# 2. Funções Built-in

O interpretador do Python possui várias funções e tipos incorporados que sempre estão disponíveis. A seguir listamos todas as funções em ordem alfabética.

|  | Funções Built-in |  |
--- | --- | --- | --- | ---
`abs()` | `dict()` | `help()` | `min()` | `setattr()`
`all()` | `dir()` | `hex()` | `next()` | `slice()`
`any()` | `divmod()` | `id()` | `object()` | `sorted()`
`ascii()` | `enumerate()` | `input()` | `oct()` | `staticmethod()`
`bin()` | `eval()` | `int()` | `open()` | `str()`
`bool()` | `exec()` | `isinstance()` | `ord()` | `sum()`
`bytearray()` | `filter()` | `issubclass()` | `pow()` | `super()`
`bytes()` | `float()` | `iter()` | `print()` | `tuple()`
`callable()` | `format()` | `len()` | `property()` | `type()`
`chr()` | `frozenset()` | `list()` | `range()` | `vars()`
`classmethod()` | `getattr()` | `locals()` | `repr()` | `zip()`
`compile()` | `globals()` | `map()` | `reversed()` | `__import__()`
`complex()` | `hasattr()` | `max()` | `round()` |
`delattr()` | `hash()` | `memoryview()` | `set()` |

`abs`(x)

  Retorna o valor absoluto de um número. O argumento pode ser um inteiro ou um número de ponto flutuante. Se o argumento é um número complexo, sua magnitude é retornada.

`all`(iterable)

  Retorna `True` se todos os elementos de iterable são verdadeiros (ou se iterable estiver vazio). Equivalente a:

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

`any`(iterable)

  Retorna `True` se qualquer elemento de iterable for verdadeiro. Se iterable estiver vazio, retorna `False`. Equivalente a:

      def any(iterable):
          for element in iterable:
              if element:
                  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 por `repr()` usando sequências de escapes `\x`, `\u` or `\U`. Isto gera uma string similar ao que é retornado por `repr()` 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`([x])

  Retorna um valor Booleano, isto é, `True` ou `False`. x é convertida usando o procedimento de teste verdade. Se x é falso ou foi omitido, isso retorna `False`; senão ele retorna `True`. A classe `bool` é uma subclasse de `int` (see Tipos Numéricos — int, float, complex). Ela não pode ser usada para criar outra subclasse. Suas únicas instâncias são `False` e `True` (see Valores Booleanos).

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 de Sequências Mutáveis, assim como a maior parte dos métodos que o tipo `bytes` 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 usando `str.encode()`.

  - Se é um integer, o array terá esse tamanho e será inicializado com bytes nulos.

  - Se é um objeto em conformidade com a interface buffer, um buffer de objeto somente leitura 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 argumentos, um vetor de tamanho 0 é criado.

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

class `bytes`([source[, encoding[, errors]]])

  Returna um novo objeto “bytes”, que é uma sequência imutável de inteiros no intervalo``0 <= x < 256``. `bytes` é uma versão imutável de `bytearray` – tem os mesmos métodos non-mutating 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 String e Bytes literais.

  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 chamável, `False` se não. Se retornar verdadeiro, é possível que uma chamada falhe, mas se é falso, chamar object nunca será em sucedido. Note que classes são chamáveis (chamar uma classe retorna uma nova instância); instâncias são chamáveis se sua classe tem o método `__call__()`.

  Novo na versão 3.2: Esta função foi removida na versão 3.0, mas retornou no Python 3.2.

`chr`(i)

  Retorna a string que é apontada pelo inteiro i no código Unicode. Por exemplo, `chr(97)` retorna a string `'a'`, enquanto `chr(8364)` retorna a string `'€'`. É o inverso de `ord()`.

  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`

  Transforme um método em um método de classe.

  Um método de classe recebe a classe como primeiro argumento implícito, exatamente como uma 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, ...): ...

  The `@classmethod` form is a function decorator – see the description of function definitions in Definições de função for details.

  It 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 object 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, consult the documentation on the standard type hierarchy in A hierarquia de tipos padrão.

`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()` ou `eval()`. source pode ser uma string normal, uma string byte, ou um objeto AST. Consulte a documentação do módulo `ast` 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 de 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 de `None` serão exibidas).

  Os argumentos opcionais flags e dont_inherit controlam qual instrução futura afeta a compilação de source. Se nenhum está presente (ou ambos são zero) o código é compilado com as instruções futuras que estão agindo no código que está chamando `compile()`. If the flags argument is given and dont_inherit is not (or is zero) then 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 future statements in effect around the call to compile are ignored.

  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 pode ser encontrada no atributo `compiler_flag` na instância `_Feature` do módulo `__future__` module.

  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ão `0` (nenhuma otimização; `__debug__` é verdadeiro), `1` (instruções `asserts` são removidas, `__debug__` é falso) ou `2` (strings de documentação também são removidas).

  Essa função levanta `SyntaxError` se o código para compilar é inválido, e `ValueError` se o código contém bytes nulos.

  Se você quer analisar código Python em sua representação AST, veja `ast.parse()`.

  Nota

  Quando compilindo 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ódulo `code`.

  Aviso

  É possível quebrar o interpretador Python com uma string suficiente grande/complexa quando compilando para uma objeto AST, devido limitações do tamanho da pilha no compilador AST do Python.

  Alterado na versão 3.2: Permitido 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.

class `complex`([real[, imag]])

  Retorna um número completo com o valor real + imag*1j ou converte uma string ou número para um número complexo. Se o primeiro parâmetro é uma string, ele será interpretado como um número complexo e a função deve ser chamada sem um segundo parâmetro. O segundo parâmetro nunca deve ser uma string. Cada argumento pode ser qualquer tipo numérico (incluindo complexo). Se imag é omitido, seu valor padrão é zero e a construção funciona como uma conversão numérica, similar a `int` e `float`. Se os dois argumentos são omitidos, retorna `0j`.

  Nota

  Quando convertendo a partir de uma string, a string não pode conter espaços em branco em torno `+` central ou do operador `-`. Por exemplo, `complex('1+2j')` funciona, mas `complex('1 + 2j')` levanta `ValueError`.

  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.

`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 a `del x.foobar`.

class `dict`(**kwarg)
class `dict`(mapping, **kwarg)
class `dict`(iterable, **kwarg)

  Cria um novo dicionário. O objeto `dict` é a classe do dicionário. Veja `dict` e Tipo de Mapeamento — dict para documentação sobre esta classe.

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

`dir`([object])

  Sem argumentos, retorne a lista de nomes no escopo local atual. Com um argumento, tente retornar 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 retornar a lista de atributos. Isso permite que objetos que implementam uma função personalizada `__getattr__()` ou `__getattribute__()` personalizem a maneira `dir()` 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)

  Toma dois números (não complexos) como argumentos e retorne um par de números que consiste em seu quociente e restante 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, se `a % b` é diferente de zero, tem o mesmo sinal que b e `0 <= abs(a % b) < abs(b)`.

`enumerate`(iterable, start=0)

  Retorne 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 por `enumerate()` retorna uma tupla contendo uma contagem (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(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

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

  Os argumentos são uma sequência de caracteres e globais e locais opcionais. Se fornecido, globals deve ser um dicionário. Se fornecido,locals* pode ser qualquer objeto de mapeamento.

  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 present and 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 before expression is parsed. This means that expression normally has full access to the standard `builtins` module and restricted environments are propagated. If the locals dictionary is omitted it defaults to the globals dictionary. If both dictionaries are omitted, the expression is executed in the environment where `eval()` is called. The return value is the result of the evaluated expression. Syntax errors are reported as exceptions. Example:

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

  Esta função também pode ser usada para executar objetos de código arbitrários (como os criados por `compile()`). Nesse caso, passe um objeto de código em vez de uma string. Se o objeto de código foi compilado com `'exec'` como o argumento mode, o valor de retorno de `eval()` será` None`.

  Dicas: a execução dinâmica de instruções é suportada pela função `exec()`. As funções `globals()` e `locals()` retornam o dicionário global e local atual, respectivamente, o que pode ser útil para ser usado por `eval()` ou `exec()`.

  Veja `ast.literal_eval()` para uma função que pode avaliar com segurança strings com expressões contendo apenas literais.

`exec`(object[, globals[, locals]])

  Esta função suporta execução dinâmica de código Python. O parâmetro object deve ser ou uma string ou um objeto contendo 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 com 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 “Arquivo de Entrada” no Manual de Referência). Tenha cuidado que as expressões `return` e `yield` não podem ser usadas fora das definições de funções mesmo dentro do contexto do código passado para a função `exec()` . O valor de retorno é sempre `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, 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 module level, globals and locals are the same dictionary. If exec gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class definition.

  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 embutido `builtins` é 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 para `exec()`.

  Nota

  As funções embutidas `globals()` e `locals()` retornam o dicionário global e local, respectivamente, o que pode ser útil para passar adiante e usar como segundo ou terceiro argumento para `exec()`.

  Nota

  locals padrão atua como descrito pela função `locals()` abaixo: modificações para o dicionário locals padrão não deveriam ser feitas. Se você precisa ver efeitos do código em locals depois da função `exec()` retornar passe um dicionário locals explícito.

`filter`(function, iterable)

  Constrói um iterador a partir dos elementos de iterable para os quais function retorna true. iterable pode ser uma sequência (um container que suporta iteração) ou um iterador. Se function tiver o valor `None`, a função identidade é será usada, isto é, todos os elementos de iterable que retornam false 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 tiver o valor `None` e `(item for item in iterable if item)` se function tiver o valor `None`.

  Veja `itertools.filterfalse()` para a função complementar que retorna elementos de iterable para a qual function retorna false.

class `float`([x])

  Retorna um número de ponto flutuante construído a partir de um número ou string * x *.

  Se o argumento é uma string, ele deve conter um número decimal, opcionalmente precedido por um sinal, e opcionalmente possuir espaço em branco. O sinal opcional pode ser `'+'` ou `'-'`; um sinal de `'+'` não tem efeito no valor produzido. O argumento também pode ser uma string representando um NaN (indica que não é numero), ou inifinito positivo/negativo. Mais precisamente, a entrada deve estar em conformidade com a seguinte gramática depois que caracteres em branco são removidos do início e do final da mesma:

      sign           ::=  "+" | "-"
      infinity       ::=  "Infinity" | "inf"
      nan            ::=  "nan"
      numeric_value  ::=  floatnumber | infinity | nan
      numeric_string ::=  [sign] numeric_value

  Aqui `floatnumber` é a forma literal de um ponto flutuante Python, descrito em Literais de Ponto Flutuante. Caso isso não seja significante, então, por exemplo, “inf”, “Inf”, “INFINITY” e “iNfINity” são todas formas escritas válidas para 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) é devolvido. Se o argumento está fora do intervalo de um ponto flutuante Python, uma exceção `OverflowError` será lançada.

  For a general Python object `x`, `float(x)` delegates to `x.__float__()`.

  Se nenhum argumento for fornecido, `0.0` será retornado.

  Exemplos:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

  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.

`format`(value[, format_spec])

  Converte um valor value em uma representação “formatada”, como 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: formspecpec.

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

  Uma chamada de `format (value, format_spec)` é convertida em `type(value).__format__(value, format_spec)`, que ignora o dicionário da instância ao pesquisar o método `__format__()` do valor. A exceção `TypeError` é levantada se a pesquisa do método atingir `object` 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 um `TypeError` se format_spec não for uma string vazia.

class `frozenset`([iterable])

  Devolve um novo objeto `frozenset`, opcionalmente com elementos obtidos de iterable. `frozenset` é uma classe embutida. Veja `frozenset` e Tipo Set — set, frozenset para documentação sobre essas classes.

  Para outros containers veja as classes embutidas `set`, `list`, `tuple`, e `dict`, bem como o módulo `collections`.

`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 exempleo, `getattr(x, 'foobar')` é equivalente a `x.foobar`. Se o atributo não existir, default é devolvido se tiver sido fornecido, caso contrário é levantada a exceção `AttributeError`.

`globals`()

  Devolve um dicionário representando a tabela de símbolos global atual. É sempre o dicionário do módulo atual (dentro de uma função ou método, é o módulo onde está definido, não o módulo do qual é chamado).

`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, e `False` se ela não for. (Isto é implementado chamando `getattr(object, name)` e vendo se levanta um `AttributeError` ou não.)

`hash`(object)

  Retorna o valor hash de um objeto (se houver um). Valores hash values 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__()` customizados, fique atento que `hash()` trunca o valor retornado baseado no comprimento de bits da máquina hospedeira. Veja `__hash__()` para mais detalhes.

`help`([object])

  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, metódo, 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.

  Esta função é adicionada ao espaço de nomes embutido pelo módulo `site`.

  Alterado na versão 3.4: Mudanças em `pydoc` e `inspect` significam que as assinaturas reportadas para chamáveis agora são mais compreensíveis e consistentes.

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

  Retorna 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()`.

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

`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 caracter de nova linha ao final), e retorna 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ão `input()` usará ele para prover edição de linhas elaboradas e funcionalidades de histórico.

class `int`(x=0)
class `int`(x, base=10)

  Return an integer object constructed from a number or string x, or return `0` if no arguments are given. If x defines `__int__()`, `int(x)` returns `x.__int__()`. If x defines `__trunc__()`, it returns `x.__trunc__()`. For floating point numbers, this truncates towards zero.

  Se x não é um número ou se base é fornecida, então x deve ser uma string, instância de `bytes` ou `bytearray` representando um inteiro literal em base base. Opcionalmente, o literal pode ser precedido por `+` ou `-` (sem espaço entre eles) e cercado por espaços em branco. Um literal base-n consiste de dígitos de 0 até n-1, com `a` até `z` (ou `A` até `Z`) com valores de 10 até 35. A base padrão é 10. Os valores permitidos são 0 e 2–36. Literais em base-2, -8, e -16 podem ser opcionalmente prefixado com `0b`/`0B`, `0o`/`0O`, ou `0x`/`0X`, assim como literais inteiros. Base 0 significa que será interpretado exatamente como um literal, ou seja, as bases são, na verdade, 2, 8, 10, ou 16, e que `int('010', 0)` não é legal, enquanto `int('010')` é, assim como `int('010', 8)`.

  O tipo inteiro é 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étodo `base.__index__`, então esse método é chamado para obter um inteiro para a base. Versões anteriores usavam `base.__int__` ao invés de `base.__index__`.

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

`isinstance`(object, classinfo)

  Return true if the object argument is an instance of the classinfo argument, or of a (direct, indirect or virtual) subclass thereof. If object is not an object of the given type, the function always returns false. If classinfo is a tuple of type objects (or recursively, other such tuples), return 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.

`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, in which case every entry in classinfo will be checked. In any other case, a `TypeError` exception is raised.

`iter`(object[, sentinel])

  Retorna um objeto iterator. O primeiro argumento é interpretado muito diferentemente dependedo da presença do segundo argumento. Sem um segundo argumento, object deve ser uma coleção de objetos que suportem o protocolo de iteração (o método `__iter__()`), ou ele deve suportar o protocolo de sequência (o método `__getitem__()` com argumentos inteiros começando em `0`). Se ele não suportar nenhum desses protocolos, um `TypeError` é levantado. Se o segundo argumento, sentinel, é fornecido, então object deve ser um objeto que pode ser chamado. O iterador criado neste caso irá chamar object sem nenhum argumento para cada chamada para o seu métod `__next__()`; se o valor retornado é igual a sentinel, então `StopIteration` será levantado, caso contrário o valor será retornado.

  Veja também Tipos de Iteradores.

  One useful application of the second form of `iter()` is to read lines of a file until a certain line is reached. The following example reads a file until the `readline()` method returns an empty string:

      with open('mydata.txt') as fp:
          for line in iter(fp.readline, ''):
              process_line(line)

`len`(s)

  Retorna 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 range) ou uma coleção (tal como um dicionário, conjunto, ou conjunto imutável).

class `list`([iterable])

  Ao invés de ser uma função, `list` é na verdade uma tipo de sequência mutável, conforme documentado em Listas e Tipos de Sequências — 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.

  Nota

  O conteúdo deste dicionário não deve ser modificado; As alterações podem não afetar os valores das variáveis ​​locais e livres usadas pelo intérprete.

`map`(function, iterable, ...)

  Retorna um iterador que aplica function para cada item de iterable, devolvendo os resultados. Se argumentos iterable 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, default])
`max`(arg1, arg2, *args[, key])

  Retorna o maior item em um iterável ou o maior de dois ou mais argumentos.

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

  Existem dois parâmetros palavra-chave 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 retornado se o iterável fornecido estiver vazio. Se o iterável estiver vazion, e default não foi fornecido, um `ValueError` é levantado.

  Se múltiplos itens são máximos, a função retorna o primeiro encontrado. Isto é consistente com outras ferramentas de ordenamento que preservam a estabilidade, tais como `sorted(iterable, key=keyfunc, reverse=True)[0]` e `heapq.nlargest(1, iterable, key=keyfunc)`.

  Novo na versão 3.4: O parâmetro palavra-chave default.

`memoryview`(obj)

  Retorna um objeto de “visão da memória” criado a partir do argumento fornecido. Veja Memory Views para mais informações.

`min`(iterable, *[, key, default])
`min`(arg1, arg2, *args[, key])

  Retorna o menor item de um iterável ou o menor de dois ou mais argumentos.

  Se um argumento posicional é fornecido, ele deve ser um iterable. O menor item no iterável é retornado. Se dois ou mais argumentos posicionais são fornecidos, o menor dos argumentos posicionais é retornado.

  Existem dois parâmetros palavra-chave 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 retornado se o iterável fornecido estiver vazio. Se o iterável estiver vazion, e default não foi fornecido, um `ValueError` é levantado.

  Se múltiplos itens são mínimos, a função retorna o primeiro encontrado. Isto é consistente com outras ferramentas de ordenamento que preservam a estabilidade, tais como `sorted(iterable, key=keyfunc)[0]` e `heapq.nsmallest(1, iterable, key=keyfunc)`.

  Novo na versão 3.4: O parâmetro palavra-chave default.

`next`(iterator[, default])

  Recupera o próximo item do iterator chamando o seu método `__next__()`. Se default foi fornecido, ele é retornado caso o iterável tenha sido percorrido por completo, caso contrário `StopIteration` é levantada.

class `object`

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

  Nota

  `object` não tem um atributo `__dict__`, então você não consegue designar atributos arbitrários para uma instância da classe `object`.

`oct`(x)

  Converte um número inteiro para uma string em base octal, pre-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 retorne 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 file object correspondente. Se o arquivo não puder ser aberto, um an `OSError` é levantado.

  file é um path-like object 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 é independente de plataforma: `locale.getpreferredencoding(False)` é 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:

  Character | 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'` | binary mode
  `'t'` | modo texto (padrão)
  `'+'` | abre um arquivo no disco para atualização (leitura e escrita)
  `'U'` | universal newlines mode (desuso)

  The default mode is `'r'` (open for reading text, synonym of `'rt'`). For binary read-write access, the mode `'w+b'` opens and truncates the file to 0 bytes. `'r+b'` opens the file without truncation.

  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 objetos `bytes` 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 como `str`, 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 inteiro opcional usado para definir a política de buffering. Passe o valor 0 para desativar o buffering (permitido somente em modo binário), passe 1 para selectionar buffering de linha (permitido somente em modo texto), e um inteiro > 1 para indicar o tamanho em bytes de um buffer com tamanho fixo. Quando nenhum valor é fornecido no argumento buffering, a política de buffering padrão funciona conforme as seguintes regras:

  - 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” subjancente 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()` retornam `True`) 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.getpreferredencoding()` retornar), mas qualquer text encoding suportada pelo Python pode ser usada. Veja o módulo `codecs` 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ção `ValueError` se existir um erro de codificação. O valor padrão `None` 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 marformados.

  - `'surrogateescape'` representará quaisquer bytes incorretos, conforme códigos apontados na área privada de uso da tabela Unicode, indo desde U+DC80 até U+DCFF. Esses códigos privados serão então convertidos de volta para os mesmos bytes quando o tratamento de erro para `surrogateescape` é usado ao escrever dados. Isto é útil para processar arquivos com 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 controla como o modo de novas linhas universais funciona (se aplica apenas ao modo texto). 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 sequência 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 sequência 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 ser `True` (o padrão), caso contrário, um erro será levantado.

  Um abridor personalizado pode ser usado passando uma chamada como opener. O descritor de arquivo subjacente para o objeto de 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 de `None`).

  O recém criado arquivo é ref:non-inheritable 1.

  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('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 arquivo retornado pela função `open()` depende do modo. Quando `open()` é usado para abrir um arquivo no modo texto (`'w'`, `'r'`, `'wt'`, `'rt'`, etc.), retorna uma subclasse de `io.TextIOBase` (especificamente `io.TextIOWrapper`). Quando usada para abrir um arquivo em modo binário com buffer, a classe retornada é uma subclasse de `io.BufferedIOBase`. A classe exata varia: no modo binário de leitura, ele retorna uma `io.BufferedReader`; nos modos binário de gravação e binário anexado, ele retorna um `io.BufferedWriter` e, no modo leitura/gravação, retorna um `io.BufferedRandom`. Quando o buffer está desativado, o fluxo bruto, uma subclasse de `io.RawIOBase`, `io.FileIO`, é retornado.

  Veja também os módulos de para lidar com arquivos, tais como, `fileinput`, `io` (onde `open()` é declarado), `os`, `os.path`, `tempfile`, e `shutil`.

  > 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 para `OSError`.

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

  Deprecated since version 3.4, will be removed in version 4.0: O modo `'U'`.

  > 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 lógica).

  > - O manipulador de erro `'namereplace'` foi adicionar.

  > 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 seja `io.FileIO`.

`ord`(c)

  Dada uma sequência 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 inteiro `97` e `ord('€') `` (sinal do Euro) retorna ``8364`. Este é o inverso de `chr()`.

`pow`(x, y[, z])

  Return x to the power y; if z is present, return x to the power y, modulo z (computed more efficiently than `pow(x, y) % z`). The two-argument form `pow(x, y)` is equivalent to using the power operator: `x**y`.

  The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For `int` operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, `10**2` returns `100`, but `10**-2` returns `0.01`. If the second argument is negative, the third argument must be omitted. If z is present, x and y must be of integer types, and y must be non-negative.

`print`(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

  Imprime 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 ser `None`, 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 ou `None`, então `sys.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, use `file.write(...)` ao invés.

  Se a saída é armazenada em um buffer é usualmente determinado por file, mas se o argumento nomeado flush é verdadeiro, o fluxo de saída é forçosamente descarregado.

  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, value):
              self._x = value

          def delx(self):
              del self._x

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

  Se c é uma instância de C, `c.x` irá invocar o método getter, `c.x = value` irá invocar o método setter, e `del c.x` o médodo deleter.

  Se fornecido, doc será a docstring do atributo property attribute. Otherwise, the property will copy fget’s docstring (if it exists). This makes it possible to create read-only properties easily using `property()` as a decorator:

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

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

  O decorador `@property` transforma o método `voltage()` em um “getter” para um atributo somente leitura com o mesmo nome, e define a docstring de voltage para “Get the current voltage.”

  Um objeto property possui métodos `getter`, `setter`, e `deleter` 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):
              """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

  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`, e `fdel` correspondendo aos argumentos do construtor.

  Alterado na versão 3.5: Agora é possível escrever nas docstrings de objetos property.

`range`(stop)
`range`(start, stop[, step])

  Em vez de ser uma função, `range` é realmente um tipo de sequência imutável, conforme documentado em Ranges e Tipos de 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__()`.

`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 `__len__()` e o método `__getitem__()` com argumentos inteiros começando em `0`).

`round`(number[, ndigits])

  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)` 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 número 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` delega para `number.__round__`.

  Nota

  O comportamento de `round()` para pontos flutuantes pode ser surpreendente: por exemplo, `round(2.675, 2)` fornece `2.67` em vez do esperado `2.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`([iterable])

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

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

`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 a `x.foobar = 123`.

class `slice`(stop)
class `slice`(start, stop[, step])

  Retorna um objeto slice representando o conjunto de índices especificado por `range(start, stop, step)`. Os argumentos start e step são padronizados como `None`. Os objetos de têm atributos de dados somente leitura `start`, `stop` e `step`, que meramente retornam os valores do argumento (ou o padrão). Eles não têm outra funcionalidade explícita; no entanto, eles são usados pelo Python numérico e outras extensões de terceiros. Os objetos slice também são gerados quando a sintaxe de indexação estendida é usada. Por exemplo: `a[start:stop:step]` ou `a[start:stop, i]`. Veja `itertools.islice()` para uma versão alternativa que retorna um iterador.

`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 fosse reversa.

  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 ordem é 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).

  Para selecionar exemplos e um breve tutorial de classificação, veja: ref: sortinghowto.

`@``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, ...): ...

  The `@staticmethod` form is a function decorator – see the description of function definitions in Definições de função for details.

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

  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:

      class C:
          builtin_open = staticmethod(open)

  For more information on static methods, consult the documentation on the standard type hierarchy in A hierarquia de tipos padrão.

class `str`(object='')
class `str`(object=b'', encoding='utf-8', errors='strict')

  Retorna uma versão `str` de object. Consulte `str()` para detalhes.

  `str` é uma string embutida class. Para informações gerais sobre strins, consulte Tipo de Sequência de Texto — str.

`sum`(iterable[, start])

  Sums start and the items of an iterable from left to right and returns the total. start defaults to `0`. The iterable’s items are normally numbers, and the start value is not allowed to be a 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, consulte `math.fsum()`. Para concatenar uma série de iteráveis, considere usar `itertools.chain()`.

`super`([type[, object-or-type]])

  Return a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing inherited methods that have been overridden in a class. The search order is same as that used by `getattr()` except that the type itself is skipped.

  The `__mro__` attribute of the type lists the method resolution search order used by both `getattr()` and `super()`. The attribute is dynamic and can change whenever the inheritance hierarchy is updated.

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

  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-pai 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 determina que esse método tenha 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 method(self, arg):
              super().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

  Observe que `super()` é implementada como parte do processo de vinculação para procura explícita de atributos com ponto, tal como `super().__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 como `super()[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().

`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 de Sequências — list, tuple, range.

class `type`(object)
class `type`(name, bases, dict)

  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 transforma em itens as classes bases e se torna o atributo `__bases__`; e o dicionário dict é o namespace contendo as definições para a classe principal, e é copiada para um dicionário padrão para se tornar o atributo `__dict__`. Por exemplo, as seguintes duas instruções criam objetos `type` objects: idênticos

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

  Veja também Objetos de tipo.

  Alterado na versão 3.6: Sub-classes de `type` que não fazem sobrecarga de `type.__new__` não podem mais usar a forma com apenas um argumento para obter o tipo de um objeto.

`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 um `types.MappingProxyType` para prevenir atualizações diretas a dicionário).

  Sem um argumento, `vars()` funciona como `locals()`. Perceba que, o dicionário locals é apenas útil para leitura, pelo fato de alterações no dicionário locals serem ignoradas.

`zip`(*iterables)

  Produzi um iterador que agrega elementos de cada um dos iteráveis.

  Retorna um iterador de tuplas, onde a *i*ª tupla contém o *i*º elemento de cada uma das sequências de argumentos ou iteráveis. O iterador é parado quando a menor entrada iterável é esgotada. Com um único argumento iterável, ele retorna um iterador de 1 tupla. Sem argumentos, ele retorna um iterador vazio. Equivalente a:

      def zip(*iterables):
          # zip('ABCD', 'xy') --> Ax By
          sentinel = object()
          iterators = [iter(it) for it in iterables]
          while iterators:
              result = []
              for it in iterators:
                  elem = next(it, sentinel)
                  if elem is sentinel:
                      return
                  result.append(elem)
              yield tuple(result)

  A ordem de avaliação da esquerda para a direita dos iteráveis é garantida. Isso possibilita um idioma para agrupar uma série de dados em grupos de comprimento n usando `zip(*[iter(s)]*n)`. Isso repete o mesmo iterador `n` vezes, para que cada tupla de saída tenha o resultado de ``n` chamadas ao iterador. Isso tem o efeito de dividir a entrada em pedaços de comprimento n.

  `zip()` deve ser usado apenas com entradas de comprimento diferente quando você não se importa com valores inigualáveis à direita de iteráveis mais longos. Se esses valores forem importantes, use `itertools.zip_longest()`.

  `zip()` em conjunto com o operador `*` pode ser usado para descompactar uma lista:

      >>> x = [1, 2, 3]
      >>> y = [4, 5, 6]
      >>> zipped = zip(x, y)
      >>> list(zipped)
      [(1, 4), (2, 5), (3, 6)]
      >>> x2, y2 = zip(*zip(x, y))
      >>> x == list(x2) and y == list(y2)
      True

`__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()`.

  This function is invoked by the `import` statement. It can be replaced (by importing the `builtins` module and assigning to `builtins.__import__`) in order to change semantics of the `import` statement, but doing so is strongly discouraged as it is usually simpler to use import hooks (see PEP 302) to attain the same goals and does not cause issues with code which assumes the default import implementation is in use. Direct use of `__import__()` is also discouraged in favor of `importlib.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 `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 argumento fromlist não vazio é fornecido, o módulo nomeado por name é retornado.

  Por exemplo, a instrução `importar spam` resulta em bytecode semelhante ao seguinte código:

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

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

      spam = __import__('spam.ham', 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ção `import`.

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

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

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

Notas de Rodapé

1

  Observe que o analisador aceita apenas a convenção de fim de linha no estilo Unix. Se você estiver lendo o código de um arquivo, use o modo de conversão de nova linha para converter novas linhas no estilo Windows ou Mac.