11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.

3.12.5 Pesquisa rápida Ir

Funções integradas
O interpretador Python tem uma série de funções e tipos incorporados que estão sempre disponíveis. Eles es‐
tão listados aqui em ordem alfabética.

Funções Integradas

UM E eu R
abs() enumerate() len() range()
aiter() eval() list() repr()
all() exec() locals() reversed()
anext() round()
any() F M
ascii() filter() map() S
float() max() set()
B format() memoryview() setattr()
bin() frozenset() min() slice()
bool() sorted()
breakpoint() G Não staticmethod()
bytearray() getattr() next() str()
bytes() globals() sum()
O super()
C E object()
callable() hasattr() oct() E
chr() hash() open() tuple()
classmethod() help() ord() type()
compile() hex()
complex() P V
EU pow() vars()
E id() print()
delattr() input() property() Z
dict() int() zip()
dir() isinstance()
divmod() issubclass() _
iter() __import__()

abdômen ( x )
Retorna o valor absoluto de um número. O argumento pode ser um inteiro, um número de ponto flutu‐
ante ou um objeto implementando __abs__() . Se o argumento for 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 variante de 2 argumentos.

Adicionado na versão 3.10.

todos ( iterável )

https://docs.python.org/3/library/functions.html#type 1/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Retorna True se todos os elementos do iterável forem verdadeiros (ou se o iterável estiver vazio). Equiva‐
lente a:

def all(iterable):
for element in iterable:
if not element:
return False
return True

aguardável anext ( async_iterator )

aguardável anext ( async_iterator , default )
Quando aguardado, retorna o próximo item do iterador assíncrono fornecido ou o padrão se fornecido e
o iterador estiver esgotado.

Esta é a variante assíncrona do next() builtin e se comporta de forma semelhante.

Isso chama o __anext__() método de async_iterator , retornando um awaitable . Awaiting retorna o pró‐
ximo valor do iterador. Se default for fornecido, ele será retornado se o iterador estiver esgotado, caso
contrário, StopAsyncIteration será levantado.

Adicionado na versão 3.10.

qualquer ( iterável )
Retorna True se algum elemento do iterável for true. Se o iterável estiver vazio, retorna False . Equivalente
a:

def any(iterable):
for element in iterable:
if element:
return True
return False

ascii ( objeto )
Como repr() , retorna uma string contendo uma representação imprimível de um objeto, mas escapa os
caracteres não-ASCII na string retornada usando repr() , \x , \u ou \U escapes. Isso gera uma string simi‐
lar àquela retornada por repr() em Python 2.

caixa ( x )
Converte um número inteiro para uma string binária prefixada com “0b”. O resultado é uma expressão
Python válida. Se x não for um objeto Python int , ele tem que definir um __index__() método que re‐
torna um inteiro. Alguns exemplos:

>>> bin(3) >>>

'0b11'
>>> bin(-10)
'-0b1010'

Se o prefixo “0b” for desejado ou não, você pode usar qualquer uma das seguintes maneiras.

>>> format(14, '#b'), format(14, 'b') >>>

('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

https://docs.python.org/3/library/functions.html#type 2/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Veja também format() para mais informações.

classe bool ( objeto = False , / )

Retorna um valor booleano, ou seja, um de True ou False . O argumento é convertido usando o procedi‐
mento padrão de teste de verdade . Se o argumento for falso ou omitido, isso retorna False ; caso contrá‐
rio, ele retorna True . A bool classe é uma subclasse de int (veja Tipos Numéricos — int, float, complex ).
Ela não pode ser subclassificada mais. Suas únicas instâncias são False e True (veja Tipo Booleano - bool ).

Alterado na versão 3.7: o parâmetro agora é somente posicional.

ponto de interrupção ( * args , ** kws )

Esta função coloca você no depurador no local da chamada. Especificamente, ela chama
sys.breakpointhook() , passando args e kws direto. Por padrão, sys.breakpointhook() chama
pdb.set_trace() sem esperar argumentos. Neste caso, é puramente uma função de conveniência, então
você não precisa importar explicitamente pdb ou digitar tanto código para entrar no depurador. No en‐
tanto, sys.breakpointhook() pode ser definido para alguma outra função e breakpoint() irá chamá-la
automaticamente, permitindo que você coloque no depurador de sua escolha. Se
sys.breakpointhook() não estiver acessível, esta função irá levantar RuntimeError .

Por padrão, o comportamento de breakpoint() pode ser alterado com o PYTHONBREAKPOINT variável de
ambiente. Veja sys.breakpointhook() para detalhes de uso.

Observe que isso não é garantido se sys.breakpointhook() tiver sido substituído.

Gera um evento de auditoria builtins.breakpoint com argumento breakpointhook .

Adicionado na versão 3.7.

classe bytearray ( fonte = b'' )

classe bytearray ( fonte , codificação )
classe bytearray ( fonte , codificação , erros )
Retorna um novo array de bytes. A bytearray classe é uma sequência mutável de inteiros no intervalo 0
<= x < 256. Ela tem a maioria dos métodos usuais de sequências mutáveis, descritos em Tipos de Sequên‐
cia Mutável , assim como a maioria dos métodos que o bytes tipo tem, veja Bytes e Operações de
Bytearray .

O parâmetro de origem opcional pode ser usado para inicializar o array de algumas maneiras diferentes:

Se for uma string , você também deve fornecer os parâmetros de codificação (e, opcionalmente,
erros bytearray() ); em seguida, converte a string em bytes usando str.encode() .
Se for um inteiro , o array terá esse tamanho e será inicializado com bytes nulos.
Se for um objeto em conformidade com a interface de buffer , um buffer somente leitura do objeto
será usado para inicializar a matriz de bytes.
Se for um iterável , deve ser um iterável de inteiros no intervalo , que são usados ​como conteúdo inicial
do array. 0 <= x < 256

Sem um argumento, uma matriz de tamanho 0 é criada.

Veja também Tipos de Sequência Binária — bytes, bytearray, memoryview e Objetos Bytearray .

classe bytes ( fonte = b'' )

https://docs.python.org/3/library/functions.html#type 3/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

classe bytes ( fonte , codificação )

bytes de classe ( fonte , codificação , erros )
Retorna um novo objeto “bytes” que é uma sequência imutável de inteiros no intervalo . é uma versão
imutável de – ele tem os mesmos métodos não mutantes e o mesmo comportamento de indexação e
fatiamento. 0 <= x < 256 bytes bytearray

Consequentemente, os argumentos do construtor são interpretados como para bytearray() .

Objetos de bytes também podem ser criados com literais, veja String e Literais de bytes .

Veja também Tipos de sequência binária — bytes, bytearray, memoryview , Objetos de bytes e Operações
de bytes e bytearray .

chamável ( objeto )
Retorna True se o argumento object False parece chamável, se não. Se retornar True , ainda é possível
que uma chamada falhe, mas se for False , chamar object nunca terá sucesso. Note que classes são cha‐
máveis ​(chamar uma classe retorna uma nova instância); instâncias são chamáveis ​se sua classe tiver um
__call__() método.

Adicionado na versão 3.2: Esta função foi removida primeiro no Python 3.0 e depois trazida de volta
no Python 3.2.

chr ( eu )
Retorna a string que representa um caractere cujo ponto de código Unicode é o inteiro i . Por exemplo,
chr(97) retorna a string 'a' , enquanto chr(8364) retorna a string '€' . Este é o inverso de ord() .

The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16). ValueError will be
raised if i is outside that range.

@classmethod
Transform a method into a class method.

A class method receives the class as an implicit first argument, just like an instance method receives the
instance. To declare a class method, use this idiom:

class C:
@classmethod
def f(cls, arg1, arg2): ...

The @classmethod form is a function decorator – see Function definitions for details.

A class method can be called either on the class (such as C.f() ) or on an instance (such as C().f() ). The
instance is ignored except for its class. If a class method is called for a derived class, the derived class ob‐
ject is passed as the implied first argument.

Class methods are different than C++ or Java static methods. If you want those, see staticmethod() in
this section. For more information on class methods, see The standard type hierarchy.

Changed in version 3.9: Class methods can now wrap other descriptors such as property() .

Changed in version 3.10: Class methods now inherit the method attributes ( __module__ , __name__ ,
__qualname__ , __doc__ and __annotations__ ) and have a new __wrapped__ attribute.

https://docs.python.org/3/library/functions.html#type 4/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Changed in version 3.11: Class methods can no longer wrap other descriptors such as property() .

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

Compile the source into a code or AST object. Code objects can be executed by exec() or eval() . source
can either be a normal string, a byte string, or an AST object. Refer to the ast module documentation for
information on how to work with AST objects.

The filename argument should give the file from which the code was read; pass some recognizable value if
it wasn’t read from a file ( '<string>' is commonly used).

The mode argument specifies what kind of code must be compiled; it can be 'exec' if source consists of a
sequence of statements, 'eval' if it consists of a single expression, or 'single' if it consists of a single
interactive statement (in the latter case, expression statements that evaluate to something other than
None will be printed).

The optional arguments flags and dont_inherit control which compiler options should be activated and
which future features should be allowed. If neither is present (or both are zero) the code is compiled with
the same flags that affect the code that is calling compile() . If the flags argument is given and
dont_inherit is not (or is zero) then the compiler options and the future statements specified by the flags
argument are used in addition to those that would be used anyway. If dont_inherit is a non-zero integer
then the flags argument is it – the flags (future features and compiler options) in the surrounding code are
ignored.

Compiler options and future statements are specified by bits which can be bitwise ORed together to
specify multiple options. The bitfield required to specify a given future feature can be found as the
compiler_flag attribute on the _Feature instance in the __future__ module. Compiler flags can be
found in ast module, with PyCF_ prefix.

The argument optimize specifies the optimization level of the compiler; the default value of -1 selects the
optimization level of the interpreter as given by -O options. Explicit levels are 0 (no optimization;
__debug__ is true), 1 (asserts are removed, __debug__ is false) or 2 (docstrings are removed too).

This function raises SyntaxError if the compiled source is invalid, and ValueError if the source contains
null bytes.

If you want to parse Python code into its AST representation, see ast.parse() .

Raises an auditing event compile with arguments source and filename . This event may also be raised by
implicit compilation.

Note: When compiling a string with multi-line code in 'single' or 'eval' mode, input must be ter‐
minated by at least one newline character. This is to facilitate detection of incomplete and complete
statements in the code module.

Warning: It is possible to crash the Python interpreter with a sufficiently large/complex string when
compiling to an AST object due to stack depth limitations in Python’s AST compiler.

Changed in version 3.2: Allowed use of Windows and Mac newlines. Also, input in 'exec' mode
does not have to end in a newline anymore. Added the optimize parameter.

https://docs.python.org/3/library/functions.html#type 5/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Changed in version 3.5: Previously, TypeError was raised when null bytes were encountered in
source.

Added in version 3.8: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT can now be passed in flags to enable sup‐
port for top-level await , async for , and async with .

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)
Convert a single string or number to a complex number, or create a complex number from real and
imaginary parts.

Examples:

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

If the argument is a string, it must contain either a real part (in the same format as for float() ) or an
imaginary part (in the same format but with a 'j' or 'J' suffix), or both real and imaginary parts (the
sign of the imaginary part is mandatory in this case). The string can optionally be surrounded by whitespa‐
ces and the round parentheses '(' and ')' , which are ignored. The string must not contain whitespace
between '+' , '-' , the 'j' or 'J' suffix, and the decimal number. For example, complex('1+2j') is fine,
but complex('1 + 2j') raises ValueError . More precisely, the input must conform to the
complexvalue production rule in the following grammar, after parentheses and leading and trailing whi‐
tespace characters are removed:

complexvalue ::= floatvalue |

floatvalue ("j" | "J") |
floatvalue sign absfloatvalue ("j" | "J")

If the argument is a number, the constructor serves as a numeric conversion like int and float . For a ge‐
neral Python object x , complex(x) delegates to x.__complex__() . If __complex__() is not defined then
it falls back to __float__() . If __float__() is not defined then it falls back to __index__() .

If two arguments are provided or keyword arguments are used, each argument may be any numeric type
(including complex). If both arguments are real numbers, return a complex number with the real compo‐
nent real and the imaginary component imag. If both arguments are complex numbers, return a complex
number with the real component real.real-imag.imag and the imaginary component
real.imag+imag.real . If one of arguments is a real number, only its real component is used in the above
expressions.
https://docs.python.org/3/library/functions.html#type 6/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

If all arguments are omitted, returns 0j .

The complex type is described in Numeric Types — int, float, complex.

Changed in version 3.6: Grouping digits with underscores as in code literals is allowed.

Changed in version 3.8: Falls back to __index__() if __complex__() and __float__() are not
defined.

delattr(object, name)
This is a relative of setattr() . The arguments are an object and a string. The string must be the name of
one of the object’s attributes. The function deletes the named attribute, provided the object allows it. For
example, delattr(x, 'foobar') is equivalent to del x.foobar . name need not be a Python identifier
(see setattr() ).

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
Create a new dictionary. The dict object is the dictionary class. See dict and Mapping Types — dict for
documentation about this class.

For other containers see the built-in list , set , and tuple classes, as well as the collections module.

dir()
dir(object)
Without arguments, return the list of names in the current local scope. With an argument, attempt to re‐
turn a list of valid attributes for that object.

If the object has a method named __dir__() , this method will be called and must return the list of attri‐
butes. This allows objects that implement a custom __getattr__() or __getattribute__() function to
customize the way dir() reports their attributes.

If the object does not provide __dir__() , the function tries its best to gather information from the
object’s __dict__ attribute, if defined, and from its type object. The resulting list is not necessarily com‐
plete and may be inaccurate when the object has a custom __getattr__() .

The default dir() mechanism behaves differently with different types of objects, as it attempts to pro‐
duce the most relevant, rather than complete, information:

If the object is a module object, the list contains the names of the module’s attributes.
If the object is a type or class object, the list contains the names of its attributes, and recursively of the
attributes of its bases.
Otherwise, the list contains the object’s attributes’ names, the names of its class’s attributes, and
recursively of the attributes of its class’s base classes.

The resulting list is sorted alphabetically. For example:

>>> 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__',
https://docs.python.org/3/library/functions.html#type 7/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5
'_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']

Note: Because dir() is supplied primarily as a convenience for use at an interactive prompt, it tries to
supply an interesting set of names more than it tries to supply a rigorously or consistently defined set
of names, and its detailed behavior may change across releases. For example, metaclass attributes are
not in the result list when the argument is a class.

divmod(a, b)
Take two (non-complex) numbers as arguments and return a pair of numbers consisting of their quotient
and remainder when using integer division. With mixed operand types, the rules for binary arithmetic ope‐
rators apply. For integers, the result is the same as (a // b, a % b) . For floating-point numbers the re‐
sult is (q, a % b) , where q is usually math.floor(a / b) but may be 1 less than that. In any case q * b
+ a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b) <
abs(b) .

enumerate(iterable, start=0)
Return an enumerate object. iterable must be a sequence, an iterator, or some other object which supports
iteration. The __next__() method of the iterator returned by enumerate() returns a tuple containing a
count (from start which defaults to 0) and the values obtained from iterating over 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')]

Equivalent to:

def enumerate(iterable, start=0):

n = start
for elem in iterable:
yield n, elem
n += 1

eval(expression, globals=None, locals=None)

Parameters: expression ( str | code object) – A Python expression.
globals ( dict | None ) – The global namespace (default: None ).
locals (mapping | None ) – The local namespace (default: None ).
Returns: The result of the evaluated expression.
Raises: Syntax errors are reported as exceptions.

The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition
list) using the globals and locals dictionaries as global and local namespace. If the globals dictionary is pre‐
sent and does not contain a value for the key __builtins__ , a reference to the dictionary of the built-in

https://docs.python.org/3/library/functions.html#type 8/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

module builtins is inserted under that key before expression is parsed. That way you can control what
builtins are available to the executed code by inserting your own __builtins__ dictionary into globals
before passing it to eval() . If the locals dictionary is omitted it defaults to the globals dictionary. If both
dictionaries are omitted, the expression is executed with the globals and locals in the environment where
eval() is called. Note, eval() does not have access to the nested scopes (non-locals) in the enclosing
environment.

Example:

>>> x = 1 >>>
>>> eval('x+1')
2

This function can also be used to execute arbitrary code objects (such as those created by compile() ). In
this case, pass a code object instead of a string. If the code object has been compiled with 'exec' as the
mode argument, eval() 's return value will be None .

Hints: dynamic execution of statements is supported by the exec() function. The globals() and
locals() functions return the current global and local dictionary, respectively, which may be useful to
pass around for use by eval() or exec() .

If the given source is a string, then leading and trailing spaces and tabs are stripped.

See ast.literal_eval() for a function that can safely evaluate strings with expressions containing only
literals.

Raises an auditing event exec with the code object as the argument. Code compilation events may also
be raised.

exec(object, globals=None, locals=None, /, *, closure=None)

This function supports dynamic execution of Python code. object must be either a string or a code object.
If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax
error occurs). [1] If it is a code object, it is simply executed. In all cases, the code that’s executed is expec‐
ted to be valid as file input (see the section File input in the Reference Manual). Be aware that the
nonlocal , yield , and return statements may not be used outside of function definitions even within the
context of code passed to the exec() function. The return value is None .

In all cases, if the optional parts are omitted, the code is executed in the current scope. If only globals is
provided, it must be a dictionary (and not a subclass of dictionary), which will be used for both the global
and the local variables. If globals and locals are given, they are used for the global and local variables,
respectively. If provided, locals can be any mapping object. Remember that at the module level, globals
and locals are the same dictionary.

Note: Most users should just pass a globals argument and never locals. If exec gets two separate ob‐
jects as globals and locals, the code will be executed as if it were embedded in a class definition.

If the globals dictionary does not contain a value for the key __builtins__ , a reference to the dictionary
of the built-in module builtins is inserted under that key. That way you can control what builtins are
available to the executed code by inserting your own __builtins__ dictionary into globals before passing
it to exec() .
https://docs.python.org/3/library/functions.html#type 9/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

The closure argument specifies a closure–a tuple of cellvars. It’s only valid when the object is a code object
containing free variables. The length of the tuple must exactly match the number of free variables referen‐
ced by the code object.

Raises an auditing event exec with the code object as the argument. Code compilation events may also
be raised.

Note: The built-in functions globals() and locals() return the current global and local dictionary,
respectively, which may be useful to pass around for use as the second and third argument to exec() .

Note: The default locals act as described for function locals() below: modifications to the default
locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of
the code on locals after function exec() returns.

Changed in version 3.11: Added the closure parameter.

filter(function, iterable)
Construct an iterator from those elements of iterable for which function is true. iterable may be either a se‐
quence, a container which supports iteration, or an iterator. If function is None , the identity function is as‐
sumed, that is, all elements of iterable that are false are removed.

Note that filter(function, iterable) is equivalent to the generator expression (item for item in
iterable if function(item)) if function is not None and (item for item in iterable if item) if
function is None .

See itertools.filterfalse() for the complementary function that returns elements of iterable for
which function is false.

class float(number=0.0, /)
class float(string, /)
Return a floating-point number constructed from a number or a string.

Examples:

>>> 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 si‐
nal e opcionalmente inserido em espaços 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 em conformi‐
dade com a floatvalue regra de produção na seguinte gramática, após os caracteres de espaço em
branco iniciais e finais serem removidos:

https://docs.python.org/3/library/functions.html#type 10/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

sinal ::= "+" | "-"

infinito ::= "Infinito" | "inf"
nan ::= "nan"
dígito ::= <um dígito decimal Unicode,
ou seja, caracteres na categoria geral Unicode Nd> parte_do_dígito ::= digit (["_"
número ::= [ digitpart ] "." digitpart | digitpart ["."]
expoente ::= ("e" | "E") [ sign ] número_flutuante ::= [ ]
valor_flutuante_abs ::= | | valor_flutuante ::= [ ] digitpart
number exponent floatnumber infinity nan
sign absfloatvalue

A caixa não é significativa, então, por exemplo, “inf”, “Inf”, “INFINITY” e “iNfINity” são grafias aceitáveis ​
para infinito positivo.

Caso contrário, se o argumento for um inteiro ou um número de ponto flutuante, um número de ponto
flutuante com o mesmo valor (dentro da precisão de ponto flutuante do Python) será retornado. Se o ar‐
gumento estiver fora do intervalo de um float do Python, um OverflowError será levantado.

Para um objeto Python geral x , float(x) delega para x.__float__() . Se __float__() não for definido,
ele retorna para __index__() .

Se nenhum argumento for fornecido, 0.0 será retornado.

O tipo float é descrito em Tipos Numéricos — int, float, complex .

Alterado na versão 3.6: É permitido agrupar dígitos com sublinhados como em literais de código.

Alterado na versão 3.7: o parâmetro agora é somente posicional.

Alterado na versão 3.8: retorna para __index__() se __float__() não estiver definido.

formato ( valor , format_spec = '' )

Converte um valor para uma representação “formatada”, conforme controlado por format_spec . A inter‐
pretação de format_spec dependerá do tipo do argumento de valor ; no entanto, há uma sintaxe de for‐
matação padrão que é usada pela maioria dos tipos internos: Format Specification Mini-Language .

O format_spec padrão é uma string vazia que geralmente produz o mesmo efeito que chamar
str(value) .

Uma chamada para é traduzida para que ignora o dicionário de instância ao pesquisar o método do valor
. Uma exceção é gerada se a pesquisa do método atingir e o format_spec não estiver vazio, ou se o
format_spec ou o valor de retorno não forem strings. format(value,
format_spec) type(value).__format__(value, format_spec) __format__() TypeError object

Alterado na versão 3.4: object().__format__(format_spec) é gerado TypeError se format_spec

não for uma string vazia.

classe frozenset ( iterável = set() )

Retorna um novo frozenset objeto, opcionalmente com elementos retirados de iterable . frozenset é
uma classe interna. Veja frozenset e Set Types — set, frozenset para documentação sobre esta classe.

Para outros contêineres, consulte as classes integradas set , list , tuple e dict , bem como o
collections módulo.

https://docs.python.org/3/library/functions.html#type 11/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

getattr ( objeto , nome )

getattr ( objeto , nome , padrão )
Retorna o valor do atributo nomeado do objeto . name deve ser uma string. Se a string for o nome de um
dos atributos do objeto, o resultado será o valor desse atributo. Por exemplo, é equivalente a . Se o atri‐
buto nomeado não existir, default será retornado se fornecido, caso contrário, será gerado. name não pre‐
cisa ser um identificador Python (veja ). getattr(x, 'foobar') x.foobar AttributeError setattr()

Observação: Como a alteração de nomes privados ocorre no momento da compilação, é necessário

alterar manualmente o nome de um atributo privado (atributos com dois sublinhados iniciais) para re‐
cuperá-lo com getattr() .

globais ( )
Retorna o dicionário que implementa o namespace 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 ( objeto , nome )

Os argumentos são um objeto e uma string. O resultado é True se a string é o nome de um dos atributos
do objeto, False se não. (Isso é implementado chamando e vendo se ele levanta um ou
não.) getattr(object, name) AttributeError

hash ( objeto )
Return the hash value of the object (if it has one). Hash values are integers. They are used to quickly com‐
pare dictionary keys during a dictionary lookup. Numeric values that compare equal have the same hash
value (even if they are of different types, as is the case for 1 and 1.0).

Note: For objects with custom __hash__() methods, note that hash() truncates the return value ba‐
sed on the bit width of the host machine.

help()
help(request)
Invoke the built-in help system. (This function is intended for interactive use.) If no argument is given, the
interactive help system starts on the interpreter console. If the argument is a string, then the string is loo‐
ked up as the name of a module, function, class, method, keyword, or documentation topic, and a help
page is printed on the console. If the argument is any other kind of object, a help page on the object is
generated.

Note that if a slash(/) appears in the parameter list of a function when invoking help() , it means that the
parameters prior to the slash are positional-only. For more info, see the FAQ entry on positional-only
parameters.

This function is added to the built-in namespace by the site module.

Changed in version 3.4: Changes to pydoc and inspect mean that the reported signatures for calla‐
bles are now more comprehensive and consistent.

hex(x)
Convert an integer number to a lowercase hexadecimal string prefixed with “0x”. If x is not a Python int
object, it has to define an __index__() method that returns an integer. Some examples:
https://docs.python.org/3/library/functions.html#type 12/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

>>> hex(255) >>>

'0xff'
>>> hex(-42)
'-0x2a'

If you want to convert an integer number to an uppercase or lower hexadecimal string with prefix or not,
you can use either of the following ways:

>>> '%#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')

See also format() for more information.

See also int() for converting a hexadecimal string to an integer using a base of 16.

Note: To obtain a hexadecimal string representation for a float, use the float.hex() method.

id(object)
Return the “identity” of an object. This is an integer which is guaranteed to be unique and constant for this
object during its lifetime. Two objects with non-overlapping lifetimes may have the same id() value.

CPython implementation detail: This is the address of the object in memory.

Raises an auditing event builtins.id with argument id .

input()
input(prompt)
If the prompt argument is present, it is written to standard output without a trailing newline. The function
then reads a line from input, converts it to a string (stripping a trailing newline), and returns that. When
EOF is read, EOFError is raised. Example:

>>> s = input('--> ') >>>

--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

If the readline module was loaded, then input() will use it to provide elaborate line editing and history
features.

Raises an auditing event builtins.input with argument prompt before reading input

Raises an auditing event builtins.input/result with the result after successfully reading input.

class int(number=0, /)
class int(string, /, base=10)
Return an integer object constructed from a number or a string, or return 0 if no arguments are given.

Examples:

https://docs.python.org/3/library/functions.html#type 13/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

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

If the argument defines __int__() , int(x) returns x.__int__() . If the argument defines __index__() ,
it returns x.__index__() . If the argument defines __trunc__() , it returns x.__trunc__() . For floating-
point numbers, this truncates towards zero.

If the argument is not a number or if base is given, then it must be a string, bytes , or bytearray instance
representing an integer in radix base. Optionally, the string can be preceded by + or - (with no space in
between), have leading zeros, be surrounded by whitespace, and have single underscores interspersed
between digits.

A base-n integer string contains digits, each representing a value from 0 to n-1. The values 0–9 can be re‐
presented by any Unicode decimal digit. The values 10–35 can be represented by a to z (or A to Z ). The
default base is 10. The allowed bases are 0 and 2–36. Base-2, -8, and -16 strings can be optionally prefixed
with 0b / 0B , 0o / 0O , or 0x / 0X , as with integer literals in code. For base 0, the string is interpreted in a simi‐
lar way to an integer literal in code, in that the actual base is 2, 8, 10, or 16 as determined by the prefix.
Base 0 also disallows leading zeros: int('010', 0) is not legal, while int('010') and int('010', 8)
are.

The integer type is described in Numeric Types — int, float, complex.

Changed in version 3.4: If base is not an instance of int and the base object has a base.__index__
method, that method is called to obtain an integer for the base. Previous versions used
base.__int__ instead of base.__index__ .

Changed in version 3.6: Grouping digits with underscores as in code literals is allowed.

Changed in version 3.7: The first parameter is now positional-only.

Changed in version 3.8: Falls back to __index__() if __int__() is not defined.

Changed in version 3.11: The delegation to __trunc__() is deprecated.

Changed in version 3.11: int string inputs and string representations can be limited to help avoid
denial of service attacks. A ValueError is raised when the limit is exceeded while converting a string
to an int or when converting an int into a string would exceed the limit. See the integer string
conversion length limitation documentation.

isinstance(object, classinfo)
Return True if the object argument is an instance of the classinfo argument, or of a (direct, indirect, or vir‐
tual) subclass thereof. If object is not an object of the given type, the function always returns False . If clas‐
sinfo is a tuple of type objects (or recursively, other such tuples) or a Union Type of multiple types, return

https://docs.python.org/3/library/functions.html#type 14/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

True if object is an instance of any of the types. If classinfo is not a type or tuple of types and such tuples,
a TypeError exception is raised. TypeError may not be raised for an invalid type if an earlier check
succeeds.

Changed in version 3.10: classinfo can be a Union Type.

issubclass(class, classinfo)
Return True if class is a subclass (direct, indirect, or virtual) of classinfo. A class is considered a subclass of
itself. classinfo may be a tuple of class objects (or recursively, other such tuples) or a Union Type, in which
case return True if class is a subclass of any entry in classinfo. In any other case, a TypeError exception is
raised.

Changed in version 3.10: classinfo can be a Union Type.

iter(object)
iter(object, sentinel)
Return an iterator object. The first argument is interpreted very differently depending on the presence of
the second argument. Without a second argument, object must be a collection object which supports the
iterable protocol (the __iter__() method), or it must support the sequence protocol (the
__getitem__() method with integer arguments starting at 0 ). If it does not support either of those pro‐
tocols, TypeError is raised. If the second argument, sentinel, is given, then object must be a callable ob‐
ject. The iterator created in this case will call object with no arguments for each call to its __next__()
method; if the value returned is equal to sentinel, StopIteration will be raised, otherwise the value will
be returned.

See also Iterator Types.

One useful application of the second form of iter() is to build a block-reader. For example, reading fi‐
xed-width blocks from a binary database file until the end of file is reached:

from functools import partial

with open('mydata.db', 'rb') as f:
for block in iter(partial(f.read, 64), b''):
process_block(block)

len(s)
Return the length (the number of items) of an object. The argument may be a sequence (such as a string,
bytes, tuple, list, or range) or a collection (such as a dictionary, set, or frozen set).

CPython implementation detail: len raises OverflowError on lengths larger than sys.maxsize , such
as range(2 ** 100) .

class list
class list(iterable)
Rather than being a function, list is actually a mutable sequence type, as documented in Lists and Se‐
quence Types — list, tuple, range.

locals()
Update and return a dictionary representing the current local symbol table. Free variables are returned by
locals() when it is called in function blocks, but not in class blocks. Note that at the module level,
locals() and globals() are the same dictionary.

https://docs.python.org/3/library/functions.html#type 15/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Note: The contents of this dictionary should not be modified; changes may not affect the values of lo‐
cal and free variables used by the interpreter.

map(function, iterable, *iterables)

Return an iterator that applies function to every item of iterable, yielding the results. If additional iterables
arguments are passed, function must take that many arguments and is applied to the items from all itera‐
bles in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases
where the function inputs are already arranged into argument tuples, see itertools.starmap() .

max ( iterável , * , chave = Nenhum )

max ( iterável , * , padrão , chave = Nenhum )
max ( arg1 , arg2 , * args , chave = Nenhum )
Retorna o maior item em um iterável ou o maior entre dois ou mais argumentos.

Se um argumento posicional for fornecido, ele deve ser um iterável . O maior item no iterável é retornado.
Se dois ou mais argumentos posicionais forem fornecidos, o maior dos argumentos posicionais é
retornado.

Há dois argumentos opcionais somente de palavra-chave. O argumento key especifica uma função de or‐
denação de um argumento como a usada para list.sort() . O argumento default especifica um objeto a
ser retornado se o iterável fornecido estiver vazio. Se o iterável estiver vazio e default não for fornecido, a
ValueError será levantado.

Se vários itens forem máximos, a função retorna o primeiro encontrado. Isso é consistente com outras fer‐
ramentas de preservação da estabilidade de classificação, como e . sorted(iterable, key=keyfunc,
reverse=True)[0] heapq.nlargest(1, iterable, key=keyfunc)

Alterado na versão 3.4: adicionado o parâmetro padrão somente para palavras-chave.

Alterado na versão 3.8: A chave pode ser None .

classe memoryview ( objeto )

Retorna um objeto “memory view” criado a partir do argumento fornecido. Veja Memory Views para mais
informações.

min ( iterável , * , chave = Nenhum )

min ( iterável , * , padrão , chave = Nenhum )
min ( arg1 , arg2 , * args , chave = Nenhum )
Retorna o menor item em um iterável ou o menor entre dois ou mais argumentos.

Se um argumento posicional for fornecido, ele deve ser um iterável . O menor item no iterável é retor‐
nado. Se dois ou mais argumentos posicionais forem fornecidos, o menor dos argumentos posicionais é
retornado.

Há dois argumentos opcionais somente de palavra-chave. O argumento key especifica uma função de or‐
denação de um argumento como a usada para list.sort() . O argumento default especifica um objeto a
ser retornado se o iterável fornecido estiver vazio. Se o iterável estiver vazio e default não for fornecido, a
ValueError será levantado.

https://docs.python.org/3/library/functions.html#type 16/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Se vários itens forem mínimos, a função retorna o primeiro encontrado. Isso é consistente com outras fer‐
ramentas de preservação da estabilidade de classificação, como e . sorted(iterable, key=keyfunc)
[0] heapq.nsmallest(1, iterable, key=keyfunc)

Alterado na versão 3.4: adicionado o parâmetro padrão somente para palavras-chave.

Alterado na versão 3.8: A chave pode ser None .

próximo ( iterador )
próximo ( iterador , padrão )
Recupere o próximo item do iterador chamando seu __next__() método. Se default for fornecido, ele
será retornado se o iterador estiver esgotado, caso contrário, StopIteration será levantado.

objeto de classe
Retorna um novo objeto sem características. object é uma base para todas as classes. Ela tem métodos
que são comuns a todas as instâncias de classes Python. Esta função não aceita nenhum argumento.

Observação: object não tem um __dict__ , então você não pode atribuir atributos arbitrários a uma
instância da object classe.

out ( x )
Converte um número inteiro para uma string octal prefixada com “0o”. O resultado é uma expressão
Python válida. Se x não for um objeto Python int , ele tem que definir um __index__() método que re‐
torna um inteiro. Por exemplo:

>>> oct(8) >>>

'0o10'
>>> oct(-56)
'-0o70'

Se você quiser converter um número inteiro em uma string octal com o prefixo “0o” ou não, você pode
usar qualquer uma das seguintes maneiras.

>>> '%#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.

abrir ( arquivo , modo = 'r' , buffering = -1 , codificação = Nenhum , erros = Nenhum ,

nova linha = Nenhum , closefd = Verdadeiro , abridor = Nenhum )
Abra o arquivo e retorne um objeto de arquivo correspondente . Se o arquivo não puder ser aberto, um
OSError será levantado. Veja Lendo e Escrevendo Arquivos para mais exemplos de como usar esta função.

file é um objeto do tipo caminho que fornece o nome do caminho (absoluto ou relativo ao diretório de
trabalho atual) do arquivo a ser aberto ou um descritor de arquivo inteiro do arquivo a ser encapsulado.
(Se um descritor de arquivo for fornecido, ele será fechado quando o objeto de E/S retornado for fechado,
a menos que closefd esteja definido como False .)

https://docs.python.org/3/library/functions.html#type 17/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

mode é uma string opcional que especifica o modo em que o arquivo é aberto. O padrão é 'r' que signi‐
fica aberto para leitura no modo texto. Outros valores comuns são 'w' para escrita (truncando o arquivo
se ele já existir), 'x' para criação exclusiva e 'a' para anexação (que em alguns sistemas Unix, significa que
todas as gravações são anexadas ao final do arquivo, independentemente da posição de busca atual). No
modo texto, se encoding não for especificado, a codificação usada depende da plataforma:
locale.getencoding() é chamado para obter a codificação de localidade atual. (Para leitura e gravação
de bytes brutos, use o modo binário e deixe a codificação não especificada.) Os modos disponíveis são:

Personagem Significado

'r' aberto para leitura (padrão)

'w' aberto para escrita, truncando o arquivo primeiro

'x' aberto para criação exclusiva, falhando se o arquivo já existir

'a' aberto para escrita, anexando ao final do arquivo se existir

'b' modo binário

't' modo de texto (padrão)

'+' aberto para atualização (leitura e escrita)

O modo padrão é 'r' (aberto 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 truncamento.

Conforme mencionado na Visão geral , o Python distingue entre E/S binária e de texto. Arquivos abertos
no modo binário (incluindo 'b' no argumento mode ) retornam conteúdos como bytes objetos sem ne‐
nhuma decodificação. No modo texto (o padrão, ou quando 't' é incluído no argumento mode ), o con‐
teúdo do arquivo é retornado como , os bytes tendo sido primeiro decodificados usando uma codificação
dependente da plataforma ou usando a codificação str especificada, se fornecida.

Observação: O Python não depende da noção de arquivos de texto do sistema operacional subja‐
cente; todo o processamento é feito pelo próprio Python e, portanto, é independente de plataforma.

buffering é um inteiro opcional usado para definir a política de buffering. Passe 0 para desligar o buffering
(permitido somente no modo binário), 1 para selecionar o buffering de linha (utilizável somente ao escre‐
ver no modo 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 forma se aplica a E/S com buffer binário, mas
TextIOWrapper (ou seja, arquivos abertos com mode='r+' ) teriam outro buffering. Para desabilitar o buf‐
fering em TextIOWrapper , considere usar o write_through sinalizador para
io.TextIOWrapper.reconfigure() . Quando nenhum argumento buffering é fornecido, a política de buf‐
fering padrão funciona da seguinte maneira:

Arquivos binários são armazenados em buffer em pedaços de tamanho fixo; o tamanho do buffer é es‐
colhido usando uma heurística tentando determinar o “tamanho do bloco” do dispositivo subjacente e
retornando a io.DEFAULT_BUFFER_SIZE . Em muitos sistemas, o buffer normalmente terá 4096 ou 8192
bytes de comprimento.

https://docs.python.org/3/library/functions.html#type 18/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Arquivos de texto “interativos” (arquivos para os quais isatty() retorna True ) usam buffer de linha.
Outros arquivos de texto usam a política descrita acima para arquivos binários.

encoding é o nome da codificação usada para decodificar ou codificar o arquivo. Isso deve ser usado so‐
mente no modo texto. A codificação padrão depende da plataforma (qualquer que seja
locale.getencoding() o retorno), mas qualquer codificação de texto suportada pelo Python pode ser
usada. Veja o codecs módulo para a lista de codificações suportadas.

errors é uma string opcional que especifica como erros de codificação e decodificação devem ser manipu‐
lados — isso não pode ser usado no modo binário. Uma variedade de manipuladores de erro padrão es‐
tão disponíveis (listados em Error Handlers ), embora qualquer nome de manipulação de erro que tenha
sido registrado codecs.register_error() também seja válido. Os nomes padrão incluem:

'strict' para levantar uma ValueError exceção se houver um erro de codificação. O valor padrão de
None tem o mesmo efeito.
'ignore' ignora erros. Note que ignorar erros de codificação pode levar à perda de dados.
'replace' faz com que um marcador de substituição (como '?' ) seja inserido onde há dados
malformados.
'surrogateescape' representará quaisquer bytes incorretos como unidades de código substituto bai‐
xas 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 surrogateescape manipulador de erros for usado ao gravar dados.
Isso é útil para processar arquivos em uma codificação desconhecida.
'xmlcharrefreplace' só é suportado ao gravar em um arquivo. Caracteres não suportados pela codifi‐
cação são substituídos pela referência de caractere XML apropriada . &#nnn;
'backslashreplace' substitui dados malformados pelas sequências de escape com barra invertida do
Python.
'namereplace' (também suportado somente durante a escrita) substitui caracteres não suportados por
\N{...} sequências de escape.

newline determina como analisar caracteres de nova linha do fluxo. Pode ser None , '' , '\n' , '\r' , e
'\r\n' . Funciona da seguinte forma:

Ao ler a entrada do fluxo, se newline for None , o modo universal newlines é habilitado. As linhas na en‐
trada podem terminar em '\n' , '\r' , ou '\r\n' , e são traduzidas para '\n' antes de serem retorna‐
das ao chamador. Se for '' , o modo universal newlines é habilitado, mas as terminações de linha são
retornadas ao chamador sem tradução. Se tiver qualquer um dos outros valores legais, as linhas de en‐
trada são terminadas apenas pela string fornecida, e a terminação de linha é retornada ao chamador
sem tradução.
Ao escrever a saída para o fluxo, se newline for None , quaisquer '\n' caracteres escritos serão traduzi‐
dos para o separador de linha padrão do sistema, os.linesep . Se newline for '' ou '\n' , nenhuma
tradução ocorrerá. Se newline for qualquer um dos outros valores legais, quaisquer '\n' caracteres es‐
critos serão traduzidos para a string fornecida.

Se closefd for False e um descritor de arquivo em vez de um nome de arquivo foi fornecido, o descritor
de arquivo subjacente será mantido aberto quando o arquivo for fechado. Se um nome de arquivo for for‐
necido, closefd deve ser True (o padrão); caso contrário, um erro será levantado.

Um opener personalizado pode ser usado passando um callable como opener . O descritor de arquivo
subjacente para o objeto de arquivo é então obtido chamando opener com ( file , flags ). opener deve re‐
https://docs.python.org/3/library/functions.html#type 19/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

tornar um descritor de arquivo aberto (passar os.open como opener resulta em funcionalidade seme‐
lhante a passar None ).

O arquivo recém-criado não é herdável .

O exemplo a seguir usa o parâmetro dir_fd da os.open() função para abrir um arquivo relativo a um de‐
terminado diretório:

>>> import os >>>

>>> dir_fd = os.open('somedir', 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('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd) # don't leak a file descriptor

O tipo de objeto de arquivo retornado pela open() função depende do modo. Quando open() é usado
para abrir um arquivo em um modo de texto ( 'w' , 'r' , 'wt' , 'rt' , etc.), ele retorna uma subclasse de
io.TextIOBase (especificamente io.TextIOWrapper ). Quando usado para abrir um arquivo em um modo
binário com buffering, a classe retornada é uma subclasse de io.BufferedIOBase . A classe exata varia: no
modo de leitura binária, ele retorna um io.BufferedReader ; nos modos de gravação binária e de acrés‐
cimo binária, ele retorna um io.BufferedWriter , e no modo de leitura/gravação, ele retorna um
io.BufferedRandom . Quando o buffering é desabilitado, o fluxo bruto, uma subclasse de io.RawIOBase ,
io.FileIO , é retornado.

Veja também os módulos de manipulação de arquivos, como fileinput , io (onde open() é declarado),
os , os.path , tempfile , e shutil .

Gera um evento de auditoria open com argumentos path , mode , flags .

Os argumentos mode e flags podem ter sido modificados ou inferidos da chamada original.

Alterado na versão 3.3:

O parâmetro opener foi adicionado.

O 'x' modo foi adicionado.
IOError costumava ser criado, agora é um alias de OSError .
FileExistsError agora é gerado se o arquivo aberto no modo de criação exclusiva ( '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 do sistema for interrompida e o manipulador de sinal não gerar uma exceção, a
função agora tentará novamente a chamada do sistema em vez de gerar uma
InterruptedError exceção (consultePEP 475 para a justificativa).
O 'namereplace' manipulador de erros foi adicionado.

https://docs.python.org/3/library/functions.html#type 20/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Alterado na versão 3.6:

Suporte adicionado para aceitar objetos implementando os.PathLike .

No Windows, abrir um buffer de console pode retornar uma subclasse io.RawIOBase diferente de
io.FileIO .

Alterado na versão 3.11: O 'U' modo foi removido.

ordem ( c )
Dada uma string representando um caractere Unicode, retorna um inteiro representando o ponto de có‐
digo Unicode daquele caractere. Por exemplo, ord('a') retorna o inteiro 97 e ord('€') (símbolo do Euro)
retorna 8364 . Este é o inverso de chr() .

pow ( base , exp , mod = Nenhum )

Retorna a base para a potência exp ; se mod estiver presente, retorna a base para a potência exp , módulo
mod (calculado de forma mais eficiente que ). A forma de dois argumentos é equivalente a usar o opera‐
dor de potência: . pow(base, exp) % mod pow(base, exp) base**exp

Os argumentos devem ter tipos numéricos. Com tipos de operandos mistos, as regras de coerção para
operadores aritméticos binários se aplicam. Para int operandos, o resultado tem o mesmo tipo que os
operandos (após a coerção), a menos que o segundo argumento seja negativo; nesse caso, todos os argu‐
mentos são convertidos para float e um resultado float é entregue. Por exemplo, retorna , mas retorna .
Para uma base negativa do tipo or e um expoente não integral, um resultado complexo é entregue. Por
exemplo, retorna um valor próximo a . Enquanto que, para uma base negativa do tipo or com um expo‐
ente integral, um resultado float é entregue. Por exemplo, retorna . pow(10, 2) 100 pow(10,
-2) 0.01 int float pow(-9, 0.5) 3j int float pow(-9, 2.0) 81.0

Para int operandos 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 a mod
. Nesse caso, é retornado, onde inv_base é um inverso de base módulo mod . pow(inv_base, -exp, mod)

Aqui está um exemplo de cálculo de uma inversa para 38 módulo 97 :

>>> pow(38, -1, mod=97) >>>

23
>>> 23 * 38 % 97 == 1
True

Alterado na versão 3.8: Para int operandos, a forma de três argumentos de pow agora permite que o
segundo argumento seja negativo, permitindo o cálculo de inversos modulares.

Alterado na versão 3.8: Permitir argumentos de palavra-chave. Anteriormente, apenas argumentos

posicionais eram suportados.

print ( * objetos , sep = ' ' , fim = '\n' , arquivo = Nenhum , flush = Falso )
Imprima objetos no arquivo de fluxo de texto , separados por sep e seguidos por end . Sep , end , file e
flush , se presentes, devem ser fornecidos como argumentos de palavra-chave.

Todos os argumentos que não sejam palavras-chave são convertidos em strings como str() does e escri‐
tos no fluxo, separados por sep e seguidos por end . Tanto sep quanto end devem ser strings; eles também

https://docs.python.org/3/library/functions.html#type 21/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

podem ser None , o que significa usar os valores padrão. Se nenhum objeto for fornecido, print() apenas
escreverá end .

O argumento file write(string) deve ser um objeto com um método; se não estiver presente ou None ,
sys.stdout será usado. Como argumentos impressos são convertidos em strings de texto, print() não
pode ser usado com objetos file de modo binário. Para estes, use file.write(...) em vez disso.

O buffer de saída é geralmente determinado por file . No entanto, se flush for true, o fluxo será forçado a
ser liberado.

Alterado na versão 3.3: Adicionado o argumento de palavra-chave flush .

propriedade de classe ( fget = None , fset = None , fdel = None , doc = None )
Retorna um atributo de propriedade.

fget é uma função para obter um valor de atributo. fset é uma função para definir um valor de atributo.
fdel é uma função para excluir um valor de atributo. E doc cria uma docstring para o atributo.

Um uso típico é definir um atributo gerenciado x :

class C:
def __init__(self):
self._x = None

def getx(self):
return self._x

def setx(self, value):

self._x = value

def delx(self):
del self._x

x = property(getx, setx, delx, "I'm the 'x' property.")

Se c for uma instância de C , c.x invocará o getter, invocará o setter e o deleter. c.x = value del c.x

Se fornecido, doc será a docstring do atributo property. Caso contrário, a propriedade copiará a docstring
de fget (se existir). Isso torna possível criar propriedades somente leitura facilmente usando
property() como um decorador :

class Parrot:
def __init__(self):
self._voltage = 100000

@property
def voltage(self):
"""Get the current voltage."""
return self._voltage

O @property decorador transforma o voltage() método em um “getter” para um atributo somente lei‐
tura com o mesmo nome e define a docstring para voltagem como “Obter a voltagem atual”.

@ getter

@ setter

https://docs.python.org/3/library/functions.html#type 22/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

@deletador ​
Um objeto de propriedade tem métodos getter , setter , e deleter utilizáveis ​como decoradores
que criam uma cópia da propriedade com a função acessadora correspondente definida para a fun‐
ção decorada. Isso é melhor explicado com um exemplo:

class C:
def __init__(self):
self._x = None

@property
def x(self):
"""I'm the 'x' property."""
return self._x

@x.setter
def x(self, value):
self._x = value

@x.deleter
def x(self):
del self._x

Este código é exatamente equivalente ao primeiro exemplo. Certifique-se de dar às funções adicio‐
nais o mesmo nome da propriedade original ( x neste caso).

O objeto de propriedade retornado também tem os atributos fget , fset e fdel correspondentes aos
argumentos do construtor.

Alterado na versão 3.5: As docstrings de objetos de propriedade agora são graváveis.

intervalo de classe ( parar )

intervalo de classe ( início , parada , passo = 1 )
Em vez de ser uma função, range na verdade é um tipo de sequência imutável, conforme documentado
em Intervalos e tipos de sequência — lista, tupla, intervalo .

repr ( objeto )
Retorna uma string contendo uma representação imprimível de um objeto. Para muitos tipos, esta função
tenta retornar uma string que produziria um objeto com o mesmo valor quando passada para eval() ;
caso contrário, a representação é uma string entre colchetes angulares que contém o nome do tipo do
objeto junto com informações adicionais, geralmente incluindo o nome e o endereço do objeto. Uma
classe pode controlar o que esta função retorna para suas instâncias definindo um __repr__() método.
Se sys.displayhook() não estiver acessível, esta função levantará RuntimeError .

Esta classe tem uma representação personalizada que pode ser avaliada:

class Person:
def __init__(self, name, age):
self.name = name
self.age = age

def __repr__(self):
return f"Person('{self.name}', {self.age})"

revertido ( seq )

https://docs.python.org/3/library/functions.html#type 23/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Retorna um iterador reverso . seq deve ser um objeto que tenha um __reversed__() método ou suporte
o protocolo de sequência (o __len__() método e o __getitem__() método com argumentos inteiros co‐
meçando em 0 ).

round ( número , ndigitos = Nenhum )

Retorna número arredondado para precisão de ndigits após o ponto decimal. Se ndigits for omitido ou for
None , ele retorna o inteiro mais próximo de sua entrada.

Para os tipos internos que suportam round() , os valores são arredondados para o múltiplo mais próximo
de 10 à potência menos ndigits ; se dois múltiplos forem igualmente próximos, o arredondamento é feito
para a escolha par (então, por exemplo, ambos round(0.5) e round(-0.5) são 0 , e round(1.5) é 2 ).
Qualquer valor inteiro é válido para ndigits (positivo, zero ou negativo). O valor de retorno é um inteiro se
ndigits for omitido ou None . Caso contrário, o valor de retorno tem o mesmo tipo que number .

Para um objeto Python geral number , round delegados para number.__round__ .

Observação: O comportamento de round() for floats pode ser surpreendente: por exemplo, dá em
vez do esperado . Isso não é um bug: é um resultado do fato de que a maioria das frações decimais não
podem ser representadas exatamente como um float. Veja Aritmética de Ponto Flutuante: Problemas e
Limitações para mais informações. round(2.675, 2) 2.67 2.68

conjunto de classes
conjunto de classes ( iterável )
Retorna um novo set objeto, opcionalmente com elementos retirados de iterable . set é uma classe in‐
terna. Veja set e Set Types — set, frozenset para documentação sobre esta classe.

Para outros contêineres, consulte as classes integradas frozenset , list , tuple e dict , bem como o
collections módulo.

setattr ( objeto , nome , valor )

Esta é a contraparte 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 o permita. Por exemplo, é equivalente a . setattr(x, 'foobar', 123) x.foobar =
123

name não precisa ser um identificador Python conforme definido em Identificadores e palavras-chave, a
menos que o objeto escolha impor isso, por exemplo em um personalizado __getattribute__() ou via
__slots__ . Um atributo cujo nome não é um identificador não será acessível usando a notação de ponto,
mas é acessível por meio de getattr() etc..

Observação: Como a alteração de nome privado ocorre no momento da compilação, é necessário al‐
terar manualmente o nome de um atributo privado (atributos com dois sublinhados iniciais) para de‐
fini-lo com setattr() .

classe slice ( parar )

classe slice ( início , parada , passo = Nenhum )
Retorna um objeto slice representando o conjunto de índices especificados por . Os argumentos start e
step são padrão para . range(start, stop, step) None

https://docs.python.org/3/library/functions.html#type 24/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

começar

parar

etapa
Objetos slice têm atributos de dados somente leitura start , stop , e step que apenas retornam os
valores dos argumentos (ou seus padrões). Eles não têm nenhuma outra funcionalidade explícita; no
entanto, são usados ​pelo NumPy e outros pacotes de terceiros.

Objetos de fatia também são gerados quando a sintaxe de indexação estendida é usada. Por exemplo:
a[start:stop:step] or . Veja para uma versão alternativa que retorna um iterador . a[start:stop,
i] itertools.islice()

Alterado na versão 3.12: Objetos de fatia agora são hasháveis ​(desde que start , stop e step sejam
hasháveis).

ordenado ( iterável , / , * , chave = Nenhum , reverso = Falso )

Retorna uma nova lista ordenada a partir dos itens em iterável .

Tem dois argumentos opcionais que devem ser especificados como argumentos de palavra-chave.

key especifica uma função de um argumento que é usada para extrair uma chave de comparação de cada
elemento em iterável (por exemplo, key=str.lower ). O valor padrão é None (comparar os elementos
diretamente).

reverse é um valor booleano. Se definido como True , os elementos da lista são classificados como se cada
comparação fosse invertida.

Use para converter uma função cmp functools.cmp_to_key() antiga em uma função key .

A função interna sorted() é garantidamente estável. Uma classificação é estável se ela garante não alterar
a ordem relativa dos elementos que são comparados como iguais — isso é útil para classificar em várias
passagens (por exemplo, classificar por departamento e, em seguida, por nível salarial).

O algoritmo de classificação usa apenas < comparações entre itens. Embora definir um __lt__() método
seja suficiente para a classificação, O PEP 8 recomenda que todas as seis comparações ricas sejam imple‐
mentadas. Isso ajudará a evitar bugs ao usar os mesmos dados com outras ferramentas de ordenação,
comométodo max() refletido __gt__()

Para exemplos de classificação e um breve tutorial de classificação, consulte Técnicas de classificação .

@ método estático
Transforme um método em um 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): ...

O @staticmethod formulário é um decorador de função – veja Definições de função para detalhes.

https://docs.python.org/3/library/functions.html#type 25/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Um método estático pode ser chamado na classe (como C.f() ) ou em uma instância (como ). Além disso,
o descritor C().f() de método estático também é invocável, então ele pode ser usado na definição de
classe (como ). f()

Métodos estáticos em Python são similares aos encontrados em Java ou C++. Veja também
classmethod() para uma variante que é útil para criar 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 a uma
função de um corpo de classe e quer evitar a transformação automática para método de instância. Para
esses casos, use este idioma:

def regular_function():
...

class C:
method = staticmethod(regular_function)

Para obter 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 ( , , e __module__ )
__name__ , __qualname__ têm um novo atributo e agora podem ser chamados como funções
regulares. __doc__ __annotations__ __wrapped__

classe str ( objeto = '' )

classe str ( objeto = b'' , codificação = 'utf-8' , erros = 'estrito' )
Retorna uma str versão do objeto . Veja str() para detalhes.

str é a classe string interna . Para informações gerais sobre strings, veja Tipo de Sequência de Texto — str
.

soma ( iterável , / , início = 0 )

As somas iniciam e os itens de um iterável da esquerda para a direita e retornam o total. Os itens do iterá‐
vel normalmente são números, e o valor inicial não pode ser uma string.

Para alguns casos de uso, há 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, consulte math.fsum() . Para concatenar uma série de iteráveis, considere usar
itertools.chain() .

Alterado na versão 3.8: O parâmetro start pode ser especificado como um argumento de palavra-
chave.

Alterado na versão 3.12: A soma de floats foi alterada para um algoritmo que oferece maior precisão
na maioria das compilações.

classe super
classe super ( tipo , objeto_ou_tipo = Nenhum )
Retorna um objeto proxy que delega chamadas de método para uma classe pai ou irmã do tipo . Isso é
útil para acessar métodos herdados que foram substituídos em uma classe.

https://docs.python.org/3/library/functions.html#type 26/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

O object_or_type determina a ordem de resolução do método a ser pesquisado. A pesquisa começa na

classe logo após o type .

Por exemplo, se object_or_type __mro__ for e o valor de type for , então pesquisa . D -> B -> C -> A ->
object B super() C -> A -> object

O __mro__ atributo do object_or_type lista a ordem de busca de resolução de método usada por ambos
getattr() e super() . O atributo é dinâmico e pode mudar sempre que a hierarquia de herança for
atualizada.

Se o segundo argumento for omitido, o super objeto retornado é unbound. Se o segundo argumento for
um objeto, deve ser true. Se o segundo argumento for um tipo, deve ser true (isso é útil para métodos de
classe). isinstance(obj, type) issubclass(type2, type)

Há 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 pai sem nomeá-las explicitamente, tornando o código mais sustentável.
Esse uso é muito semelhante ao uso de super em outras linguagens de programação.

O segundo caso de uso é dar 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 linguagens compiladas estatica‐
mente ou linguagens que dão suporte apenas à herança única. Isso torna possível implementar “diagra‐
mas de diamante” onde várias classes base implementam o mesmo método. Um bom design determina
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 a mudanças na hie‐
rarquia de classes e porque essa ordem pode incluir classes irmãs que são desconhecidas antes do tempo
de execução).

Para ambos os casos de uso, uma chamada típica de superclasse se parece com isto:

class C(B):
def method(self, arg):
super().method(arg) # This does the same thing as:
# super(C, self).method(arg)

Além de pesquisas de métodos, super() também funciona para pesquisas de atributos. Um possível caso
de uso para isso é chamar descritores em uma classe pai ou irmã.

Note que super() é implementado como parte do processo de vinculação para pesquisas explícitas de
atributos pontilhados, como super().__getitem__(name) . Ele faz isso implementando seu próprio
__getattribute__() método para pesquisar classes em uma ordem previsível que suporta herança múlti‐
pla cooperativa. Consequentemente, super() é indefinido para pesquisas implícitas usando instruções ou
operadores, como super()[name] .

Observe também que, além da forma de argumento zero, super() não se limita ao uso dentro de méto‐
dos. A forma de dois argumentos especifica os argumentos exatamente e faz as referências apropriadas. A
forma de argumento zero só funciona dentro de uma definição de classe, pois o compilador preenche os
detalhes necessários para recuperar corretamente a classe que está sendo definida, bem como 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
usar super() .

https://docs.python.org/3/library/functions.html#type 27/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

tupla de classe
classe tupla ( iterável )
Em vez de ser uma função, tuple na verdade é um tipo de sequência imutável, conforme documentado
em Tuplas e tipos de sequência — lista, tupla, intervalo .

tipo de classe ( objeto )

tipo de classe ( nome , bases , dict , ** kwds )
Com um argumento, retorna o tipo de um objeto . O valor de retorno é um objeto de tipo e geralmente o
mesmo objeto retornado por object.__class__ .

A isinstance() função interna é recomendada para testar o tipo de um objeto, porque leva em conside‐
ração subclasses.

Com três argumentos, retorna um novo objeto de tipo. Esta é essencialmente uma forma dinâmica da
class declaração. A string name é o nome da classe e se torna o __name__ atributo. A tupla bases contém
as classes base e se torna o __bases__ atributo; se estiver vazia, 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 encapsulado antes de se tornar o __dict__ atributo. As duas declarações a seguir criam
type objetos idênticos:

>>> class X: >>>

... a = 1
...
>>> X = type('X', (), dict(a=1))

Veja também Objetos de Tipo .

Os argumentos de palavras-chave fornecidos ao formulário de três argumentos são passados ​para o ma‐
quinário de metaclasse apropriado (geralmente __init_subclass__() ) da mesma forma que as palavras-
chave em uma definição de classe (além da metaclasse ) fariam.

Veja também Personalizando a criação de classes .

Alterado na versão 3.6: Subclasses type que não substituem type.__new__ não podem mais usar o
formato de um argumento para obter o tipo de um objeto.

vars ( )
vars ( objeto )
Retorna o __dict__ atributo para um módulo, classe, instância ou qualquer outro objeto com um
__dict__ atributo.

Objetos como módulos e instâncias têm um __dict__ atributo atualizável; no entanto, outros objetos po‐
dem ter restrições de gravação em seus __dict__ atributos (por exemplo, classes usam um
types.MappingProxyType para impedir atualizações diretas de dicionário).

Sem um argumento, vars() age como locals() . Observe que o dicionário locals só é útil para leituras,
pois as atualizações do dicionário locals são ignoradas.

Uma TypeError exceção é gerada se um objeto for especificado, mas não tiver um __dict__ atributo (por
exemplo, se sua classe definir o __slots__ atributo).

zip ( * iteráveis ​, strict = False )

https://docs.python.org/3/library/functions.html#type 28/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Itere sobre vários iteráveis ​em paralelo, produzindo tuplas com um item de cada um.

Exemplo:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']): >>>
... print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

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 zip() é que ele transforma linhas em colunas, e colunas em linhas. Isso é similar
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 for loop ou por encapsulamento em um list .

Uma coisa a considerar é que os iteráveis ​passados ​para zip() podem ter tamanhos 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 ignorará os itens restantes nos iterá‐
veis ​mais longos, cortando o resultado para o comprimento do iterável mais curto:

>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'])) >>>

[(0, 'fee'), (1, 'fi'), (2, 'fo')]

zip() é frequentemente usado em casos onde os iteráveis ​são assumidos como tendo o mesmo com‐
primento. Em tais casos, é recomendado usar a strict=True opção. Sua saída é a mesma que a regular
zip() :

>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True)) >>>

[('a', 1), ('b', 2), ('c', 3)]

Diferentemente do comportamento padrão, ele gera um 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 strict=True argumento, qualquer bug que resulte em iteráveis ​de comprimentos diferentes
será silenciado, possivelmente se manifestando como um bug difícil de encontrar em outra parte do
programa.

https://docs.python.org/3/library/functions.html#type 29/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Iteráveis ​mais curtos podem ser preenchidos com um valor constante para fazer com que todos os ite‐
ráveis ​tenham o mesmo comprimento. Isso é feito por itertools.zip_longest() .

Casos extremos: Com um único argumento iterável, zip() retorna um iterador de 1-tuplas. Sem argumen‐
tos, 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 idi‐
oma para agrupar uma série de dados em grupos de comprimento n usando . Isso repete os mesmos
tempos do iterador para que cada tupla de saída tenha o resultado de chamadas ao iterador. Isso tem
o efeito de dividir a entrada em pedaços de comprimento n. zip(*[iter(s)]*n, strict=True) n n

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

__import__ ( nome , globais = Nenhum , locais = Nenhum , fromlist = () , nível = 0 )

Observação: Esta é uma função avançada que não é necessária na programação diária em Python, ao
contrário do importlib.import_module() .

Esta função é invocada pela import declaração. Ela pode ser substituída (importando o builtins módulo
e atribuindo a builtins.__import__ ) para alterar a semântica da import declaração, mas fazer isso é
fortemente desencorajado, pois geralmente é mais simples usar ganchos de importação (vejaPEP 302 )
para atingir os mesmos objetivos e não causa problemas com código que assume que a implementação
de importação padrão está em uso. O uso direto de __import__() também é desencorajado em favor
de importlib.import_module() .

A função importa o nome do módulo , potencialmente usando os globais e locais fornecidos para determi‐
nar como interpretar o nome em um contexto de pacote. O fromlist fornece os nomes de objetos ou sub‐
módulos que devem ser importados do módulo fornecido por name . A implementação padrão não usa
seu argumento locals e usa seus globais apenas para determinar o contexto do pacote da import declara‐
ção.

level especifica se deve usar importações absolutas ou relativas. 0 (o padrão) significa executar apenas im‐
portações absolutas. Valores positivos para level indicam o número de diretórios pais a serem pesquisados
​em relação ao diretório do módulo que está chamando __import__() (consultePEP 328 para mais
detalhes).

Quando a variável name é do formato package.module , 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 ar‐
gumento fromlist não vazio é fornecido, o módulo nomeado por name é retornado.

https://docs.python.org/3/library/functions.html#type 30/31
11/09/2024, 21:21 Funções integradas — documentação do Python 3.12.5

Por exemplo, a declaração resulta em um bytecode semelhante ao seguinte código: import spam

spam = __import__('spam', globals(), locals(), [], 0)

A declaração resulta nesta chamada: import spam.ham

spam = __import__('spam.ham', globals(), locals(), [], 0)

Observe como __import__() retorna o módulo de nível superior aqui porque este é o objeto que está
vinculado a um nome pela import instrução.

Por outro lado, a afirmação resulta em from spam.ham import eggs, sausage as saus

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)

eggs = _temp.eggs
saus = _temp.sausage

Aqui, o spam.ham módulo é retornado de __import__() . Deste objeto, os nomes a serem importados são
recuperados e atribuídos aos seus respectivos nomes.

Se você quiser simplesmente importar um módulo (potencialmente dentro de um pacote) pelo nome, use
importlib.import_module() .

Alterado na versão 3.3: Valores negativos para nível 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 va‐
riável de ambiente PYTHONCASEOK agora é ignorado.

Notas de rodapé

[ 1 ] Note que o parser aceita apenas a convenção de fim de linha no estilo Unix. Se você estiver lendo o có‐
digo de um arquivo, certifique-se de usar o modo de conversão de nova linha para converter novas linhas
no estilo Windows ou Mac.

https://docs.python.org/3/library/functions.html#type 31/31