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.

...

The default Python prompt of the interactive shell when entering code for an indented code block or within a pair of matching left and right delimiters (parentheses, square brackets or curly braces).

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.

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.

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

An object that implements __aiter__() and __anext__() methods. __anext__ must return an awaitable object. async for resolves awaitable returned from asynchronous iterator’s __anext__() method until it raises StopAsyncIteration exception. Introduced by 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.

Ver também

A text file reads and writes str objects.

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.

Coerção

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

número complexo

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

Gerenciador de Contexto

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

Contíguo

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

co-rotina

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

função coroutine

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

CPython

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

decorador

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

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

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

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

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

descritor

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

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

dicionário

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

visualização de dicionário

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

docstring

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

duck-typing (tipagem pato)

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

EAFP

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

expressão

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

módulo de extensão

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

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)

An arbitrary metadata value associated with a function parameter or return value. Its syntax is explained in section Definições de função. Annotations may be accessed via the __annotations__ special attribute of a function object.

Python itself does not assign any particular meaning to function annotations. They are intended to be interpreted by third-party libraries or tools. See PEP 3107, which describes some of their potential uses.

__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)

The process of freeing memory when it is not used anymore. Python performs garbage collection via reference counting and a cyclic garbage collector that is able to detect and break reference cycles.

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.

Each yield temporarily suspends processing, remembering the location execution state (including local variables and pending try-statements). When the generator iterator resumes, it picks-up where it left-off (in contrast to functions which start fresh on every invocation).

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

An object capable of returning its members one at a time. Examples of iterables include all sequence types (such as list, str, and tuple) and some non-sequence types like dict, file objects, and objects of any classes you define with an __iter__() or __getitem__() method. Iterables can be used in a for loop and in many other places where a sequence is needed (zip(), map(), …). When an iterable object is passed as an argument to the built-in function iter(), it returns an iterator for the object. This iterator is good for one pass over the set of values. When using iterables, it is usually not necessary to call iter() or deal with iterator objects yourself. The for statement does that automatically for you, creating a temporary unnamed variable to hold the iterator for the duration of the loop. See also iterator, sequence, and generator.

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

An anonymous inline function consisting of a single expression which is evaluated when the function is called. The syntax to create a lambda function is lambda [arguments]: 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

A built-in Python sequence. Despite its name it is more akin to an array in other languages than to a linked list since access to elements are 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 Personalizando a criação de classe.

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.

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

Ver também

A binary file reads and write bytes 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).

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.

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.

See also pyvenv - Creating virtual environments.

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.