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.
