Glossário

>>>

O prompt padrão do shell interativo do Python. Normalmente visto em exemplos de código que podem ser executados interativamente no interpretador.

...

O prompt padrão do shell interativo do Python ao inserir o código para um bloco de código recuado, quando dentro de um par de delimitadores correspondentes esquerdo e direito (parênteses, colchetes, chaves ou aspas triplas) ou após especificar um decorador.

2to3

Uma ferramenta que tenta converter código Python 2.x em código Python 3.x tratando a maioria das incompatibilidades que podem se detectadas com análise do código-fonte e navegação na árvore sintática.

O 2to3 está disponível na biblioteca padrão como lib2to3; um ponto de entrada é disponibilizado como Tools/scripts/2to3. Veja 2to3 - Tradução Automatizada de Código Python 2 para 3.

classe base abstrata

Classes básicas abstratas complementam tipagem pato, fornecendo uma maneira de definir interfaces quando outras técnicas, como hasattr(), seriam desajeitadas ou sutilmente erradas (por exemplo, com métodos mágicos). ABCs introduzem subclasses virtuais, que são classes que não herdam de uma classe mas ainda são reconhecidas por isinstance() e issubclass(); veja a documentação do módulo abc. O Python vem com muitas ABCs internas para estruturas de dados (no módulo collections.abc), números (no módulo numbers), fluxos (no módulo io) , localizadores e carregadores de importação (no módulo importlib.abc). Você pode criar suas próprias ABCs com o módulo: mod:abc.

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 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 a seção Chamadas 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, usar o 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.

iterável assíncrono

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

Abreviação da expressão da língua inglesa “Benevolent Dictator for Life” (em português, “Ditador Benevolente Vitalício”), referindo-se a Guido van Rossum, criador do Python.

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

A conversão implícita de uma instância de um tipo para outro durante uma operação que envolve dois argumentos do mesmo tipo. Por exemplo, int(3.15) converte o número do ponto flutuante no número inteiro 3, mas em 3+4.5, cada argumento é de um tipo diferente (um int, um float), e ambos devem ser convertidos para o mesmo tipo antes de poderem ser adicionados ou isso levantará um TypeError. Sem coerção, todos os argumentos de tipos compatíveis teriam que ser normalizados com o mesmo valor pelo programador, por exemplo, float(3)+4.5 em vez de apenas 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.

variável de contexto

Uma variável que pode ter valores diferentes, dependendo do seu contexto. Isso é semelhante ao armazenamento local do encadeamento, no qual cada encadeamento de execução pode ter um valor diferente para uma variável. No entanto, com variáveis de contexto, pode haver vários contextos em um encadeamento de execução e o principal uso para variáveis de contexto é acompanhar as variáveis em tarefas assíncronas simultâneas. Veja contextvars.

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 são uma forma mais generalizada de sub-rotinas. Sub-routinas tem a entrada iniciada em um ponto, e a saída em outro ponto. Coroutines podem entrar, sair, e continuar em muitos pontos diferentes. Elas podem ser implementadas com a instrução async def. Veja também PEP 492.

função de co-rotina

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

Uma parte da sintaxe que pode ser avaliada para algum valor. Em outras palavras, uma expressão é a acumulação de elementos de expressão como literais, nomes, atributos de acesso, operadores ou chamadas de funções, todos os quais retornam um valor. Em contraste com muitas outras linguagens, nem todas as contruções de linguagem são expressões. Também existem statement, os quais não podem ser usadas como expressões, como por exemplo while. Atribuições também são instruções, não expressões.

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.

Atualmente há três categorias de objetos arquivo: arquivos binários raw, .. XXX: sugestões para “raw” e “bufferizados”? arquivos binários bufferizados e arquivos texto. Suas interfaces estão definidas no módulo io. A forma canônica de se criar um objeto arquivo é por meio da função open().

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

Uma expressão que retorna um iterador. Parece uma expressão normal, seguido de uma cláusula for definindo uma variável de loop, um range, e uma cláusula if opcional. A expressão combinada gera valores para uma função encapsuladora:

>>> 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.

pyc baseado em hash

Um arquivo de cache em bytecode que usa hash ao invés do tempo (no qual o arquivo de código-fonte foi modificado pela última vez) para determinar a sua validade. Veja Cached bytecode invalidation.

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.

A maioria dos objetos embutidos imutáveis do Python são hasheáveis; containers mutáveis (tais como listas ou dicionários) não são; containers imutáveis (tais como tuplas e frozensets) são hasheáveis apenas se os seus elementos são hasheáveis. Objetos que são instâncias de classes definidas pelo usuário são hasheáveis por padrão. Todos eles comparam de forma desigual (exceto entre si mesmos), e o seu valor hash é derivado a partir do seu 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.

iterador

Um objeto que representa 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.

método mágico

Um sinônimo informal para um special method.

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

O termo “tupla nomeada” é aplicado a qualquer tipo ou classe que herda de tupla e cujos elementos indexáveis também são acessíveis usando atributos nomeados. O tipo ou classe pode ter outras funcionalidades também.

Diversos tipos embutidos são tuplas nomeadas, incluindo os valores retornados por time.localtime() e os.stat(). Outro exemplo é sys.float_info:

>>> sys.float_info[1]                   # indexed access
1024
>>> sys.float_info.max_exp              # named field access
1024
>>> isinstance(sys.float_info, tuple)   # kind of tuple
True

Algumas tuplas nomeadas são tipos embutidos (tal como os exemplos acima). Alternativamente, uma tupla nomeada pode ser criada a partir da definição de uma classe regular, que herde de tuple e que defina campos nomeados. Tal classe pode ser escrita a mão, ou ela pode ser criada com uma função factory collections.namedtuple(). A segunda técnica também adiciona alguns métodos extras, que podem não ser encontrados quando foi escrita manualmente, ou em tuplas nomeadas embutidas.

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.

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 instruções de atribuição anotado.

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.