Funções embutidas¶
O interpretador do Python possui várias funções e tipos embutidos que sempre estão disponíveis. A seguir listamos todas as funções em ordem alfabética.
Funções embutidas |
|||
---|---|---|---|
- abs(x)¶
Retorna o valor absoluto de um número. O argumento pode ser um inteiro, um número de ponto flutuante ou um objeto implementando
__abs__()
. Se o argumento é um número complexo, sua magnitude é retornada.
- aiter(async_iterable)¶
Retorna um iterador assíncrono para um iterável assíncrono. Equivalente a chamar
x.__aiter__()
.Nota: Ao contrário de
iter()
,aiter()
não tem uma variante de 2 argumentos.Adicionado na versão 3.10.
- all(iterable)¶
Retorna
True
se todos os elementos de iterable são verdadeiros (ou se iterable estiver vazio). Equivalente a:def all(iterable): for elemento in iterable: if not elemento: return False return True
- awaitable anext(async_iterator)¶
- awaitable anext(async_iterator, default)
Quando aguardado, retorna o próximo item do iterador assíncrono fornecido, ou default se fornecido e o iterador for esgotado.
Esta é a variante assíncrona do
next()
embutido, e se comporta de forma semelhante.Isso chama o método
__anext__()
de async_iterator, retornando um aguardável. Ao aguardar isso, retorna o próximo valor do iterador. Se default for fornecido, ele será retornado se o iterador for esgotado, caso contrário, a exceçãoStopAsyncIteration
será levantada.Adicionado na versão 3.10.
- any(iterable)¶
Retorna
True
se algum elemento de iterable for verdadeiro. Se iterable estiver vazio, retornaFalse
. Equivalente a:def any(iterable): for elemento in iterable: if elemento: return True return False
- ascii(object)¶
Como
repr()
, retorna uma string contendo uma representação imprimível de um objeto, mas faz escape de caracteres não-ASCII na string retornada porrepr()
usando sequências de escapes\x
,\u
ou\U
. Isto gera uma string similar ao que é retornado porrepr()
no Python 2.
- bin(x)¶
Converte um número inteiro para uma string de binários prefixada com “0b”. O resultado é uma expressão Python válida. Se x não é um objeto Python
int
, ele tem que definir um método__index__()
que devolve um inteiro. Alguns exemplos:>>> bin(3) '0b11' >>> bin(-10) '-0b1010'
Se o prefixo “0b” é desejado ou não, você pode usar uma das seguintes maneiras.
>>> format(14, '#b'), format(14, 'b') ('0b1110', '1110') >>> f'{14:#b}', f'{14:b}' ('0b1110', '1110')
Veja também
format()
para mais informações.
- class bool(object=False, /)¶
Retorna um valor Booleano, isto é,
True
ouFalse
. O argumento é convertido usando o procedimento de teste de verdade padrão. Se o argumento for falso ou foi omitido, isso retornaFalse
; senãoTrue
. A classebool
é uma subclasse deint
(veja Tipos numéricos — int, float, complex). Ela não pode ser usada para criar outra subclasse. Suas únicas instâncias sãoFalse
eTrue
(veja Tipo booleano - bool).Alterado na versão 3.7: O parâmetro agora é somente-posicional
- breakpoint(*args, **kws)¶
Esta função coloca você no depurador no local da chamada. Especificamente, ela chama
sys.breakpointhook()
, passandoargs
ekws
diretamente. Por padrão,sys.breakpointhook()
chamapdb.set_trace()
não esperando nenhum argumento. Neste caso, isso é puramente uma função de conveniência para você não precisar importarpdb
explicitamente ou digitar mais código para entrar no depurador. Contudo,sys.breakpointhook()
pode ser configurado para alguma outra função ebreakpoint()
irá automaticamente chamá-la, permitindo você ir para o depurador de sua escolha. Sesys.breakpointhook()
não estiver acessível, esta função vai levantarRuntimeError
.Por padrão, o comportamento de
breakpoint()
pode ser alterado com a variável de ambientePYTHONBREAKPOINT
. Vejasys.breakpointhook()
para detalhes de uso.Observe que isso não é garantido se
sys.breakpointhook()
tiver sido substituído.Levanta um evento de auditoria
builtins.breakpoint
com o argumentobreakpointhook
.Adicionado na versão 3.7.
- class bytearray(source=b'')
- class bytearray(source, encoding)
- class bytearray(source, encoding, errors)
Retorna um novo vetor de bytes. A classe
bytearray
é uma sequência mutável de inteiros no intervalo 0 <= x < 256. Ela tem a maior parte dos métodos mais comuns de sequências mutáveis, descritas em Tipos sequências mutáveis, assim como a maior parte dos métodos que o tipobytes
tem, veja Operações com Bytes e Bytearray.O parâmetro opcional source pode ser usado para inicializar o vetor de algumas maneiras diferentes:
Se é uma string, você deve informar o parâmetro encoding (e opcionalmente, errors);
bytearray()
então converte a string para bytes usandostr.encode()
.Se é um inteiro, o vetor terá esse tamanho e será inicializado com bytes nulos.
Se é um objeto em conformidade com a interface de buffer, um buffer somente leitura do objeto será usado para inicializar o vetor de bytes.
Se é um iterável, deve ser um iterável de inteiros no intervalo
0 <= x < 256
, que serão usados como o conteúdo inicial do vetor.
Sem nenhum argumento, um vetor de tamanho 0 é criado.
Veja também Tipos de sequência binária — bytes, bytearray, memoryview e Objetos Bytearray.
- class bytes(source=b'')
- class bytes(source, encoding)
- class bytes(source, encoding, errors)
Retorna um novo objeto “bytes” que é uma sequência imutável de inteiros no intervalo
0 <= x < 256
.bytes
é uma versão imutável debytearray
– tem os mesmos métodos de objetos imutáveis e o mesmo comportamento de índices e fatiamento.Consequentemente, argumentos do construtor são interpretados como os de
bytearray()
.Objetos bytes também podem ser criados com literais, veja Literais de string e bytes.
Veja também Tipos de sequência binária — bytes, bytearray, memoryview, Objetos bytes, e Operações com Bytes e Bytearray.
- callable(object)¶
Retorna
True
se o argumento object parece ser chamável,False
caso contrário. Se retornaTrue
, ainda é possível que a chamada falhe, mas se éFalse
, chamar object nunca será bem sucedido. Note que classes são chamáveis (chamar uma classe devolve uma nova instância); instâncias são chamáveis se suas classes possuem um método__call__()
.Adicionado na versão 3.2: Esta função foi removida na versão 3.0, mas retornou no Python 3.2.
- chr(i)¶
Retorna o caractere que é apontado pelo inteiro i no código Unicode. Por exemplo,
chr(97)
retorna a string'a'
, enquantochr(8364)
retorna a string'€'
. É o inverso deord()
.O intervalo válido para o argumento vai de 0 até 1.114.111 (0x10FFFF na base 16). Será lançada uma exceção
ValueError
se i estiver fora desse intervalo.
- @classmethod¶
Transforma um método em um método de classe.
Um método de classe recebe a classe como um primeiro argumento implícito, exatamente como um método de instância recebe a instância. Para declarar um método de classe, faça dessa forma:
class C: @classmethod def f(cls, arg1, arg2): ...
O termo
@classmethod
é uma função decoradora – veja Definições de função para detalhes.Um método de classe pode ser chamado tanto da classe (como em
C.f()
) quanto da instância (como emC().f()
). A instância é ignorada, exceto por sua classe. Se um método de classe é chamado por uma classe derivada, o objeto da classe derivada é passado como primeiro argumento implícito.Métodos de classe são diferentes de métodos estáticos em C++ ou Java. Se você quer saber desses, veja
staticmethod()
nesta seção. Para mais informações sobre métodos de classe, consulte A hierarquia de tipos padrão.Alterado na versão 3.9: Métodos de classe agora podem envolver outros descritores tal como
property()
.Alterado na versão 3.10: Métodos de classe agora herdam os atributos do método (
__module__
,__name__
,__qualname__
,__doc__
e__annotations__
) e têm um novo atributo__wrapped__
.Deprecated since version 3.11, removed in version 3.13: Métodos de classe não podem mais envolver outros descritores tal como
property()
.
- compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)¶
Compila o argumento source em código ou objeto AST. Objetos código podem ser executados por
exec()
oueval()
. source pode ser uma string normal, uma string byte, ou um objeto AST. Consulte a documentação do móduloast
para saber como trabalhar com objetos AST.O argumento filename deve ser o arquivo de onde o código será lido; passe algum valor reconhecível se isso não foi lido de um arquivo (
'<string>'
é comumente usado).O argumento mode especifica qual o tipo de código deve ser compilado; pode ser
'exec'
se source consiste em uma sequência de instruções,'eval'
se consiste de uma única expressão, ou'single'
se consiste de uma única instrução interativa (neste último caso, instruções que são avaliadas para alguma coisa diferente deNone
serão exibidas).Os argumentos opcionais flags e dont_inherit controlam quais opções do compilador devem ser ativadas e quais recursos futuros devem ser permitidos. Se nenhum estiver presente (ou ambos forem zero), o código é compilado com os mesmos sinalizadores que afetam o código que está chamando
compile()
. Se o argumento flags for fornecido e dont_inherit não for (ou for zero), as opções do compilador e as instruções futuras especificadas pelo argumento flags são usadas além daquelas que seriam usadas de qualquer maneira. Se dont_inherit for um inteiro diferente de zero, então o argumento flags é – os sinalizadores (recursos futuros e opções do compilador) no código circundante são ignorados.Opções de compilador e instruções futuras são especificadas por bits, assim pode ocorrer uma operação OU bit a bit para especificar múltiplas instruções. O sinalizador necessário para especificar um dado recurso futuro pode ser encontrado no atributo
compiler_flag
na instância_Feature
do módulo__future__
. Sinalizadores de compilador podem ser encontrados no móduloast
, com o prefixoPyCF_
.O argumento optimize especifica o nível de otimização do compilador; o valor padrão de
-1
seleciona o nível de otimização do interpretador dado pela opção-O
. Níveis explícitos são0
(nenhuma otimização;__debug__
é verdadeiro),1
(instruçõesassert
são removidas,__debug__
é falso) ou2
(strings de documentação também são removidas).Essa função levanta
SyntaxError
se o código para compilar é inválido, eValueError
se o código contém bytes nulos.Se você quer analisar código Python em sua representação AST, veja
ast.parse()
.Levanta um evento de auditoria
compile
com os argumentossource
,filename
. Esse evento pode também ser levantando por uma compilação implícita.Nota
Quando compilando uma string com código multi-linhas em modo
'single'
ou'eval'
, entrada deve ser terminada por ao menos um caractere de nova linhas. Isso é para facilitar a detecção de instruções completas e incompletas no módulocode
.Aviso
É possível quebrar o interpretador Python com uma string suficientemente grande/complexa ao compilar para um objeto AST, devido limitações do tamanho da pilha no compilador AST do Python.
Alterado na versão 3.2: Permitido o uso de marcadores de novas linhas no estilo Windows e Mac. Além disso, em modo
'exec'
a entrada não precisa mais terminar com uma nova linha. Também foi adicionado o parâmetro optimize.Alterado na versão 3.5: Anteriormente,
TypeError
era levantada quando havia bytes nulos em source.Adicionado na versão 3.8:
ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
agora pode ser passado em flags para habilitar o suporte em nível superior aawait
,async for
, easync with
.
- class complex(number=0, /)¶
- class complex(string, /)
- class complex(real=0, imag=0)
Converte uma única string ou número para um número complexo, ou cria um número complexo a partir de partes real e imaginária.
Exemplos:
>>> complex('+1.23') (1.23+0j) >>> complex('-4.5j') -4.5j >>> complex('-1.23+4.5j') (-1.23+4.5j) >>> complex('\t( -1.23+4.5J )\n') (-1.23+4.5j) >>> complex('-Infinity+NaNj') (-inf+nanj) >>> complex(1.23) (1.23+0j) >>> complex(imag=-4.5) -4.5j >>> complex(-1.23, 4.5) (-1.23+4.5j)
Se o argumento for uma string, ele deve conter ou a parte real (com o mesmo formato usado em
float()
) ou uma parte imaginária (com o mesmo formato, mas com um sufixo'j'
ou'J'
), ou então ambas as partes real e imaginária (caso no qual o sinal da parte imaginária é obrigatório). A string pode opcionalmente ser cercada por espaços em branco e parênteses'('
e')'
, que são ignorados. A string não deve conter espaços em branco entre os símbolos'+'
,'-'
, o sufixo'j'
ou'J'
, e o número decimal. Por examplo,complex('1+2j')
é ok, mascomplex('1 + 2j')
levantaValueError
. Mais precisamente, após descartar os parênteses e os espaços em branco do início e do final, a entrada deve ser conforme a regra de produçãocomplexvalue
da gramática a seguir:complexvalue ::=
floatvalue
|floatvalue
("j" | "J") |floatvalue
sign
absfloatvalue
("j" | "J")Se o argumento for um número, o construtor serve como uma conversão numérica tal qual
int
efloat
. Para um objeto Pythonx
qualquer,complex(x)
delega parax.__complex__()
. Se__complex__()
não está definido então a chamada é repassada para__float__()
. Se__float__()
não está definido então a chamada é, novamente, repassada para__index__()
.Se dois argumentos forem passados ou argumentos nomeados forem usados, cada argumento pode ser de qualquer tipo numérico (incluindo complexo). Se ambos argumentos forem números reais, é retornado um número complexo com real como parte real e imag como parte imaginária. Se ambos os argumentos forem números complexos, é retornado um número complexo com parte real
real.real-imag.imag
e parte imagináriareal.imag+imag.real
. Se um dos argumentos for um número real, somente a sua parte real é usada nas expressões anteriores.Se todos os argumentos forem omitidos, retorna
0j
.O tipo complexo está descrito em Tipos numéricos — int, float, complex.
Alterado na versão 3.6: Agrupar dígitos com sublinhados como em literais de código é permitido.
Alterado na versão 3.8: Chamadas para
__index__()
se__complex__()
e__float__()
não estão definidas.
- delattr(object, name)¶
Essa função está relacionada com
setattr()
. Os argumentos são um objeto e uma string. A string deve ser o nome de um dos atributos do objeto. A função remove o atributo indicado, desde que o objeto permita. Por exemplo,delattr(x, 'foobar')
é equivalente adel x.foobar
. name não precisa ser um identificador Python (vejasetattr()
).
- class dict(**kwarg)
- class dict(mapping, **kwarg)
- class dict(iterable, **kwarg)
Cria um novo dicionário. O objeto
dict
é a classe do dicionário. Vejadict
e Tipo mapeamento — dict para documentação sobre esta classe.Para outros contêineres, consulte as classes embutidas
list
,set
etuple
, bem como o módulocollections
.
- dir()¶
- dir(object)
Sem argumentos, devolve a lista de nomes no escopo local atual. Com um argumento, tentará devolver uma lista de atributos válidos para esse objeto.
Se o objeto tiver um método chamado
__dir__()
, esse método será chamado e deve devolver a lista de atributos. Isso permite que objetos que implementam uma função personalizada__getattr__()
ou__getattribute__()
personalizem a maneira comodir()
relata seus atributos.Se o objeto não fornecer
__dir__()
, a função tentará o melhor possível para coletar informações do atributo__dict__
do objeto, se definido, e do seu objeto de tipo. A lista resultante não está necessariamente completa e pode ser imprecisa quando o objeto possui um__getattr__()
personalizado.O mecanismo padrão
dir()
se comporta de maneira diferente com diferentes tipos de objetos, pois tenta produzir as informações mais relevantes e não completas:Se o objeto for um objeto de módulo, a lista conterá os nomes dos atributos do módulo.
Se o objeto for um objeto de tipo ou classe, a lista conterá os nomes de seus atributos e recursivamente os atributos de suas bases.
Caso contrário, a lista conterá os nomes dos atributos do objeto, os nomes dos atributos da classe e recursivamente os atributos das classes base da classe.
A lista resultante é alfabeticamente ordenada. Por exemplo:
>>> import struct >>> dir() # show the names in the module namespace ['__builtins__', '__name__', 'struct'] >>> dir(struct) # show the names in the struct module ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__', '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 'unpack', 'unpack_from'] >>> class Shape: ... def __dir__(self): ... return ['area', 'perimeter', 'location'] ... >>> s = Shape() >>> dir(s) ['area', 'location', 'perimeter']
Nota
Como
dir()
é fornecido principalmente como uma conveniência para uso em um prompt interativo, ele tenta fornecer um conjunto interessante de nomes mais do que tenta fornecer um conjunto de nomes definido de forma rigorosa ou consistente, e seu comportamento detalhado pode mudar nos lançamentos. Por exemplo, os atributos de metaclasse não estão na lista de resultados quando o argumento é uma classe.
- divmod(a, b)¶
Recebe dois números (não complexos) como argumentos e retorna um par de números que consiste em seu quociente e resto ao usar a divisão inteira. Com tipos de operandos mistos, as regras para operadores aritméticos binários se aplicam. Para números inteiros, o resultado é o mesmo que
(a // b, a % b)
. Para números de ponto flutuante, o resultado é(q, a % b)
, onde q geralmente émath.floor(a / b)
, mas pode ser 1 a menos que isso. Em qualquer caso,q * b + a % b
está muito próximo de a, sea % b
é diferente de zero, tem o mesmo sinal que b e0 <= abs(a % b) < abs(b)
.
- enumerate(iterable, start=0)¶
Devolve um objeto enumerado. iterable deve ser uma sequência, um iterador ou algum outro objeto que suporte a iteração. O método
__next__()
do iterador retornado porenumerate()
devolve uma tupla contendo uma contagem (a partir de start, cujo padrão é 0) e os valores obtidos na iteração sobre iterable.>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] >>> list(enumerate(seasons, start=1)) [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
Equivalente a:
def enumerate(iterable, start=0): n = start for elem in iterable: yield n, elem n += 1
- eval(source, /, globals=None, locals=None)¶
- Parâmetros:
source (
str
| code object) – Uma expressão Python.globals (
dict
|None
) – O espaço de nomes global (por padrão,None
).locals (mapping |
None
) – O espaço de nomes local (por padrão,None
).
- Retorna:
O resultado da expressão avaliada.
- levanta:
Erros de sintaxe são reportados como exceções.
Aviso
Esta função executa código arbitrário. Chamá-la com entrada fornecida pelo usuário pode levar a vulnerabilidades de segurança.
O argumento expression é analisado e avaliado como uma expressão Python (tecnicamente falando, uma lista de condições) usando os mapeamentos globals e locals como espaços de nomes globais e locais. Se o dicionário globals estiver presente e não contiver um valor para a chave
__builtins__
, uma referência ao dicionário do módulo embutidobuiltins
será inserida sob essa chave antes de expression ser analisado. Dessa forma, você pode controlar quais funções embutidas estão disponíveis para o código executado inserindo seu próprio dicionário__builtins__
em globals antes de passá-lo paraeval()
. Se o mapeamento locals for omitido, o padrão será o dicionário globals. Se os dois mapeamentos forem omitidos, a expressão será executada com os globals e locals no ambiente em queeval()
é chamado. Observe que eval() terá acesso a escopos aninhados (não locais) no ambiente anexo somente se eles já forem referenciados pelo escopo que está chamandoeval()
(por exemplo, via uma instruçãononlocal
).Exemplo:
>>> x = 1 >>> eval('x+1') 2
Esta função também pode ser usada para executar objetos código arbitrários (como os criados por
compile()
). Nesse caso, passe um objeto código em vez de uma string. Se o objeto código foi compilado com'exec'
como o argumento mode, o valor de retorno deeval()
seráNone
.Dicas: a execução dinâmica de instruções é suportada pela função
exec()
. As funçõesglobals()
elocals()
retornam o dicionário global e local atual, respectivamente, o que pode ser útil para ser usado poreval()
ouexec()
.Se a fonte fornecida for uma string, os espaços e tabulações à esquerda ou à direita serão removidos.
Veja
ast.literal_eval()
para uma função que pode avaliar com segurança strings com expressões contendo apenas literais.Levanta um evento de auditoria
exec
com o código objeto como argumento. Eventos de compilação de código também podem ser levantados.Alterado na versão 3.13: Os argumentos globals e locals podem agora ser passados como argumentos nomeados.
Alterado na versão 3.13: A forma de uso do espaço de nomes locals padrão foi ajustado conforme descrito na função embutida
locals()
.
- exec(source, /, globals=None, locals=None, *, closure=None)¶
Aviso
Esta função executa código arbitrário. Chamá-la com entrada fornecida pelo usuário pode levar a vulnerabilidades de segurança.
Esta função suporta a execução dinâmica de código Python. O parâmetro source deve ser ou uma string ou um objeto código. Se for uma string, a mesma é analisada como um conjunto de instruções Python, o qual é então executado (exceto caso um erro de sintaxe ocorra). [1] Se for um objeto código, ele é simplesmente executado. Em todos os casos, espera-se que o código a ser executado seja válido como um arquivo de entrada (veja a seção Entrada de arquivo no Manual de Referência). Tenha cuidado, pois as instruções
nonlocal
,yield
ereturn
não podem ser usadas fora das definições de funções mesmo dentro do contexto do código passado para a funçãoexec()
. O valor de retorno é sempreNone
.Em todos os casos, se os parâmetros opcionais são omitidos, o código é executado no escopo atual. Se somente globals é fornecido, deve ser um dicionário (e não uma subclasse de dicionário), que será usado tanto para as variáveis globais quanto para locais. Se globals e locals são fornecidos, eles são usados para as variáveis globais e locais, respectivamente. Se fornecido, locals pode ser qualquer objeto de mapeamento. Lembre que no nível de módulo, globais e locais são o mesmo dicionário.
Nota
Quando or
exec
recebe dois objetos separados como globals and locals, o código será executado como se estivesse embutido em uma definição de classe. Isso significa que funções e classes definidas no código executado não poderão acessar variáveis que sofreram atribuições no escopo mais externo (pois, em uma definição de classe, tais variáveis seriam tratadas como variáveis de classe).Se o dicionário globals não contém um valor para a chave
__builtins__
, a referência para o dicionário do módulo embutidobuiltins
é inserido com essa chave. A maneira que você pode controlar quais embutidos estão disponíveis para o código executado é inserindo seu próprio__builtins__
dicionário em globals antes de passar paraexec()
.O argumento closure especifica uma clausura – uma tupla de cellvars. Só é válido quando o objeto é um objeto código contendo variáveis livres (de clausura). O comprimento da tupla deve corresponder exatamente ao comprimento do atributo
co_freevars
do objeto código.Levanta um evento de auditoria
exec
com o código objeto como argumento. Eventos de compilação de código também podem ser levantados.Nota
As funções embutidas
globals()
elocals()
devolvem o espaço de nomes global e local, respectivamente, o que pode ser útil para passar adiante e usar como segundo ou terceiro argumento paraexec()
.Nota
locals padrão atua como descrito pela função
locals()
abaixo. Se você precisa ver efeitos do código em locals depois da funçãoexec()
retornar passe um dicionário locals explícito.Alterado na versão 3.11: Adicionado o parâmetro closure.
Alterado na versão 3.13: Os argumentos globals e locals podem agora ser passados como argumentos nomeados.
Alterado na versão 3.13: A forma de uso do espaço de nomes locals padrão foi ajustado conforme descrito na função embutida
locals()
.
- filter(function, iterable)¶
Constrói um iterador a partir dos elementos de iterable para os quais function é verdadeiro. iterable pode ser uma sequência, um contêiner que com suporte a iteração, ou um iterador. Se function for
None
, a função identidade será usada, isto é, todos os elementos de iterable que são falsos são removidos.Note que
filter(function, iterable)
é equivalente a expressão geradora(item for item in iterable if function(item))
se function não forNone
e(item for item in iterable if item)
se function forNone
.Veja
itertools.filterfalse()
para a função complementar que devolve elementos de iterable para os quais function é falso.
- class float(number=0.0, /)¶
- class float(string, /)
Retorna um número de ponto flutuante construído a partir de um número ou string.
Exemplos:
>>> float('+1.23') 1.23 >>> float(' -12345\n') -12345.0 >>> float('1e-003') 0.001 >>> float('+1E6') 1000000.0 >>> float('-Infinity') -inf
Se o argumento for uma string, ele deve conter um número decimal, opcionalmente precedido por um sinal e opcionalmente embutido em um espaço em branco. O sinal opcional pode ser
'+'
ou'-'
; um sinal'+'
não tem efeito no valor produzido. O argumento também pode ser uma string representando um NaN (não um número) ou infinito positivo ou negativo. Mais precisamente, a entrada deve estar de acordo com a regra de produçãofloatvalue
na seguinte gramática, depois que os espaços em branco iniciais e finais forem removidos:sign ::= "+" | "-" infinity ::= "Infinity" | "inf" nan ::= "nan" digit ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd> digitpart ::=
digit
(["_"]digit
)* number ::= [digitpart
] "."digitpart
|digitpart
["."] exponent ::= ("e" | "E") [sign
]digitpart
floatnumber ::=number
[exponent
] absfloatvalue ::=floatnumber
|infinity
|nan
floatvalue ::= [sign
]absfloatvalue
O caso não é significativo, então, por exemplo, “inf”, “Inf”, “INFINITY” e “iNfINity” são todas grafias aceitáveis para o infinito positivo.
Caso contrário, se o argumento é um inteiro ou um número de ponto flutuante, um número de ponto flutuante com o mesmo valor (com a precisão de ponto flutuante de Python) é retornado. Se o argumento está fora do intervalo de um ponto flutuante Python, uma exceção
OverflowError
será lançada.Para um objeto Python genérico
x
,float(x)
delega para o métodox.__float__()
. Se__float__()
não estiver definido, então ele delega para o método__index__()
.Se nenhum argumento for fornecido, será retornado
0.0
.O tipo float é descrito em Tipos numéricos — int, float, complex.
Alterado na versão 3.6: Agrupar dígitos com sublinhados como em literais de código é permitido.
Alterado na versão 3.7: O parâmetro agora é somente-posicional
Alterado na versão 3.8: Chamada para
__index__()
se__float__()
não está definido.
- format(value, format_spec='')¶
Converte um valor value em uma representação “formatada”, controlado por format_spec. A interpretação de format_spec dependerá do tipo do argumento value; no entanto há uma sintaxe de formatação padrão usada pela maioria dos tipos embutidos: Minilinguagem de especificação de formato.
O format_spec padrão é uma string vazia que geralmente produz o mesmo efeito que chamar
str(value)
.Uma chamada de
format(value, format_spec)
é convertida emtype(value).__format__(value, format_spec)
, que ignora o dicionário da instância ao pesquisar o método__format__()
devalue
. Uma exceçãoTypeError
é levantada se a pesquisa do método atingirobject
e o format_spec não estiver vazio, ou se o format_spec ou o valor de retorno não forem strings.Alterado na versão 3.4:
object().__format__(format_spec)
levanta umTypeError
se format_spec não for uma string vazia.
- class frozenset(iterable=set())
Devolve um novo objeto
frozenset
, opcionalmente com elementos obtidos de iterable.frozenset
é uma classe embutida. Vejafrozenset
e Tipo conjuntos — set, frozenset para documentação sobre essas classes.Para outros contêineres veja as classes embutidas
set
,list
,tuple
, edict
, assim como o módulocollections
.
- getattr(object, name)¶
- getattr(object, name, default)
Devolve o valor do atributo name de object. name deve ser uma string. Se a string é o nome de um dos atributos do objeto, o resultado é o valor de tal atributo. Por exemplo,
getattr(x, 'foobar')
é equivalente ax.foobar
. Se o atributo não existir, default é devolvido se tiver sido fornecido, caso contrário a exceçãoAttributeError
é levantada. name não precisa ser um identificador Python (vejasetattr()
).Nota
Uma vez que desfiguração de nome privado acontece em tempo de compilação, deve-se manualmente mutilar o nome de um atributo privado (atributos com dois sublinhados à esquerda) para recuperá-lo com
getattr()
.
- globals()¶
Retorna o dicionário implementando o espaço de nomes do módulo atual. Para código dentro de funções, isso é definido quando a função é definida e permanece o mesmo, independentemente de onde a função é chamada.
- hasattr(object, name)¶
Os argumentos são um objeto e uma string. O resultado é
True
se a string é o nome de um dos atributos do objeto, eFalse
se ela não for. (Isto é implementado chamandogetattr(object, name)
e vendo se levanta umAttributeError
ou não.)
- hash(object)¶
Retorna o valor hash de um objeto (se houver um). Valores hash são números inteiros. Eles são usados para rapidamente comparar chaves de dicionários durante uma pesquisa em um dicionário. Valores numéricos que ao serem comparados são iguais, possuem o mesmo valor hash (mesmo que eles sejam de tipos diferentes, como é o caso de 1 e 1.0).
Nota
Para objetos com métodos
__hash__()
personalizados, fique atento quehash()
trunca o valor devolvido baseado no comprimento de bits da máquina hospedeira.
- help()¶
- help(request)
Invoca o sistema de ajuda embutido. (Esta função é destinada para uso interativo.) Se nenhum argumento é passado, o sistema interativo de ajuda inicia no interpretador do console. Se o argumento é uma string, então a string é pesquisada como o nome de um módulo, função, classe, método, palavra-chave, ou tópico de documentação, e a página de ajuda é exibida no console. Se o argumento é qualquer outro tipo de objeto, uma página de ajuda para o objeto é gerada.
Note que se uma barra(/) aparecer na lista de parâmetros de uma função, quando invocando
help()
, significa que os parâmetros anteriores a barra são apenas posicionais. Para mais informações, veja a entrada no FAQ sobre parâmetros somente-posicionais.Esta função é adicionada ao espaço de nomes embutido pelo módulo
site
.
- hex(x)¶
Converte um número inteiro para uma string hexadecimal em letras minúsculas pré-fixada com “0x”. Se x não é um objeto
int
do Python, ele tem que definir um método__index__()
que retorne um inteiro. Alguns exemplos:>>> hex(255) '0xff' >>> hex(-42) '-0x2a'
Se você quer converter um número inteiro para uma string hexadecimal em letras maiúsculas ou minúsculas, com prefixo ou sem, você pode usar qualquer uma das seguintes maneiras:
>>> '%#x' % 255, '%x' % 255, '%X' % 255 ('0xff', 'ff', 'FF') >>> format(255, '#x'), format(255, 'x'), format(255, 'X') ('0xff', 'ff', 'FF') >>> f'{255:#x}', f'{255:x}', f'{255:X}' ('0xff', 'ff', 'FF')
Veja também
format()
para mais informações.Veja também
int()
para converter uma string hexadecimal para um inteiro usando a base 16.Nota
Para obter uma string hexadecimal de um ponto flutuante, use o método
float.hex()
.
- id(object)¶
Devolve a “identidade” de um objeto. Ele é um inteiro, o qual é garantido que será único e constante para este objeto durante todo o seu ciclo de vida. Dois objetos com ciclos de vida não sobrepostos podem ter o mesmo valor para
id()
.Detalhes da implementação do CPython: Este é o endereço do objeto na memória.
Levanta um evento de auditoria
builtins.id
com o argumentoid
.
- input()¶
- input(prompt)
Se o argumento prompt estiver presente, escreve na saída padrão sem uma nova linha ao final. A função então lê uma linha da fonte de entrada, converte a mesma para uma string (removendo o caractere de nova linha ao final), e devolve isso. Quando o final do arquivo (EOF / end-of-file) é encontrado, um erro
EOFError
é levantado. Exemplo:>>> s = input('--> ') --> Monty Python's Flying Circus >>> s "Monty Python's Flying Circus"
Se o módulo
readline
foi carregado, entãoinput()
usará ele para prover edição de linhas elaboradas e funcionalidades de histórico.Levanta um evento de auditoria
builtins.input
com argumentoprompt
antes de ler a entrada.Levanta um evento de auditoria
builtins.input/result
com o resultado depois de ler a entrada com sucesso.
- class int(number=0, /)¶
- class int(string, /, base=10)
Retorna um objeto do tipo inteiro construído a partir de um número ou string, ou retorna
0
caso nenhum argumento seja passado.Exemplos:
>>> int(123.45) 123 >>> int('123') 123 >>> int(' -12_345\n') -12345 >>> int('FACE', 16) 64206 >>> int('0xface', 0) 64206 >>> int('01110011', base=2) 115
Se o argumento definir um método
__int__()
, entãoint(x)
retornax.__int__()
. Se x definir um método__index__()
, então ele retornax.__index__()
. Se o argumento definir um método__trunc__()
, então ele retornax.__trunc__()
. Para números de ponto flutuante, isto trunca o número na direção do zero.Se o argumento não for um número ou se base for fornecido, então o argumento deve ser uma instância de string,
bytes
oubytearray
representando um inteiro na base base. Opcionalmente, a string pode ser precedida por+
ou-
(sem espaço entre eles), ter zeros à esquerda, estar entre espaços em branco e ter sublinhados simples intercalados entre os dígitos.Uma string de inteiro de base n contém dígitos, cada um representando um valor de 0 a n-1. Os valores 0–9 podem ser representados por qualquer dígito decimal Unicode. Os valores 10–35 podem ser representados por
a
az
(ouA
aZ
). A base padrão é 10. As bases permitidas são 0 e 2–36. As strings base-2, -8 e -16 podem ser opcionalmente prefixadas com0b
/0B
,0o
/0O
ou0x
/0X
, como acontece com literais inteiros no código. Para a base 0, a string é interpretada de maneira semelhante a um literal inteiro no código, em que a base real é 2, 8, 10 ou 16 conforme determinado pelo prefixo. A base 0 também não permite zeros à esquerda:int('010', 0)
não é válido, enquantoint('010')
eint('010', 8)
são.O tipo inteiro está descrito em Tipos numéricos — int, float, complex.
Alterado na versão 3.4: Se base não é uma instância de
int
e o objeto base tem um métodobase.__index__
, então esse método é chamado para obter um inteiro para a base. Versões anteriores usavambase.__int__
ao invés debase.__index__
.Alterado na versão 3.6: Agrupar dígitos com sublinhados como em literais de código é permitido.
Alterado na versão 3.7: O primeiro parâmetro agora é somente-posicional.
Alterado na versão 3.8: Chamada para
__index__()
se__int__()
não está definido.Alterado na versão 3.11: A delegação de
__trunc__()
foi descontinuada.Alterado na versão 3.11: Entradas de strings para
int
e representações em strings podem ser limitadas para ajudar a evitar ataques de negação de serviço. Uma exceçãoValueError
é levantada quando o limite é excedido durante a conversão de uma string em umint
ou quando a conversão de umint
em uma string excede o limite. Consulte a documentação sobre limitação de comprimento de conversão de string em inteiro.
- isinstance(object, classinfo)¶
Retorna
True
se o argumento object é uma instância do argumento classinfo, ou de uma subclasse dele (direta, indireta ou virtual). Se object não é um objeto do tipo dado, a função sempre devolveFalse
. Se classinfo é uma tupla de tipos de objetos (ou recursivamente, como outras tuplas) ou um Tipo União de vários tipos, retornaTrue
se object é uma instância de qualquer um dos tipos. Se classinfo não é um tipo ou tupla de tipos ou outras tuplas, é levantada uma exceçãoTypeError
.TypeError
pode não ser levantada por um tipo inválido se uma verificação anterior for bem-sucedida.Alterado na versão 3.10: classinfo pode ser um Tipo União.
- issubclass(class, classinfo)¶
Retorna
True
se class for uma subclasse (direta, indireta ou virtual) de classinfo. Uma classe é considerada uma subclasse de si mesma. classinfo pode ser uma tupla de objetos de classe (ou recursivamente, outras tuplas) ou um Tipo União, caso em que retornaTrue
se class for uma subclasse de qualquer entrada em classinfo. Em qualquer outro caso, é levantada uma exceçãoTypeError
.Alterado na versão 3.10: classinfo pode ser um Tipo União.
- iter(object)¶
- iter(object, sentinel)
Retorna um objeto iterador. O primeiro argumento é interpretado muito diferentemente dependendo da presença do segundo argumento. Sem um segundo argumento, object deve ser uma coleção de objetos com suporte ao protocolo iterável (o método
__iter__()
), ou ele deve ter suporte ao protocolo de sequência (o método__getitem__()
com argumentos inteiros começando em0
). Se ele não tem suporte nenhum desses protocolos, umaTypeError
é levantada. Se o segundo argumento, sentinel, é fornecido, então object deve ser um objeto chamável. O iterador criado neste caso irá chamar object sem nenhum argumento para cada chamada para o seu método__next__()
; se o valor devolvido é igual a sentinel, entãoStopIteration
será levantado, caso contrário o valor será devolvido.Veja também Tipos iteradores.
Uma aplicação útil da segunda forma de
iter()
é para construir um bloco de leitura. Por exemplo, ler blocos de comprimento fixo de um arquivo binário de banco de dados até que o final do arquivo seja atingido:from functools import partial with open('meusdados.db', 'rb') as f: for bloco in iter(partial(f.read, 64), b''): process_block(bloco)
- len(s)¶
Devolve o comprimento (o número de itens) de um objeto. O argumento pode ser uma sequência (tal como uma string, bytes, tupla, lista, ou um intervalo) ou uma coleção (tal como um dicionário, conjunto, ou conjunto imutável).
Detalhes da implementação do CPython:
len
levantaOverflowError
em tamanhos maiores quesys.maxsize
, tal comorange(2 ** 100)
.
- class list
- class list(iterable)
Ao invés de ser uma função,
list
é na verdade um tipo de sequência mutável, conforme documentado em Listas e Tipos sequências — list, tuple, range.
- locals()¶
Retorna um objeto de mapeamento representando a tabela de símbolos atual, com nomes de variáveis como as chaves, e as referências às quais cada variável está atrelada no momento como os valores.
Em um escopo de módulo, assim como quando usando
exec()
oueval()
com um único espaço de nomes, esta função retorna o mesmo espaço de nomes queglobals()
.Em um escopo de classe, ela retorna o espaço de nomes que será passado para o construtor da metaclasse.
Quando usando
exec()
oueval()
com argumentos de espaço local e global distintos, ela retorna o espaço de nomes local passado na chamada.Em todos os casos acima, cada chamada a
locals()
em um dado quadro de execução vai retornar o mesmo objeto de mapeamento. Mudanças feitas através do objeto de mapeamento retornado porlocals()
serão visíveis tal qual variáveis locais atribuídas, reatribuídas ou deletadas, e atribuir, reatribuir ou deletar variáveis locais afetará imediatamente o conteúdo do objeto de mapeamento retornado.Em contraste aos casos acima, em um escopo otimizado (incluindo funções, geradores e corrotinas), cada chamada a
locals()
retorna um dicionário novo contendo as ligações atuais das variáveis locais da função e de quaisquer células com referências não-locais. Nesse caso, mudanças em ligações de nomes feitas através do dicionário retornado não são escritas de volta nas variáveis locais correspondentes nem nas células com referências não-locais, e atribuir, reatribuir ou deletar variáveis locais e células com referências não-locais não afeta o conteúdo dos dicionários que já foram retornados.Chamar a função
locals()
como parte de uma compreensão em uma função, gerador ou corrotina é equivalente a chamá-la no escopo que contém a compreensão, exceto que as variáveis de iteração inicializadas da compreensão serão incluídas. Em outros escopos, essa função se comporta como se a compreensão estivesse executando como uma função aninhada.Chamar a função
locals()
como parte de uma expressão geradora é equivalente a chamá-la em uma função geradora aninhada.Alterado na versão 3.12: O comportamento de
locals()
em uma compreensão foi atualizado conforme descrito na PEP 709.Alterado na versão 3.13: Como parte da PEP 667, o que acontece após a mutação de objetos de mapeamento retornados desta função está agora definido. O comportamento em escopos otimizados agora é o descrito acima. Além de estar definido, o comportamento em outros escopos não foi modificado em relação aos comportamentos em versões passadas.
- map(function, iterable, *iterables)¶
Devolve um iterador que aplica function para cada item de iterable, gerando os resultados. Se argumentos iterables adicionais são passados, function deve ter a mesma quantidade de argumentos e ela é aplicada aos itens de todos os iteráveis em paralelo. Com múltiplos iteráveis, o iterador para quando o iterador mais curto é encontrado. Para casos onde os parâmetros de entrada da função já estão organizados em tuplas, veja
itertools.starmap()
.
- max(iterable, *, key=None)¶
- max(iterable, *, default, key=None)
- max(arg1, arg2, *args, key=None)
Devolve o maior item em um iterável ou o maior de dois ou mais argumentos.
Se um argumento posicional é fornecido, ele deve ser um iterável. O maior item no iterável é retornado. Se dois ou mais argumentos posicionais são fornecidos, o maior dos argumentos posicionais é devolvido.
Existem dois parâmetros somente-nomeados opcionais. O parâmetro key especifica uma função de ordenamento de um argumento, como aquelas usadas por
list.sort()
. O parâmetro default especifica um objeto a ser devolvido se o iterável fornecido estiver vazio. Se o iterável estiver vazio, e default não foi fornecido, uma exceçãoValueError
é levantada.Se múltiplos itens são máximos, a função devolve o primeiro encontrado. Isto é consistente com outras ferramentas de ordenamento que preservam a estabilidade, tais como
sorted(iterable, key=keyfunc, reverse=True)[0]
eheapq.nlargest(1, iterable, key=keyfunc)
.Alterado na versão 3.4: Adicionado o parâmetro default somente-nomeado.
Alterado na versão 3.8: O valor de key pode ser
None
.
- class memoryview(object)
Devolve um objeto de “visão da memória” criado a partir do argumento fornecido. Veja Memory Views para mais informações.
- min(iterable, *, key=None)¶
- min(iterable, *, default, key=None)
- min(arg1, arg2, *args, key=None)
Devolve o menor item de um iterável ou o menor de dois ou mais argumentos.
Se um argumento posicional é fornecido, ele deve ser um iterável. O menor item no iterável é devolvido. Se dois ou mais argumentos posicionais são fornecidos, o menor dos argumentos posicionais é devolvido.
Existem dois parâmetros somente-nomeados opcionais. O parâmetro key especifica uma função de ordenamento de um argumento, como aquelas usadas por
list.sort()
. O parâmetro default especifica um objeto a ser devolvido se o iterável fornecido estiver vazio. Se o iterável estiver vazio, e default não foi fornecido, uma exceçãoValueError
é levantada.Se múltiplos itens são mínimos, a função devolve o primeiro encontrado. Isto é consistente com outras ferramentas de ordenamento que preservam a estabilidade, tais como
sorted(iterable, key=keyfunc)[0]
eheapq.nsmallest(1, iterable, key=keyfunc)
.Alterado na versão 3.4: Adicionado o parâmetro default somente-nomeado.
Alterado na versão 3.8: O valor de key pode ser
None
.
- next(iterator)¶
- next(iterator, default)
Recupera o próximo item do iterador chamando o seu método
__next__()
. Se default foi fornecido, ele é devolvido caso o iterável tenha sido percorrido por completo, caso contrárioStopIteration
é levantada.
- class object¶
Esta é a classe base definitiva de todas as outras classes. Ela tem métodos que são comuns a todas as instâncias de classes Python. Quando o construtor é chamado, ele retorna um novo objeto sem características. O construtor não aceita nenhum argumento.
- oct(x)¶
Converte um número inteiro para uma string em base octal, pré-fixada com “0o”. O resultado é uma expressão Python válida. Se x não for um objeto
int
Python, ele tem que definir um método__index__()
que devolve um inteiro. Por exemplo:>>> oct(8) '0o10' >>> oct(-56) '-0o70'
Se você quiser converter um número inteiro para uma string octal, com o prefixo “0o” ou não, você pode usar qualquer uma das formas a seguir.
>>> '%#o' % 10, '%o' % 10 ('0o12', '12') >>> format(10, '#o'), format(10, 'o') ('0o12', '12') >>> f'{10:#o}', f'{10:o}' ('0o12', '12')
Veja também
format()
para mais informações.
- open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)¶
Abre file e retorna um objeto arquivo correspondente. Se o arquivo não puder ser aberto, uma
OSError
é levantada. Veja Leitura e escrita de arquivos para mais exemplos de como usar esta função.file é um objeto caminho ou similar fornecendo o caminho (absoluto ou relativo ao diretório de trabalho atual) do arquivo que será aberto, ou de um inteiro descritor de arquivo a ser manipulado (Se um descritor de arquivo é fornecido, ele é fechado quando o objeto de I/O retornado é fechado, a não ser que closefd esteja marcado como
False
).mode é uma string opcional que especifica o modo no qual o arquivo é aberto. O valor padrão é
'r'
, o qual significa abrir para leitura em modo texto. Outros valores comuns são'w'
para escrever (truncando o arquivo se ele já existe),'x'
para criação exclusiva e'a'
para anexar (o qual em alguns sistemas Unix, significa que todas as escritas anexam ao final do arquivo independentemente da posição de busca atual). No modo texto, se encoding não for especificada, a codificação usada depende da plataforma:locale.getencoding()
é chamada para obter a codificação da localidade atual (Para ler e escrever bytes diretamente, use o modo binário e não especifique encoding). Os modos disponíveis são:Caractere
Significado
'r'
abre para leitura (padrão)
'w'
abre para escrita, truncando o arquivo primeiro (removendo tudo o que estiver contido no mesmo)
'x'
abre para criação exclusiva, falhando caso o arquivo exista
'a'
abre para escrita, anexando ao final do arquivo caso o mesmo exista
'b'
modo binário
't'
modo texto (padrão)
'+'
aberto para atualização (leitura e escrita)
O modo padrão é
'r'
(abre para leitura de texto, um sinônimo de'rt'
). Modos'w+'
e'w+b'
abrem e truncam o arquivo. Modos'r+'
e'r+b'
abrem o arquivo sem truncar o mesmo.Conforme mencionado em Visão Geral, Python diferencia entre entrada/saída binária e de texto. Arquivos abertos em modo binário (incluindo
'b'
no parâmetro mode) retornam o conteúdo como objetosbytes
sem usar nenhuma decodificação. No modo texto (o padrão, ou quando't'
é incluído no parâmetro mode), o conteúdo do arquivo é retornado comostr
, sendo os bytes primeiramente decodificados usando uma codificação dependente da plataforma, ou usando a codificação definida em encoding se fornecida.Nota
Python não depende da noção básica do sistema operacional sobre arquivos de texto; todo processamento é feito pelo próprio Python, e é então independente de plataforma.
buffering é um número inteiro opcional usado para definir a política de buffering. Passe 0 para desativar o buffer (permitido apenas no modo binário), 1 para selecionar o buffer de linha (usável apenas ao gravar no modo de texto) e um inteiro > 1 para indicar o tamanho em bytes de um buffer de bloco de tamanho fixo. Observe que especificar um tamanho de buffer dessa maneira se aplica a E/S com buffer binário, mas
TextIOWrapper
(ou seja, arquivos abertos commode='r+'
) teriam outro buffer. Para desabilitar o buffer emTextIOWrapper
, considere usar o sinalizadorwrite_through
paraio.TextIOWrapper.reconfigure()
. Quando nenhum argumento buffering é fornecido, a política de buffering padrão funciona da seguinte forma:Arquivos binários são armazenados em pedaços de tamanho fixo; o tamanho do buffer é escolhido usando uma heurística que tenta determinar o “tamanho de bloco” subjacente do dispositivo, e usa
io.DEFAULT_BUFFER_SIZE
caso não consiga. Em muitos sistemas, o buffer possuirá tipicamente 4096 ou 8192 bytes de comprimento.Arquivos de texto “interativos” (arquivos para os quais
isatty()
retornamTrue
) usam buffering de linha. Outros arquivos de texto usam a política descrita acima para arquivos binários.
encoding é o nome da codificação usada para codificar ou decodificar o arquivo. Isto deve ser usado apenas no modo texto. A codificação padrão depende da plataforma (seja qual valor
locale.getencoding()
retornar), mas qualquer codificador de texto suportado pelo Python pode ser usada. Veja o módulocodecs
para a lista de codificações suportadas.errors é uma string opcional que especifica como erros de codificação e de decodificação devem ser tratados — isso não pode ser utilizado no modo binário. Uma variedade de tratadores de erro padrão estão disponíveis (listados em Error Handlers), apesar que qualquer nome para tratamento de erro registrado com
codecs.register_error()
também é válido. Os nomes padrões incluem:'strict'
para levantar uma exceçãoValueError
se existir um erro de codificação. O valor padrãoNone
tem o mesmo efeito.'ignore'
ignora erros. Note que ignorar erros de código pode levar à perda de dados.'replace'
faz um marcador de substituição (tal como'?'
) ser inserido onde existem dados malformados.representará quaisquer bytes incorretos como unidades de código substituto baixo variando de U + DC80 a U + DCFF. Essas unidades de código substituto serão então transformadas de volta nos mesmos bytes quando o manipulador de erros for usado ao gravar dados. Isso é útil para processar arquivos em uma codificação desconhecida.
'xmlcharrefreplace'
é suportado apenas ao gravar em um arquivo. Os caracteres não suportados pela codificação são substituídos pela referência de caracteres XML apropriada&#nnn;
.'backslashreplace'
substitui dados malformados pela sequência de escape utilizando contrabarra do Python.'namereplace'
(também é suportado somente quando estiver escrevendo) substitui caractere não suportados com sequências de escape\N{...}
.
newline determina como analisar caracteres de nova linha do fluxo. Ele pode ser
None
,''
,'\n'
,'\r'
e'\r\n'
. Ele funciona da seguinte forma:Ao ler a entrada do fluxo, se newline for
None
, o modo universal de novas linhas será ativado. As linhas na entrada podem terminar em'\n'
,'\r'
ou'\r\n'
, e são traduzidas para'\n'
antes de retornar ao chamador. Se for''
, o modo de novas linhas universais será ativado, mas as terminações de linha serão retornadas ao chamador sem tradução. Se houver algum dos outros valores legais, as linhas de entrada são finalizadas apenas pela string especificada e a finalização da linha é retornada ao chamador sem tradução.Ao gravar a saída no fluxo, se newline for
None
, quaisquer caracteres'\n'
gravados serão traduzidos para o separador de linhas padrão do sistema,os.linesep
. Se newline for''
ou'\n'
, nenhuma tradução ocorrerá. Se newline for um dos outros valores legais, qualquer caractere'\n'
escrito será traduzido para a string especificada.
Se closefd for
False
e um descritor de arquivo em vez de um nome de arquivo for fornecido, o descritor de arquivo subjacente será mantido aberto quando o arquivo for fechado. Se um nome de arquivo for fornecido closefd deve serTrue
(o padrão), caso contrário, um erro será levantado.Um abridor personalizado pode ser usado passando um chamável como opener. O descritor de arquivo subjacente para o objeto arquivo é obtido chamando opener com (file, flags). opener deve retornar um descritor de arquivo aberto (passando
os.open
como opener resulta em funcionalidade semelhante à passagem deNone
).O arquivo recém-criado é não-herdável.
O exemplo a seguir usa o parâmetro dir_fd da função
os.open()
para abrir um arquivo relativo a um determinado diretório:>>> import os >>> dir_fd = os.open('algum_dir', os.O_RDONLY) >>> def opener(path, flags): ... return os.open(path, flags, dir_fd=dir_fd) ... >>> with open('spamspam.txt', 'w', opener=opener) as f: ... print('Isso será escrito para algum_dir/spamspam.txt', file=f) ... >>> os.close(dir_fd) # não deixe vazar um descritor de arquivo
O tipo de objeto arquivo retornado pela função
open()
depende do modo. Quandoopen()
é usado para abrir um arquivo no modo texto ('w'
,'r'
,'wt'
,'rt'
, etc.), retorna uma subclasse deio.TextIOBase
(especificamenteio.TextIOWrapper
). Quando usada para abrir um arquivo em modo binário com buffer, a classe retornada é uma subclasse deio.BufferedIOBase
. A classe exata varia: no modo binário de leitura, ele retorna umaio.BufferedReader
; nos modos binário de gravação e binário anexado, ele retorna umio.BufferedWriter
e, no modo leitura/gravação, retorna umio.BufferedRandom
. Quando o buffer está desativado, o fluxo bruto, uma subclasse deio.RawIOBase
,io.FileIO
, é retornado.Veja também os módulos de para lidar com arquivos, tais como
fileinput
,io
(ondeopen()
é declarado),os
,os.path
,tempfile
eshutil
.Levanta um evento de auditoria
open
com os argumentospath
,mode
,flags
.Os argumentos
mode
eflags
podem ter sido modificados ou inferidos a partir da chamada original.Alterado na versão 3.3:
O parâmetro opener foi adicionado.
O modo
'x'
foi adicionado.IOError
costumava ser levantado, agora ele é um codinome paraOSError
.FileExistsError
agora é levantado se o arquivo aberto no modo de criação exclusivo ('x'
) já existir.
Alterado na versão 3.4:
O arquivo agora é não herdável.
Alterado na versão 3.5:
Se a chamada de sistema é interrompida e o tratador de sinal não levanta uma exceção, a função agora tenta novamente a chamada de sistema em vez de levantar uma exceção
InterruptedError
(consulte PEP 475 para entender a justificativa).O tratador de erros
'namereplace'
foi adicionado.
Alterado na versão 3.6:
Suporte adicionado para aceitar objetos implementados
os.PathLike
.No Windows, a abertura de um buffer do console pode retornar uma subclasse de
io.RawIOBase
que não sejaio.FileIO
.
Alterado na versão 3.11: O modo
'U'
foi removido.
- ord(c)¶
Dada uma string que representa um caractere Unicode, retorna um número inteiro representando o ponto de código Unicode desse caractere. Por exemplo,
ord('a')
retorna o número inteiro97
eord('€')
(sinal do Euro) retorna8364
. Este é o inverso dechr()
.
- pow(base, exp, mod=None)¶
Retorna base à potência de exp; se mod estiver presente, retorna base à potência exp, módulo mod (calculado com mais eficiência do que
pow(base, exp) % mod
). A forma de dois argumentospow(base, exp)
é equivalente a usar o operador de potência:base**exp
.Os argumentos devem ter tipos numéricos. Com tipos de operandos mistos, aplicam-se as regras de coerção para operadores aritméticos binários. Para operandos
int
, o resultado tem o mesmo tipo que os operandos (após coerção), a menos que o segundo argumento seja negativo; nesse caso, todos os argumentos são convertidos em ponto flutuante e um resultado ponto flutuante é entregue. Por exemplo,pow(10, 2)
retorna100
, maspow(10, -2)
retorna0.01
. Para uma base negativa do tipoint
oufloat
e um expoente não integral, um resultado complexo é entregue. Por exemplo,pow(-9, 0.5)
retorna um valor próximo a3j
. Enquanto isso, para uma base negativa do tipoint
oufloat
com um expoente integral, um resultado de ponto flutuante é retornado. Por exemplo,pow(-9, 2.0)
retorna81.0
.Para operandos
int
base e exp, se mod estiver presente, mod também deve ser do tipo inteiro e mod deve ser diferente de zero. Se mod estiver presente e exp for negativo, base deve ser relativamente primo para mod. Nesse caso,pow(inv_base, -exp, mod)
é retornado, onde inv_base é um inverso ao base módulo mod.Aqui está um exemplo de computação de um inverso para
38
módulo97
:>>> pow(38, -1, mod=97) 23 >>> 23 * 38 % 97 == 1 True
Alterado na versão 3.8: Para operandos
int
, a forma de três argumentos depow
agora permite que o segundo argumento seja negativo, permitindo o cálculo de inversos modulares.Alterado na versão 3.8: Permite argumentos de palavra reservada. Anteriormente, apenas argumentos posicionais eram suportados.
- print(*objects, sep=' ', end='\n', file=None, flush=False)¶
Exibe objects no fluxo de texto arquivo, separado por sep e seguido por end. sep, end, file e flush, se houver, devem ser fornecidos como argumentos nomeados.
Todos os argumentos que não são nomeados são convertidos em strings como
str()
faz e gravados no fluxo, separados por sep e seguidos por end. sep e end devem ser strings; eles também podem serNone
, o que significa usar os valores padrão. Se nenhum object for fornecido,print()
escreverá apenas end.O argumento file deve ser um objeto com um método
write(string)
; se ele não estiver presente ouNone
, entãosys.stdout
será usado. Como argumentos exibidos no console são convertidos para strings de texto,print()
não pode ser usado com objetos de arquivo em modo binário. Para esses casos, usefile.write(...)
ao invés.O buffer de saída geralmente é determinado por arquivo. No entanto, se flush for verdadeiro, o fluxo será descarregado à força.
Alterado na versão 3.3: Adicionado o argumento nomeado flush.
- class property(fget=None, fset=None, fdel=None, doc=None)¶
Retorna um atributo de propriedade.
fget é uma função para obter o valor de um atributo. fset é uma função para definir um valor para um atributo. fdel é uma função para deletar um valor de um atributo. E doc cria um docstring para um atributo.
Um uso comum é para definir um atributo gerenciável
x
:class C: def __init__(self): self._x = None def getx(self): return self._x def setx(self, valor): self._x = valor def delx(self): del self._x x = property(getx, setx, delx, "Eu sou a propriedade de 'x'.")
Se c é uma instância de C,
c.x
irá invocar o método getter,c.x = valor
irá invocar o método setter, edel c.x
o método deleter.Se fornecido, doc será a docstring do atributo definido por property. Caso contrário, a property copiará a docstring de fget (se ela existir). Isso torna possível criar facilmente propriedades apenas para leitura usando
property()
como um decorador:class Parrot: def __init__(self): self._voltagem = 100000 @property def voltagem(self): """Obtém a voltagem atual.""" return self._voltagem
O decorador
@property
transforma o métodovoltage()
em um “getter” para um atributo somente leitura com o mesmo nome, e define a docstring de voltage para “Get the current voltage.”- @getter¶
- @setter¶
- @deleter¶
Um objeto property possui métodos
getter
,setter
edeleter
usáveis como decoradores, que criam uma cópia da property com o assessor correspondente a função definida para a função com decorador. Isso é explicado melhor com um exemplo:class C: def __init__(self): self._x = None @property def x(self): """Sou a propriedade de 'x'.""" return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x
Esse código é exatamente equivalente ao primeiro exemplo. Tenha certeza de nas funções adicionais usar o mesmo nome que a property original (
x
neste caso).O objeto property retornado também tem os atributos
fget
,fset
, efdel
correspondendo aos argumentos do construtor.
Alterado na versão 3.5: Agora é possível escrever nas docstrings de objetos property.
- __name__¶
Atributo que contém o nome da propriedade. O nome da propriedade pode ser alterado em tempo de execução.
Adicionado na versão 3.13.
- class range(stop)
- class range(start, stop, step=1)
Em vez de ser uma função,
range
é realmente um tipo de sequência imutável, conforme documentado em Intervalos e Tipos sequências — list, tuple, range.
- repr(object)¶
Retorna uma string contendo uma representação imprimível de um objeto. Para muitos tipos, essa função tenta retornar uma string que produziria um objeto com o mesmo valor quando passado para
eval()
, caso contrário, a representação é uma string entre colchetes angulares que contém o nome do tipo do objeto juntamente com informações adicionais, geralmente incluindo o nome e o endereço do objeto. Uma classe pode controlar o que essa função retorna para suas instâncias, definindo um método__repr__()
. Sesys.displayhook()
não estiver acessível, esta função vai levantarRuntimeError
.Esta classe possui uma representação personalizada que pode ser executada:
class Pessoa: def __init__(self, nome, idade): self.name = nome self.age = idade def __repr__(self): return f"Pessoa('{self.nome}', {self.idade})"
- reversed(seq)¶
Retorna um iterador reverso. seq deve ser um objeto que possui o método
__reversed__()
ou suporta o protocolo de sequência (o método__len__()
e o método__getitem__()
com argumentos inteiros começando em0
).
- round(number, ndigits=None)¶
Retorna number arredondado para ndigits precisão após o ponto decimal. Se ndigits for omitido ou for
None
, ele retornará o número inteiro mais próximo de sua entrada.Para os tipos embutidos com suporte a
round()
, os valores são arredondados para o múltiplo mais próximo de 10 para a potência de menos ndigit; se dois múltiplos são igualmente próximos, o arredondamento é feito para a opção par (por exemplo,round(0.5)
eround(-0.5)
são0
eround(1.5)
é2
). Qualquer valor inteiro é válido para ndigits (positivo, zero ou negativo). O valor de retorno é um número inteiro se ndigits for omitido ouNone
. Caso contrário, o valor de retorno tem o mesmo tipo que number.Para um objeto Python geral
number
,round
delega paranumber.__round__
.Nota
O comportamento de
round()
para pontos flutuantes pode ser surpreendente: por exemplo,round(2.675, 2)
fornece2.67
em vez do esperado2.68
. Isso não é um bug: é resultado do fato de que a maioria das frações decimais não pode ser representada exatamente como um ponto flutuante. Veja Aritmética de ponto flutuante: problemas e limitações para mais informações.
- class set
- class set(iterable)
Retorna um novo objeto
set
, opcionalmente com elementos retirados de iterable.set
é uma classe embutida. Vejaset
e Tipo conjuntos — set, frozenset para documentação sobre esta classe.Para outros contêineres, consulte as classes embutidas
frozenset
,list
,tuple
edict
, bem como o módulocollections
.
- setattr(object, name, value)¶
Esta é a contrapartida de
getattr()
. Os argumentos são um objeto, uma string e um valor arbitrário. A string pode nomear um atributo existente ou um novo atributo. A função atribui o valor ao atributo, desde que o objeto permita. Por exemplo,setattr(x, 'foobar', 123)
é equivalente ax.foobar = 123
.name não precisa ser um identificador do Python conforme definido em Identificadores e palavras-chave a menos que o objeto opte por impor isso, por exemplo, em um
__getattribute__()
personalizado ou via__slots__
. Um atributo cujo nome não é um identificador não será acessível usando a notação de ponto, mas pode ser acessado através degetattr()
etc.Nota
Uma vez que desfiguração de nome privado acontece em tempo de compilação, deve-se manualmente mutilar o nome de um atributo privado (atributos com dois sublinhados à esquerda) para defini-lo com
setattr()
.
- class slice(stop)¶
- class slice(start, stop, step=None)
Retorna um objeto fatia representando o conjunto de índices especificados por
range(start, stop, step)
. Os argumentos start e step têm o padrãoNone
.- start¶
- stop¶
- step¶
Objetos fatia têm atributos de dados somente leitura
start
,stop
estep
que simplesmente retornam os valores dos argumentos (ou seus padrões). Eles não possuem outra funcionalidade explícita; no entanto, eles são usados pelo NumPy e outros pacotes de terceiros.
Objetos fatia também são gerados quando a sintaxe de indexação estendida é usada. Por exemplo:
a[start:stop:step]
oua[start:stop, i]
. Vejaitertools.islice()
para uma versão alternativa que retorna um iterador.Alterado na versão 3.12: Os objetos slice agora são hasheáveis (desde que
start
,stop
estep
sejam hasheáveis).
- sorted(iterable, /, *, key=None, reverse=False)¶
Retorna uma nova lista classificada dos itens em iterable.
Possui dois argumentos opcionais que devem ser especificados como argumentos nomeados.
key especifica a função de um argumento usado para extrair uma chave de comparação de cada elemento em iterable (por exemplo,
key=str.lower
). O valor padrão éNone
(compara os elementos diretamente).reverse é um valor booleano. Se definido igual a
True
, então os elementos da lista são classificados como se cada comparação estivesse invertida.Usa
functools.cmp_to_key()
para converter a função das antigas cmp para uma função key.A função embutida
sorted()
é garantida como estável. Uma ordenação é estável se garantir não alterar a ordem relativa dos elementos que se comparam da mesma forma — isso é útil para ordenar em várias passagens (por exemplo, ordenar por departamento e depois por nível de salário).O algoritmo de classificação usa apenas comparações
<
entre itens. Embora definir um método__lt__()
seja suficiente para ordenação, PEP 8 recomenda que todas as seis comparações ricas sejam implementadas. Isso ajudará a evitar erros ao usar os mesmos dados com outras ferramentas de ordenação, comomax()
, que dependem de um método subjacente diferente. Implementar todas as seis comparações também ajuda a evitar confusão para comparações de tipo misto que podem chamar refletido o método__gt__()
.Para exemplos de classificação e um breve tutorial de classificação, veja Técnicas de ordenação.
- @staticmethod¶
Transforma um método em método estático.
Um método estático não recebe um primeiro argumento implícito. Para declarar um método estático, use este idioma:
class C: @staticmethod def f(arg1, arg2, argN): ...
A forma
@staticmethod
é uma função de decorador – veja Definições de função para detalhes.Um método estático pode ser chamado na classe (tal como
C.f()
) ou em uma instância (tal comoC().f()
). Além disso, o descritor de método estático também é um chamável, então ele pode ser usado na definição de classe (comof()
).Métodos estáticos em Python são similares àqueles encontrados em Java ou C++. Veja também
classmethod()
para uma variante útil na criação de construtores de classe alternativos.Como todos os decoradores, também é possível chamar
staticmethod
como uma função regular e fazer algo com seu resultado. Isso é necessário em alguns casos em que você precisa de uma referência para uma função de um corpo de classe e deseja evitar a transformação automática em método de instância. Para esses casos, use este idioma:def função_comum(): ... class C: método = staticmethod(função_comum)
Para mais informações sobre métodos estáticos, consulte A hierarquia de tipos padrão.
Alterado na versão 3.10: Métodos estáticos agora herdam os atributos do método (
__module__
,__name__
,__qualname__
,__doc__
e__annotations__
), têm um novo atributo__wrapped__
e são agora chamáveis como funções regulares.
- class str(object='')
- class str(object=b'', encoding='utf-8', errors='strict')
Retorna uma versão
str
de object. Consultestr()
para detalhes.str
é uma classe de string embutida. Para informações gerais sobre strings, consulte Tipo sequência de texto — str.
- sum(iterable, /, start=0)¶
Soma start e os itens de um iterable da esquerda para a direita e retornam o total. Os itens do iterable são normalmente números e o valor inicial não pode ser uma string.
Para alguns casos de uso, existem boas alternativas para
sum()
. A maneira rápida e preferida de concatenar uma sequência de strings é chamando''.join(sequence)
. Para adicionar valores de ponto flutuante com precisão estendida, consultemath.fsum()
. Para concatenar uma série de iteráveis, considere usaritertools.chain()
.Alterado na versão 3.8: O parâmetro start pode ser especificado como um argumento nomeado.
Alterado na versão 3.12: A soma dos pontos flutuantes foi alterada para um algoritmo que oferece maior precisão e melhor comutatividade na maioria das compilações.
- class super¶
- class super(type, object_or_type=None)
Retorna um objeto proxy que delega chamadas de método a uma classe pai ou irmão do type. Isso é útil para acessar métodos herdados que foram substituídos em uma classe.
O object_or_type determina a ordem de resolução de métodos a ser pesquisada. A pesquisa inicia a partir da classe logo após o type.
Por exemplo, se
__mro__
de object_or_type éD -> B -> C -> A -> object
e o valor de type éB
, entãosuper()
procura porC -> A -> object
.O atributo
__mro__
da classe correspondente ao object_or_type lista a ordem de pesquisa de resolução de método usada porgetattr()
esuper()
. O atributo é dinâmico e pode mudar sempre que a hierarquia da herança é atualizada.Se o segundo argumento for omitido, o objeto super retornado é desacoplado. Se o segundo argumento é um objeto,
isinstance(obj, type)
deve ser verdadeiro. Se o segundo argumento é um tipo,issubclass(type2, type)
deve ser verdadeiro (isto é útil para classmethods).Quando chamado diretamente de dentro de um método comum de uma classe, pode-se omitir ambos os argumentos (”
super()
de zero argumentos”). Neste caso, type será a classe em questão, e obj será o primeiro argumento da função que imediatamente chamousuper()
(geralmente oself
). (Isso significa que osuper()
de zero argumentos não vai funcionar como esperado em funções aninhadas, incluindo expressões geradoras, que criam funções aninhadas implicitamente.)Existem dois casos de uso típicos para super. Em uma hierarquia de classes com herança única, super pode ser usado para se referir a classes base sem nomeá-las explicitamente, tornando o código mais sustentável. Esse uso é paralelo ao uso de super em outras linguagens de programação.
O segundo caso de uso é oferecer suporte à herança múltipla cooperativa em um ambiente de execução dinâmica. Esse caso de uso é exclusivo do Python e não é encontrado em idiomas ou linguagens compiladas estaticamente que suportam apenas herança única. Isso torna possível implementar “diagramas em losango”, onde várias classes base implementam o mesmo método. Um bom design exige que tais implementações tenham a mesma assinatura de chamada em todos os casos (porque a ordem das chamadas é determinada em tempo de execução, porque essa ordem se adapta às alterações na hierarquia de classes e porque essa ordem pode incluir classes de irmãos desconhecidas antes do tempo de execução).
Nos dois casos de uso, uma chamada típica de superclasse se parece com isso:
class C(B): def método(self, arg): super().método(arg) # Isso faz o mesmo que: # super(C, self).método(arg)
Além das pesquisas de método,
super()
também funciona para pesquisas de atributo. Um possível caso de uso para isso é chamar descritores em uma classe pai ou irmã.Observe que
super()
é implementada como parte do processo de vinculação para procura explícita de atributos com ponto, tal comosuper().__getitem__(nome)
. Ela faz isso implementando seu próprio método__getattribute__()
para pesquisar classes em uma ordem predizível que possui suporte a herança múltipla cooperativa. Logo,super()
não é definida para procuras implícitas usando instruções ou operadores comosuper()[name]
.Observe também que, além da forma de argumento zero,
super()
não se limita ao uso de métodos internos. O formulário de dois argumentos especifica exatamente os argumentos e faz as referências apropriadas. O formulário de argumento zero funciona apenas dentro de uma definição de classe, pois o compilador preenche os detalhes necessários para recuperar corretamente a classe que está sendo definida, além de acessar a instância atual para métodos comuns.Para sugestões práticas sobre como projetar classes cooperativas usando
super()
, consulte o guia para uso de super().
- class tuple
- class tuple(iterable)
Ao invés de ser uma função,
tuple
é na verdade um tipo de sequência imutável, conforme documentado em Tuplas e Tipos sequências — list, tuple, range.
- class type(object)¶
- class type(name, bases, dict, **kwds)
Com um argumento, retorna o tipo de um object. O valor de retorno é um tipo de objeto e geralmente o mesmo objeto retornado por
object.__class__
.A função embutida
isinstance()
é recomendada para testar o tipo de um objeto, porque ela leva sub-classes em consideração.Com três argumentos, retorna um novo objeto type. Esta é essencialmente a forma dinâmica da instrução
class
. A string name é o nome da classe e se torna o atributo__name__
. A tupla bases contém as classes bases e se torna o atributo__bases__
; se vazio,object
, a base final de todas as classes é adicionada. O dicionário dict contém definições de atributo e método para o corpo da classe; ele pode ser copiado ou envolto antes de se tornar o atributo__dict__
. As duas instruções a seguir criam objetostype
idênticos:>>> class X: ... a = 1 ... >>> X = type('X', (), dict(a=1))
Veja também:
Argumentos nomeados fornecidos para a forma de três argumentos são passados para a máquina metaclasse apropriada (geralmente
__init_subclass__()
) da mesma forma que palavras-chave em uma definição de classe (além de metaclasse) fariam.Veja também Personalizando a criação de classe.
Alterado na versão 3.6: Subclasses de
type
que não substituemtype.__new__
não podem mais usar a forma com apenas um argumento para obter o tipo de um objeto.
- vars()¶
- vars(object)
Retorna o atributo
__dict__
para um módulo, classe, instância, or qualquer outro objeto com um atributo__dict__
.Objetos como modelos e instâncias têm um atributo atualizável
__dict__
; porém, outros projetos podem ter restrições de escrita em seus atributos__dict__
(por exemplo, classes usam umtypes.MappingProxyType
para prevenir atualizações diretas a dicionário).Sem nenhum argumento,
vars()
age comolocals()
.Uma exceção
TypeError
é levantada se um objeto é especificado, mas ela não tem um atributo__dict__
(por exemplo, se sua classe define o atributo__slots__
).Alterado na versão 3.13: O resultado de chamar esta função sem um argumento foi atualizado conforme descrito na embutida
locals()
.
- zip(*iterables, strict=False)¶
Itera sobre vários iteráveis em paralelo, produzindo tuplas com um item de cada um.
Exemplo:
>>> for item in zip([1, 2, 3], ['açúcar', 'tempero', 'tudo que há de bom']): ... print(item) ... (1, 'açúcar') (2, 'tempero') (3, 'tudo que há de bom')
Mais formalmente:
zip()
retorna um iterador de tuplas, onde a i-ésima tupla contém o i-ésimo elemento de cada um dos iteráveis do argumento.Outra maneira de pensar em
zip()
é que ela transforma linhas em colunas e colunas em linhas. Isso é semelhante a transpor uma matriz.zip()
é preguiçoso: Os elementos não serão processados até que o iterável seja iterado. Por exemplo, por um loopfor
ou por umlist
.Uma coisa a considerar é que os iteráveis passados para
zip()
podem ter comprimentos diferentes; às vezes por design e às vezes por causa de um bug no código que preparou esses iteráveis. Python oferece três abordagens diferentes para lidar com esse problema:Por padrão,
zip()
para quando o iterável mais curto se esgota. Ele irá ignorar os itens restantes nos iteráveis mais longos, cortando o resultado para o comprimento do iterável mais curto:>>> list(zip(range(3), ['fi', 'fa', 'fo', 'fum'])) [(0, 'fi'), (1, 'fa'), (2, 'fo')]
zip()
é frequentemente usado em casos onde os iteráveis são considerados de tamanho igual. Nesses casos, é recomendado usar a opçãostrict=True
. Sua saída é a mesma dozip()
:: normal>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True)) [('a', 1), ('b', 2), ('c', 3)]
Ao contrário do comportamento padrão, ele levanta uma exceção
ValueError
se um iterável for esgotado antes dos outros:>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True): ... print(item) ... (0, 'fee') (1, 'fi') (2, 'fo') Traceback (most recent call last): ... ValueError: zip() argument 2 is longer than argument 1
Sem o argumento
strict=True
, qualquer bug que resulte em iteráveis de diferentes comprimentos será silenciado, possivelmente se manifestando como um bug difícil de encontrar em outra parte do programa.Iteráveis mais curtos podem ser preenchidos com um valor constante para fazer com que todos os iteráveis tenham o mesmo comprimento. Isso é feito por
itertools.zip_longest()
.
Casos extremos: Com um único argumento iterável,
zip()
retorna um iterador de tuplas de um elemento. Sem argumentos, retorna um iterador vazio.Dicas e truques:
A ordem de avaliação da esquerda para a direita dos iteráveis é garantida. Isso torna possível um idioma para agrupar uma série de dados em grupos de comprimento n usando
zip(*[iter(s)]*n, strict=True)
. Isso repete o mesmo iteradorn
vezes para que cada tupla de saída tenha o resultado de chamadasn
para o iterador. Isso tem o efeito de dividir a entrada em pedaços de n comprimentos.zip()
em conjunto com o operador*
pode ser usado para descompactar uma lista:>>> x = [1, 2, 3] >>> y = [4, 5, 6] >>> list(zip(x, y)) [(1, 4), (2, 5), (3, 6)] >>> x2, y2 = zip(*zip(x, y)) >>> x == list(x2) and y == list(y2) True
Alterado na versão 3.10: Adicionado o argumento
strict
.
- __import__(name, globals=None, locals=None, fromlist=(), level=0)¶
Nota
Esta é uma função avançada que não é necessária na programação diária do Python, ao contrário de
importlib.import_module()
.Esta função é chamada pela instrução
import
. Ela pode ser substituída (importando o módulobuiltins
e atribuindo abuiltins.__import__
) para alterar a semântica da instruçãoimport
, mas isso é fortemente desencorajado, pois geralmente é mais simples usar ganchos de importação (consulte PEP 302) para atingir os mesmos objetivos e não causa problemas com o código que pressupõe que a implementação de importação padrão esteja em uso. O uso direto de__import__()
também é desencorajado em favor deimportlib.import_module()
.A função importa o módulo name, potencialmente usando os dados globals e locals para determinar como interpretar o nome em um contexto de pacote. O fromlist fornece os nomes de objetos ou submódulos que devem ser importados do módulo, fornecidos por name. A implementação padrão não usa seu argumento locals e usa seus globals apenas para determinar o contexto do pacote da instrução
import
.level especifica se é necessário usar importações absolutas ou relativas.
0
(o padrão) significa apenas realizar importações absolutas. Valores positivos para level indicam o número de diretórios pai a serem pesquisados em relação ao diretório do módulo que chama__import__()
(consulte PEP 328 para obter detalhes).Quando a variável name está no formato
pacote.módulo
, normalmente, o pacote de nível superior (o nome até o primeiro ponto) é retornado, não o módulo nomeado por name. No entanto, quando um argumento fromlist não vazio é fornecido, o módulo nomeado por name é retornado.Por exemplo, a instrução
import spam
resulta em bytecode semelhante ao seguinte código:spam = __import__('spam', globals(), locals(), [], 0)
A instrução
import spam.presunto
resulta nesta chamada:spam = __import__('spam.presunto', globals(), locals(), [], 0)
Observe como
__import__()
retorna o módulo de nível superior aqui, porque este é o objeto vinculado a um nome pela instruçãoimport
.Por outro lado, a instrução
from spam.presunto import ovos, salsicha as sals
resulta em_temp = __import__('spam.presunto', globals(), locals(), ['ovos', 'salsicha'], 0) ovos = _temp.ovos sals = _temp.salsicha
Aqui, o módulo
spam.ham
é retornado de__import__()
. A partir desse objeto, os nomes a serem importados são recuperados e atribuídos aos seus respectivos nomes.Se você simplesmente deseja importar um módulo (potencialmente dentro de um pacote) pelo nome, use
importlib.import_module()
.Alterado na versão 3.3: Valores negativos para level não são mais suportados (o que também altera o valor padrão para 0).
Alterado na versão 3.9: Quando as opções de linha de comando
-E
ou-I
estão sendo usadas, a variável de ambientePYTHONCASEOK
é agora ignorada.
Notas de rodapé