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
   *statement*s 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.
