# Glossário

`>>>`

  O prompt Python padrão do shell interativo. Muitas vezes visto em exemplos de código que podem ser executados de forma interativa no interpretador.

`...`

  O prompt padrão do shell interativo do Python ao se digitar código em um bloco indentado ou dentro de um par de delimitadores direita-esquerda .. XXX: concordam com “delimitadores direita-esquerda”? (como parênteses, colchetes ou chaves).

2to3

  Uma ferramenta que tenta converter código Python 2.x para código Python 3.x lidando com a maioria das incompatibilidades que podem ser detectadas analisando o código-fonte e navegando na árvore de sintática

  2to3 is available in the standard library as `lib2to3`; a standalone entry point is provided as `Tools/scripts/2to3`. See 2to3 - Tradução Automatizada de Código Python 2 para 3.

Classe Base Abstrata

  Abstract base classes complement duck-typing by providing a way to define interfaces when other techniques like `hasattr()` would be clumsy or subtly wrong (for example with magic methods). ABCs introduce virtual subclasses, which are classes that don’t inherit from a class but are still recognized by `isinstance()` and `issubclass()`; see the `abc` module documentation. Python comes with many built-in ABCs for data structures (in the `collections.abc` module), numbers (in the `numbers` module), streams (in the `io` module), import finders and loaders (in the `importlib.abc` module). You can create your own ABCs with the `abc` module.

Anotação

  Um rótulo associado a uma variável, um atributo de classe ou um parâmetro de função ou valor de retorno, usado por convenção como: term: type hint.

  Anotações de variáveis ​​locais não podem ser acessadas em tempo de execução, mas anotações de variáveis ​​globais, atributos de classe e funções são armazenadas no atributo especial: attr: __annotations__ de módulos, classes e funções, respectivamente.

  Ver :term: variable annotation, function annotation, :pep: 484 e :pep: 526, que descrevem esta funcionalidade

Argumento

  Um valor passado para um function (ou method`) ao chamar a função. Existem dois tipos de argumento:

  - argumento nomeado: um argumento precedido por um identificador (por exemplo, `nome=`) na chamada de uma função ou passada como um valor em um dicionário precedido por `**`. Por exemplo, `3` e `5` são ambos argumentos nomeados na chamada da função `complex()` a seguir:

        complex(real=3, imag=5)
        complex(**{'real': 3, 'imag': 5})

  - argumento posicional: um argumento que não é um argumento nomeado. Argumentos posicionais podem aparecer no início da lista de argumentos e/ou podem ser passados com elementos de um iterável precedido por `*`. Por exemplo, `3` e `5` são ambos argumentos posicionais nas chamadas a seguir:

        complex(3, 5)
        complex(*(3, 5))

  Argumentos são atribuídos às variáveis locais nomeadas no corpo da função. Veja Calls para as regras de atribuição. Sintaticamente, qualquer expressão pode ser usada para representar um argumento; avaliada a expressão, o valor é atribuído à variável local.

  Veja também o termo parâmetro no glossário, a pergunta the difference between arguments and parameters na FAQ, e PEP 362.

gerenciador de contexto assíncrono

  An object which controls the environment seen in an `async with` statement by defining `__aenter__()` and `__aexit__()` methods. Introduced by PEP 492.

gerador assíncrono

  A function which returns an asynchronous generator iterator. It looks like a coroutine function defined with `async def` except that it contains `yield` expressions for producing a series of values usable in an `async for` loop.

  Normalmente se refere a uma função geradora assíncrona, mas pode se referir a um iterador gerador assíncrono em alguns contextos. Em casos em que o significado não esteja claro, o uso do termo completo evita a ambiguidade.

  Uma função geradora assíncrona pode conter expressões `await` e também `async for` e `async with`.

gerador iterador assíncrono

  Um objeto criado por uma função asynchronous generator.

  Este é um iterador assíncrono que, quando chamado usando o método `__anext__()`, retorna um objeto aguardável que executará o corpo da função de gerador assíncrono até a próxima expressão `yield`.

  Cada `yield` suspende temporariamente o processamento, lembrando o estado de execução do local (incluindo variáveis locais e instruções de tentativa pendentes). Quando o iterador do gerador assíncrono efetivamente é retomado com outro retorno esperado por `__anext__()`, ele inicia de onde parou. Veja PEP 492 e PEP 525.

assíncrono iterável

  Um objeto que pode ser usado em uma instrução `async for`. Deve retornar um iterador assíncrono do seu método `__aiter__()`. Introduzido por PEP 492.

Iterador assíncrono

  Um objeto que implementa os métodos `__aiter__()` e `__anext__()`. `__anext__` deve retornar um objeto aguardável. `async for` resolve os aguardáveis retornados por um método `__anext__()` do iterador assíncrono até que ele levante uma exceção `StopAsyncIteration`. Introduzido pela PEP 492.

Atributo

  Um valor associado a um objeto que é referenciado pelo nome separado por um ponto. Por exemplo, se um objeto o tem um atributo a esse seria referenciado como o.a.

aguardável

  Um objeto que pode ser usado em uma expressão `await`. Pode ser uma coroutine ou um objeto com um método `__await__()`. Veja também a PEP 492.

BDFL

  Benevolent Dictator For Life, a.k.a. Guido van Rossum, Python’s creator.

Arquivo Binário

  Um objeto arquivo capaz de ler e gravar em objetos byte ou similar. Exemplos de arquivos binários são arquivos abertos no modo binário (`'rb'`, `'wb'` ou `'rb+'`), `sys.stdin.buffer`, `sys.stdout.buffer` e instâncias de `io.BytesIO` e `gzip.GzipFile`.

  Veja também arquivo texto para um arquivo objeto capaz de ler e gravar em objetos `str`.

objeto byte ou similar

  Um objeto que suporta o Protocolo de Buffer e pode exportar um buffer C contíguo. Isso inclui todos os objetos `bytes`, `bytearray` e `array.array`, além de muitos objetos comuns `memoryview`. Objetos byte ou similar podem ser usados para várias operações que funcionam com dados binários; isso inclui compactação, salvamento em um arquivo binário e envio por um soquete.

  Algumas operações precisam que os dados binários sejam mutáveis. A documentação geralmente se refere a eles como “objetos byte ou similiar para leitura-escrita”. Exemplos de objetos de buffer mutável incluem `bytearray` e um `memoryview` de um `bytearray`. Outras operações exigem que os dados binários sejam armazenados em objetos imutáveis (“objetos byte ou similar para somente leitura”); exemplos disso incluem `bytes` e a `memoryview` de um objeto `bytes`.

bytecode

  Python source code is compiled into bytecode, the internal representation of a Python program in the CPython interpreter. The bytecode is also cached in `.pyc` files so that executing the same file is faster the second time (recompilation from source to bytecode can be avoided). This “intermediate language” is said to run on a virtual machine that executes the machine code corresponding to each bytecode. Do note that bytecodes are not expected to work between different Python virtual machines, nor to be stable between Python releases.

  A list of bytecode instructions can be found in the documentation for the dis module.

Classe

  A template for creating user-defined objects. Class definitions normally contain method definitions which operate on instances of the class.

variável de classe

  Uma variável definida em uma classe e destinada a ser modificada apenas no nível da classe (ou seja, não em uma instância da classe).

Coerção

  The implicit conversion of an instance of one type to another during an operation which involves two arguments of the same type. For example, `int(3.15)` converts the floating point number to the integer `3`, but in `3+4.5`, each argument is of a different type (one int, one float), and both must be converted to the same type before they can be added or it will raise a `TypeError`. Without coercion, all arguments of even compatible types would have to be normalized to the same value by the programmer, e.g., `float(3)+4.5` rather than just `3+4.5`.

número complexo

  An extension of the familiar real number system in which all numbers are expressed as a sum of a real part and an imaginary part. Imaginary numbers are real multiples of the imaginary unit (the square root of `-1`), often written `i` in mathematics or `j` in engineering. Python has built-in support for complex numbers, which are written with this latter notation; the imaginary part is written with a `j` suffix, e.g., `3+1j`. To get access to complex equivalents of the `math` module, use `cmath`. Use of complex numbers is a fairly advanced mathematical feature. If you’re not aware of a need for them, it’s almost certain you can safely ignore them.

Gerenciador de Contexto

  An object which controls the environment seen in a `with` statement by defining `__enter__()` and `__exit__()` methods. See PEP 343.

Contíguo

  Um buffer é considerado contíguo exatamente se for *contíguo C * ou *contíguo Fortran *. Os buffers de dimensão zero são contíguos C e Fortran. Em matrizes unidimensionais, os itens devem ser dispostos na memória próximos um do outro, em ordem crescente de índices, começando do zero. Em matrizes multidimensionais contíguas C, o último índice varia mais rapidamente ao visitar itens em ordem de endereço de memória. No entanto, nas matrizes contíguas do Fortran, o primeiro índice varia mais rapidamente.

co-rotina

  Coroutines is a more generalized form of subroutines. Subroutines are entered at one point and exited at another point. Coroutines can be entered, exited, and resumed at many different points. They can be implemented with the `async def` statement. See also PEP 492.

função coroutine

  Uma função que retorna um objeto do tipo coroutine. Uma função coroutine pode ser definida com a instrução `async def`, e pode conter as palavras chaves `await`, `async for`, e `async with`. Isso foi introduzido pela PEP 492.

CPython

  The canonical implementation of the Python programming language, as distributed on python.org. The term “CPython” is used when necessary to distinguish this implementation from others such as Jython or IronPython.

decorador

  Uma função que retorna outra função, geralmente aplicada como uma transformação de função usando a sintaxe `@wrapper`. Exemplos comuns para decoradores são `classmethod()` e `staticmethod()`.

  A sintaxe do decorador é meramente um açúcar-sintático, as duas definições de funções a seguir são semanticamente equivalentes:

      def f(...):
          ...
      f = staticmethod(f)

      @staticmethod
      def f(...):
          ...

  O mesmo conceito existe para as classes, mas não é comumente utilizado. Veja a documentação de function definitions e class definitions para obter mais informações sobre decoradores.

descritor

  Any object which defines the methods `__get__()`, `__set__()`, or `__delete__()`. When a class attribute is a descriptor, its special binding behavior is triggered upon attribute lookup. Normally, using a.b to get, set or delete an attribute looks up the object named b in the class dictionary for a, but if b is a descriptor, the respective descriptor method gets called. Understanding descriptors is a key to a deep understanding of Python because they are the basis for many features including functions, methods, properties, class methods, static methods, and reference to super classes.

  Para obter mais informações sobre os métodos dos descritores, veja: Implementando descritores.

dicionário

  Um Array associativo em que chaves arbitrárias são mapeadas para valores. As chaves podem ser quaisquer objetos que possuam os métodos `__hash__()` e `__eq__()`. Dicionários são estruturas chamadas de hash na linguagem Perl.

visualização de dicionário

  Os objetos retornados por `dict.keys()`, `dict.values()` e `dict.items()` são chamados de Views de Dicionário. Eles fornecem uma visualização dinâmica das entradas do dicionário, o que significa que quando o dicionário é alterado, a View reflete essas alterações. Para forçar a View do dicionário a se tornar uma lista completa use `list(dictview)`. Veja: ref:dict-views.

docstring

  Uma string literal que aparece como primeira expressão numa classe, função ou módulo. Ainda que sejam ignoradas quando a suíte é executada, é reconhecida pelo compilador que a coloca no atributo `__doc__` da classe, função ou módulo que a encapsula. Como ficam disponíveis por meio de introspecção, docstrings são o lugar canônico para documentação do objeto.

duck-typing (tipagem pato)

  A programming style which does not look at an object’s type to determine if it has the right interface; instead, the method or attribute is simply called or used (“If it looks like a duck and quacks like a duck, it must be a duck.”) By emphasizing interfaces rather than specific types, well-designed code improves its flexibility by allowing polymorphic substitution. Duck-typing avoids tests using `type()` or `isinstance()`. (Note, however, that duck-typing can be complemented with abstract base classes.) Instead, it typically employs `hasattr()` tests or EAFP programming.

EAFP

  Easier to ask for forgiveness than permission. This common Python coding style assumes the existence of valid keys or attributes and catches exceptions if the assumption proves false. This clean and fast style is characterized by the presence of many `try` and `except` statements. The technique contrasts with the LBYL style common to many other languages such as C.

expressão

  A piece of syntax which can be evaluated to some value. In other words, an expression is an accumulation of expression elements like literals, names, attribute access, operators or function calls which all return a value. In contrast to many other languages, not all language constructs are expressions. There are also statements which cannot be used as expressions, such as `if`. Assignments are also statements, not expressions.

módulo de extensão

  Um módulo escrito em C ou C++, usando a API C de Python para interagir tanto com código de usuário quanto do núcleo.

f-string

  Literais string prefixadas com `'f'` ou `'F'` são conhecidas como “f-strings” que é uma abreviação de formatted string literals. Veja também PEP 498.

file object (arquivo objeto)

  Um objeto que expõe uma API orientada a arquivos (com métodos tais como `read()` ou `write()`) para um recurso subjacente. Dependendo da maneira como foi criado, um objeto arquivo pode mediar o acesso a um arquivo real no disco ou outro tipo de dispositivo de armazenamento ou de comunicação (por exemplo a entrada/saída padrão, buffers em memória, sockets, pipes, etc.). Objetos arquivo também são chamados de file-like objects ou streams.

  There are actually three categories of file objects: raw binary files, buffered binary files and text files. Their interfaces are defined in the `io` module. The canonical way to create a file object is by using the `open()` function.

file-like object (objeto como a um arquivo)

  Um sinônimo do termo file object.

finder

  An object that tries to find the loader for a module that is being imported.

  Desde o Python 3.3, existem dois tipos de localizadores: meta path finders para uso com `sys.meta_path`, e path entry finders para uso com `sys.path_hooks`.

  Veja PEP 302, PEP 420 e PEP 451 para maiores informações.

divisão pelo piso

  Mathematical division that rounds down to nearest integer. The floor division operator is `//`. For example, the expression `11 // 4` evaluates to `2` in contrast to the `2.75` returned by float true division. Note that `(-11) // 4` is `-3` because that is `-2.75` rounded downward. See PEP 238.

function (função)

  A series of statements which returns some value to a caller. It can also be passed zero or more arguments which may be used in the execution of the body. See also parameter, method, and the Definições de função section.

function annotation (anotação de função)

  Uma annotation de um parâmetro ou retorno de uma função.

  Anotações de função são comumente usados por type hints: por exemplo, essa função espera receber dois argumentos `int` e também é esperado que devolva um valor `int`:

      def sum_two_numbers(a: int, b: int) -> int:
         return a + b

  A sintaxe de anotação de uma função é explicada na seção Definições de função.

  Veja variable annotation e PEP 484, que descrevem essa funcionalidade.

__future__

  A pseudo-module which programmers can use to enable new language features which are not compatible with the current interpreter.

  Ao importar o módulo `__future__` e avaliar suas variáveis, você pode ver quando uma nova funcionalidade foi adicionada pela primeira vez à linguagem e quando ela se tornará padrão:

      >>> import __future__
      >>> __future__.division
      _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection (coletor de lixo)

  O processo de liberar a memória quando ela não é mais utilizada. Python executa a liberação da memória através da contagem de referências e um coletor de lixo cíclico que é capaz de detectar e interromper referências cíclicas. O coletor de lixo pode ser controlado usando o módulo `gc`.

gerador

  A function which returns a generator iterator. It looks like a normal function except that it contains `yield` expressions for producing a series of values usable in a for-loop or that can be retrieved one at a time with the `next()` function.

  Normalmente refere-se a uma função geradora, mas pode referir-se a um iterador gerador em alguns contextos. Em alguns casos onde o significado desejado não está claro, usar o termo completo evita ambiguidade.

iterador gerador

  Um objeto criado por uma função gerador.

  Cada `yield` suspende temporariamente o processamento, memorizando o estado da execução local (incluindo variáveis locais e instruções try pendentes). Quando o iterador gerador retorna, ele se recupera do último ponto onde estava (em contrapartida as funções que iniciam uma nova execução a cada vez que são invocadas).

generator expression

  An expression that returns an iterator. It looks like a normal expression followed by a `for` expression defining a loop variable, range, and an optional `if` expression. The combined expression generates values for an enclosing function:

      >>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
      285

generic function (função genérica)

  Uma função composta por multiplas funções implementando a mesma operação para diferentes tipos. Qual implementação deverá ser usada durante a execução é determinada pelo algoritmo de despacho.

  Veja também a entrada single dispatch no glossário, o decorador `functools.singledispatch()`, e a PEP 443.

GIL

  Veja global interpreter lock.

global interpreter lock (bloqueio global do intérprete)

  The mechanism used by the CPython interpreter to assure that only one thread executes Python bytecode at a time. This simplifies the CPython implementation by making the object model (including critical built-in types such as `dict`) implicitly safe against concurrent access. Locking the entire interpreter makes it easier for the interpreter to be multi-threaded, at the expense of much of the parallelism afforded by multi-processor machines.

  However, some extension modules, either standard or third-party, are designed so as to release the GIL when doing computationally-intensive tasks such as compression or hashing. Also, the GIL is always released when doing I/O.

  Past efforts to create a “free-threaded” interpreter (one which locks shared data at a much finer granularity) have not been successful because performance suffered in the common single-processor case. It is believed that overcoming this performance issue would make the implementation much more complicated and therefore costlier to maintain.

hashable

  An object is hashable if it has a hash value which never changes during its lifetime (it needs a `__hash__()` method), and can be compared to other objects (it needs an `__eq__()` method). Hashable objects which compare equal must have the same hash value.

  Hashability makes an object usable as a dictionary key and a set member, because these data structures use the hash value internally.

  All of Python’s immutable built-in objects are hashable; mutable containers (such as lists or dictionaries) are not. Objects which are instances of user-defined classes are hashable by default. They all compare unequal (except with themselves), and their hash value is derived from their `id()`.

IDLE

  Um ambiente de desenvolvimento integrado para Python. IDLE é um editor básico e um ambiente interpretador que vem junto com a distribuição padrão do Python.

imutável

  Um objeto que possui um valor fixo. Objetos imutáveis incluem números, strings e tuplas. Estes objetos não podem ser alterados. Um novo objeto deve ser criado se um valor diferente tiver de ser armazenado. Objetos imutáveis têm um papel importante em lugares onde um valor constante de hash seja necessário, como por exemplo uma chave em um dicionário.

import path

  Uma lista de localizações (ou path entries) que são buscadas pelo path based finder por módulos para importar. Durante a importação, esta lista de localizações usualmente vem a partir de `sys.path`, mas para sub-pacotes ela também pode vir do atributo `__path__` de pacotes-pai.

importando

  O processo pelo qual o código Python em um módulo é disponibilizado para o código Python em outro módulo.

importer

  Um objeto que localiza e carrega um módulo; Tanto um finder e o objeto loader.

interactive

  Python has an interactive interpreter which means you can enter statements and expressions at the interpreter prompt, immediately execute them and see their results. Just launch `python` with no arguments (possibly by selecting it from your computer’s main menu). It is a very powerful way to test out new ideas or inspect modules and packages (remember `help(x)`).

interpretado

  Python é uma linguagem interpretada, em oposição àquelas que são compiladas, embora esta distinção possa ser nebulosa devido à presença do compilador de bytecode. Isto significa que os arquivos-fontes podem ser executados diretamente sem necessidade explícita de se criar um arquivo executável. Linguagens interpretadas normalmente têm um ciclo de desenvolvimento/depuração mais curto que as linguagens compiladas, apesar de seus programas geralmente serem executados mais lentamente. Veja também interativo.

interpreter shutdown

  Quando solicitado para desligar, o interpretador Python entra em uma fase especial, onde ele gradualmente libera todos os recursos alocados, tais como módulos e várias estruturas internas críticas. Ele também faz diversas chamadas para o garbage collector. Isto pode disparar a execução de código em destrutores definidos pelo usuário ou callbacks de referência fraca. Código executado durante a fase de desligamento pode encontrar diversas exceções, pois os recursos que ele depende podem não funcionar mais (exemplos comuns são os módulos de bibliotecas, ou os mecanismos de avisos).

  A principal razão para o interpretador desligar, é que o módulo `__main__` ou o script sendo executado terminou sua execução.

iterável

  Um objeto capaz de retornar seus membros um de cada vez. Exemplos de iteráveis incluem todos os tipos de sequência (tais como `list`, `str` e `tuple`) e alguns tipos de não-sequência, como o `dict`, file objects, além dos objetos de quaisquer classes que você definir com um método `__iter__()` ou `__getitem__()` que implementam a semântica de sequência .

  Iteráveis podem ser usados em um laço `for` e em vários outros lugares em que uma sequência é necessária (`zip()`, `map()`, …). Quando um objeto iterável é passado como argumento para a função nativa `iter()`, ela retorna um iterador para o objeto. Este iterador é adequado para se varrer todo o conjunto de valores. Ao usar iteráveis, normalmente não é necessário chamar `iter()` ou lidar com os objetos iteradores em si. A instrução `for` faz isso automaticamente para você, criando uma variável temporária para armazenar o iterador durante a execução do laço. Veja também iterador, sequência, e gerador.

iterator

  Um objeto que represent um fluxo de dados. Repetidas chamadas ao método `__next__()` de um iterador (ou passando o objeto para a função nativa `next()`) vão retornar itens sucessivos do fluxo. Quando não houver mais dados disponíveis uma exceção `StopIteration` exception será levantada. Neste ponto, o objeto iterador se esgotou e quaisquer chamadas subsequentes a seu método `__next__()` vão apenas levantar a exceção `StopIteration` novamente. Iteradores precisam ter um método `__iter__()` que retorne o objeto iterador em si, de forma que todo iterador também é iterável e pode ser usado na maioria dos lugares em que um iterável é requerido. Uma notável exceção é código que tenta realizar passagens em múltiplas iterações. Um objeto contêiner (como uma `list`) produz um novo iterador a cada vez que você passá-lo para a função `iter()` ou utilizá-lo em um laço `for`. Tentar isso com o mesmo iterador apenas iria retornar o mesmo objeto iterador esgotado já utilizado na iteração anterior, como se fosse um contêiner vazio.

  Mais informações podem ser encontradas em Tipos de Iteradores.

Função chave

  A key function or collation function is a callable that returns a value used for sorting or ordering. For example, `locale.strxfrm()` is used to produce a sort key that is aware of locale specific sort conventions.

  A number of tools in Python accept key functions to control how elements are ordered or grouped. They include `min()`, `max()`, `sorted()`, `list.sort()`, `heapq.merge()`, `heapq.nsmallest()`, `heapq.nlargest()`, and `itertools.groupby()`.

  There are several ways to create a key function. For example. the `str.lower()` method can serve as a key function for case insensitive sorts. Alternatively, a key function can be built from a `lambda` expression such as `lambda r: (r[0], r[2])`. Also, the `operator` module provides three key function constructors: `attrgetter()`, `itemgetter()`, and `methodcaller()`. See the Sorting HOW TO for examples of how to create and use key functions.

keyword argument (Argumento de Palavra-Chave)

  Veja o argument.

lambda

  Uma função de linha anônima consistindo de uma única expression, que é avaliada quando a função é chamada. A sintaxe para criar uma função lambda é `lambda [parameters]: expression`

LBYL

  Look before you leap. This coding style explicitly tests for pre-conditions before making calls or lookups. This style contrasts with the EAFP approach and is characterized by the presence of many `if` statements.

  In a multi-threaded environment, the LBYL approach can risk introducing a race condition between “the looking” and “the leaping”. For example, the code, `if key in mapping: return mapping[key]` can fail if another thread removes key from mapping after the test, but before the lookup. This issue can be solved with locks or by using the EAFP approach.

list

  Uma sequence embutida no Python. Apesar do seu nome, é mais próximo de um vetor em outras linguagens do que uma lista encadeada, como o acesso aos elementos é da ordem O(1).

list comprehension

  A compact way to process all or part of the elements in a sequence and return a list with the results. `result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]` generates a list of strings containing even hex numbers (0x..) in the range from 0 to 255. The `if` clause is optional. If omitted, all elements in `range(256)` are processed.

carregador

  An object that loads a module. It must define a method named `load_module()`. A loader is typically returned by a finder. See PEP 302 for details and `importlib.abc.Loader` for an abstract base class.

mapeando

  A container object that supports arbitrary key lookups and implements the methods specified in the `Mapping` or `MutableMapping` abstract base classes. Examples include `dict`, `collections.defaultdict`, `collections.OrderedDict` and `collections.Counter`.

meta path finder

  Um finder retornado por uma busca de `sys.meta_path`. Meta localizadores de diretórios são relacionados a, mas diferentes de path entry finders.

  Veja `importlib.abc.MetaPathFinder` para os métodos que meta localizadores de diretórios implementam.

metaclass

  The class of a class. Class definitions create a class name, a class dictionary, and a list of base classes. The metaclass is responsible for taking those three arguments and creating the class. Most object oriented programming languages provide a default implementation. What makes Python special is that it is possible to create custom metaclasses. Most users never need this tool, but when the need arises, metaclasses can provide powerful, elegant solutions. They have been used for logging attribute access, adding thread-safety, tracking object creation, implementing singletons, and many other tasks.

  More information can be found in Metaclasses.

method (método)

  A function which is defined inside a class body. If called as an attribute of an instance of that class, the method will get the instance object as its first argument (which is usually called `self`). See function and nested scope.

method resolution order (ordem de resolução de método)

  Method Resolution Order is the order in which base classes are searched for a member during lookup. See The Python 2.3 Method Resolution Order for details of the algorithm used by the Python interpreter since the 2.3 release.

módulo

  Um objeto que serve como uma unidade organizacional de código Python. Os módulos têm um namespace contendo objetos Python arbitrários. Os módulos são carregados pelo Python através do processo de: term: importing.

  Veja também package.

module spec (módulo spec)

  Uma namespace que contém as informações relacionadas à importação usadas para carregar um módulo. Uma instância de class:importlib.machinery.ModuleSpec.

MRO

  See method resolution order.

mutable (mutável)

  Objeto mutável é aquele que pode modificar seus valor mas manter seu `id()`. Veja também immutable.

named tuple

  Qualquer classe semelhante a uma tupla cujos elementos indexados também sejam acessíveis por meio de atributos nomeados (como exemplo, tem-se o `time.localtime()` que devolve um objeto semelhante à uma tupla em que o ano é acessível tanto através de um índice, como `t[0]`, quanto por um atributo nomeado como `t.tm_year`).

  A named tuple can be a built-in type such as `time.struct_time`, or it can be created with a regular class definition. A full featured named tuple can also be created with the factory function `collections.namedtuple()`. The latter approach automatically provides extra features such as a self-documenting representation like `Employee(name='jones', title='programmer')`.

namespace

  O lugar em que uma variável é armazenada. Namespaces são implementados como dicionários. Existem os namespaces local, global e nativo, bem como namespaces aninhados em objetos (em métodos). Namespaces suportam modularidade ao previnir conflitos de nomes. Por exemplo, as funções `__builtin__.open()` e `os.open()` são diferenciadas por seus namespaces. Namespaces também auxiliam na legibilidade e na manutenibilidade ao torar mais claro quais módulos implementam uma função. Escrever `random.seed()` ou `itertools.izip()`, por exemplo, deixa claro que estas funções são implementadas pelos módulos `random` e `itertools` respectivamente.

namespace package (espaço de nomes do pacote)

  Um package PEP 420 que serve apenas como container para sub pacotes. Pacotes de namespaces podem não ter representação física, e especificamente não são como um regular package porque eles não tem um arquivo `__init__.py`.

  Veja também module.

nested scope (escopo aninhado)

  A habilidade de referir-se a uma variável em uma definição de fechamento. Por exemplo, uma função definida dentro de outra pode referenciar variáveis da função externa. Perceba que escopos aninhados por padrão funcionam apenas por referência e não por atribuição. Variáveis locais podem ler e escrever no escopo mais interno. De forma similar, variáveis globais podem ler e escrever para o namespace global. O `nonlocal` permite escrita para escopos externos.

new-style class (novo estilo de classes)

  Antigo nome para o tipo de classes agora usado para todos os objetos de classes. Em versões anteriores do Python, apenas classes com o novo estilo podiam usar recursos novos e versáteis do Python, tais como `__slots__`, descritores, propriedades, `__getattribute__()`, métodos de classe, e métodos estáticos.

object (objeto)

  Qualquer dado que tenha estado (atributos ou valores) e comportamento definidos (métodos). Também a última classe base de qualquer new-style class.

pacote

  Um module Python é capaz de conter submódulos ou recursivamente, sub-pacotes. Tecnicamente, um pacote é um módulo Python com um atributo `__path__`.

  Veja também regular package e namespace package.

parameter (parâmetro)

  Uma entidade nomeada na definição de uma função (ou método) que específica um argumento (ou em alguns casos, argumentos) que a função pode receber. Existem cinco tipos de parâmetros:

  - posicional-ou-nomeado: especifica um argumento que pode ser tanto posicional quanto nomeado. Esse é o tipo padrão de parâmetro, por exemplo foo e bar a seguir:

        def func(foo, bar=None): ...

  - somente-posicional: especifica um argumento que pode ser passado para a função somente por posição. Python não possui sintaxe para definir parâmetros somente-posicionais. Contudo, algumas funções embutidas possuem argumentos somente-posicionais (por exemplo, `abs()`).

  - somente-nomeado: especifica um argumento que pode ser passado para a função somente por nome. Parâmetros somente-nomeados podem ser definidos com um simples parâmetro var-posicional ou um `*` antes deles na lista de parâmetros na definição da função, por exemplo kw_only1 and kw_only2 a seguir:

        def func(arg, *, kw_only1, kw_only2): ...

  - var-posicional: especifica quem uma sequência arbitrária de argumentos posicionais pode ser fornecida (em adição a qualquer argumento posicional já aceito por outros parâmetros). Tal parâmetro pode ser definido colocando um `*` antes do nome, por exemplo args a seguir:

        def func(*args, **kwargs): ...

  - var-nomeado: especifica que, arbitrariamente, muitos argumentos nomeados podem ser fornecidos (em adição a qualquer argumento nomeado já aceito por outros parâmetros). Tal parâmetro pode definido colocando-se `**` antes do nome, por exemplo kwargs no exemplo acima.

  Parâmetros podem especificar tanto argumentos opcionais quanto obrigatórios, assim como valores padrões para alguns argumentos opcionais.

  Veja o termo argument no glossario, a questão :ref:` sobre a diferença entre argumentos e parâmetros <faq-argument-vs-parameter>` na FAQ, a classe `inspect.Parameter`, a seçã Definições de função, e PEP 362.

entrada de caminho

  Um local único no term:import path que o path based finder consulta para encontrar módulos a serem importados.

path entry finder (localizador de entrada de path)

  Um finder retornado por um callable em `sys.path_hooks` (ou seja, um path entry hook) que sabe como localizar os módulos path entry.

  Veja `importlib.abc.PathEntryFinder` para os métodos implementadores da entrada do path.

path entry hook (hook do path de entrada)

  Um callable na lista `sys.path_hook` que retorna um path entry finder caso saiba como encontrar módulos em um local específico path entry.

path based finder

  Uma das opções padrãot meta path finders que será procurado por módulos import path.

objeto caminho ou similar

  Um objeto representando um arquivo de caminho do sistema. Um objeto caminho ou similar é ou um objeto `str` ou `bytes` representando um caminho, ou um objeto implementando o protocolo `os.PathLike`. Um objeto que suporta o protocolo `os.PathLike` pode ser convertido para um arquivo de caminho do sistema `str` ou `bytes`, através da chamada da função `os.fspath()`; `os.fsdecode()` e `os.fsencode()` podem ser usadas para garantir um `str` ou `bytes` como resultado, respectivamente. Introduzido na PEP 519.

PEP

  Proposta de melhoria do Python. Uma PEP é um documento de design que fornece informação para a comunidade Python, ou descreve uma nova funcionalidade para o Python ou seus predecessores ou ambientes. PEPs devem prover uma especificação técnica concisa e um racional para funcionalidades propostas.

  PEPs tem a intenção de ser os mecanismos primários para propor novas funcionalidades significativas, para coletar opiniões da comunidade sobre um problema, e para documentar as decisões de design que foram adicionadas ao Python. O autor da PEP é responsável por construir um consenso dentro da comunidade e documentar opiniões dissidentes.

  Veja PEP 1.

parte

  Um conjunto de arquivos em um único diretório (possivelmente armazenado em um arquivo zip) que contribuem para um pacote de namespace, conforme definido em PEP 420.

positional argument (argumento posicional)

  Veja o argument.

API provisória

  Uma API provisória é uma API que foi deliberadamente excluída das bibliotecas padrões com compatibilidade retroativa garantida. Enquanto mudanças maiores para tais interfaces não são esperadas, contanto que elas sejam marcadas como provisórias, mudanças retroativas incompatíveis (até e incluindo a remoção da interface) podem ocorrer se consideradas necessárias pelos desenvolvedores principais. Tais mudanças não serão feitas gratuitamente – elas irão ocorrer apenas se sérias falhas fundamentais forem descobertas, que foram esquecidas anteriormente a inclusão da API.

  Mesmo para APIs provisórias, mudanças retroativas incompatíveis são vistas como uma “solução em último caso” - cada tentativa ainda será feita para encontrar uma resolução retroativa compatível para quaisquer problemas encontrados.

  Esse processo permite que a biblioteca padrão continue a evoluir com o passar do tempo, sem se prender em erros de design problemáticos por períodos de tempo prolongados. Veja PEP 411 para mais detalhes.

pacote provisório

  Veja provisional API.

Python 3000

  Apelido para a versão do Python 3.x linha de lançamento (cunhado há muito tempo, quando o lançamento da versão 3 era algo em um futuro muito distante.) Esse termo possui a seguinte abreviação: “Py3k”.

Pythonic

  Uma ideia ou um pedaço de código que segue de perto os idiomas mais comuns da linguagem Python, ao invés de implementar códigos usando conceitos comuns a outros idiomas. Por exemplo, um idioma comum em Python é fazer um loop sobre todos os elementos de uma iterável usando a instrução: for statement. Muitas outras línguas não têm esse tipo de construção, então as pessoas que não estão familiarizadas com o Python usam um contador numérico:

      for i in range(len(food)):
          print(food[i])

  Ao contrário do método limpo, ou então, Pythônico:

      for piece in food:
          print(piece)

qualified name (nome qualificado)

  Um nome pontilhado (quando 2 termos são ligados por um ponto) que mostra o “path” do escopo global de um módulo para uma classe, função ou método definido num determinado módulo, conforme definido pela PEP 3155. Para funções e classes de nível superior, o nome qualificado é o mesmo que o nome do objeto:

      >>> class C:
      ...     class D:
      ...         def meth(self):
      ...             pass
      ...
      >>> C.__qualname__
      'C'
      >>> C.D.__qualname__
      'C.D'
      >>> C.D.meth.__qualname__
      'C.D.meth'

  Quando usado para se referir a módulos, o fully qualified name significa todo o caminho pontilhado para o módulo, incluindo quaisquer pacotes pai, por exemplo: `email.mime.text`:

      >>> import email.mime.text
      >>> email.mime.text.__name__
      'email.mime.text'

reference count

  O número de refrências para um objeto. Quando a contagem de referências de um objeto atinge zero, ele é desalocado. Contagem de referências geralmente não é visível no código Python, mas é um elemento chave da implementação CPython. O módulo `sys` define a função `getrefcount()` que programadores podem chamar para retornar a contagem de referências para um objeto em particular.

regular package

  Um package tradicional, como um diretório contendo um arquivo `__init __. py`.

  Veja também namespace package.

__slots__

  A declaração dentro de uma classe que salva memória através de pré-declarações de espaço para atributos des instâncias, e eliminando dicionários de instâncias. Apesar de popular, a técnica é um tanto quanto complicada de acertar, e é melhor se for reservada para casos raros, onde existe uma grande quantidade de instâncias em uma aplicação onde a memória é crítica.

sequência

  Um iterable com suporte para acesso eficiente a seus elementos através de índices inteiros via método especial `__getitem__()` e que define o método `__len__()` que devolve o tamanho da sequência. Alguns tipos de sequência nativos são: `list`, `str`, `tuple`, e `bytes`. Note que `dict` também tem suporte para `__getitem__()` e `__len__()`, mas é considerado um mapa e não uma sequência porque a busca usa uma chave imutável arbitrária em vez de inteiros.

  A classe base abstrata `collections.abc.Sequence` define uma interface mais rica que vai além de apenas `__getitem__()` e `__len__()`, adicionando `count()`, `index()`, `__contains__()`, e `__reversed__()`. Tipos que implementam essa interface podem ser explicitamente registrados usando `register()`.

single dispatch (despacho único)

  Uma forma do generic function despacho onde a implementação é escolhida com base no tipo de um único argumento.

slice

  Um objeto geralmente contendo uma parte de uma sequence. Uma fatia é criada usando a notação de subscrito `[]` pode conter também até dois pontos entre números, como em `variable_name[1:3:5]`. A notação de suporte (subscrito) utiliza objetos `slice` internamente.

método especial

  Um método que é chamado implicitamente pelo Python para executar uma certa operação em um tipo, como uma adição por exemplo. Tais métodos tem nomes iniciando e terminando com dois underscores. Métodos especiais sestão documentados em Nomes de métodos especiais.

declaração

  Uma instrução é parte de uma suíte (um “bloco” de código). Uma instrução é ou uma expression ou uma de várias construções com uma palavra-chave, tal como `if`, `while` ou `for`.

struct sequence

  A tuple with named elements. Struct sequences expose an interface similar to named tuple in that elements can be accessed either by index or as an attribute. However, they do not have any of the named tuple methods like `_make()` or `_asdict()`. Examples of struct sequences include `sys.float_info` and the return value of `os.stat()`.

codificador de texto

  Um codec que codifica strings Unicode para bytes.

arquivo texto

  Um file object apto a ler e escrever objetos `str`. Geralmente, um arquivo texto, na verdade, acesse um fluxo de dados de bytes e captura o text encoding automaticamente. Exemplos de arquivos texto são: arquivos abertos em modo texto (`'r'` or `'w'`), `sys.stdin`, `sys.stdout`, e instâncias de `io.StringIO`.

  Veja também binary file para um objeto arquivo apto a ler e escrever bytes-like objects.

aspas triplas

  Uma string que está definida com três ocorrências de aspas duplas (“) ou apóstrofes (‘). Enquanto elas não fornecem nenhuma funcionalidade não disponível com strings de aspas simples, elas são úteis para inúmeras razões. Elas permitem que você inclua aspas simples e duplas não encerradas dentro de uma string, e elas podem utilizar múltiplas linhas sem o uso de caracteres de continuação, fazendo-as especialmente úteis quando escrevemos documentação em docstrings.

tipo

  O tipo de um objeto Python determina qual tipo de objeto ele é; todos objetos tem um tipo. Um tipo de objeto é acessivel pelo atributo `__class__` ou pode ser recuperado com `type(obj)`.

tipo alias

  Um sinônimo para tipo, criado através da atribuição do tipo para um identificador.

  Tipos alias são úteis para simplificar type hints. Por exemplo:

      from typing import List, Tuple

      def remove_gray_shades(
              colors: List[Tuple[int, int, int]]) -> List[Tuple[int, int, int]]:
          pass

  pode tornar-se mais legível desta forma:

      from typing import List, Tuple

      Color = Tuple[int, int, int]

      def remove_gray_shades(colors: List[Color]) -> List[Color]:
          pass

  Veja `typing` e PEP 484, o qual descreve esta funcionalidade.

dica do tipo

  Uma annotation que especifica o tipo esperado para uma variável, um atributo de classe, ou um parâmetro de função ou um valor de retorno.

  Dicas de tipo são opcionais e não são forçadas pelo Python, mas elas são úteis para ferramentas de análise estática de tipos, e ajudam IDEs a completar e refatorar código.

  Dicas de tipos de variáveis globais, atributos de classes, e funções, mas não de variáveis locais, podem ser acessadas usando `typing.get_type_hints()`.

  Veja `typing` e PEP 484, o qual descreve esta funcionalidade.

Novas linhas universais

  Uma maneira de interpretar fluxos de textos, na qual todos estes são reconhecidos como caracteres de encerramento de linha: a convenção para fim-de-linha no Unix `'\n'`, a convenção no Windows `'\r\n'`, e a antiga convenção no Macintosh `'\r'`. Veja PEP 278 e PEP 3116, bem como `bytes.splitlines()` para uso adicional.

anotação variável

  Uma annotation de uma variável ou um atributo de classe.

  Ao fazer uma anotação de uma variável ou atributo de classe, a atribuição é opcional:

      class C:
          field: 'annotation'

  Variable annotations are usually used for type hints: for example this variable is expected to take `int` values:

      count: int = 0

  A sintaxe de anotação de variável é explicada na seção Annotated assignment statements.

  Veja function annotation, PEP 484 e PEP 526, que descrevem esta funcionalidade.

ambiente virtual

  Um ambiente de execução isolado que permite usuários Python e aplicações instalarem e atualizarem pacotes Python sem interferir no comportamento de outras aplicações Python em execução no mesmo sistema.

  Veja também `venv`.

virtual machine

  Um computador definido inteiramente em software. A máquina virtual de Python executa o bytecode emitido pelo compilador de bytecode.

Zen of Python

  Lista de princípios de projeto e filosofias do Python que são úteis para a compreensão e uso da linguagem. A lista é exibida quando se digita “`import this`” no console interativo.