"sys" --- Parâmetros e funções específicas do sistema
*****************************************************

======================================================================

Este módulo fornece acesso a algumas variáveis usadas ou mantidas pelo
interpretador e a funções que interagem fortemente com o
interpretador. Sempre disponível.

sys.abiflags

   Em sistemas POSIX onde Python foi construído com o script
   "configure" padrão, ele contém os sinalizadores ABI conforme
   especificado por **PEP 3149**.

   Novo na versão 3.2.

sys.argv

   A lista de argumentos de linha de comando passados para um script
   Python. "argv[0]" é o nome do script (depende do sistema
   operacional se este é um nome de caminho completo ou não). Se o
   comando foi executado usando a opção de linha de comando "-c" para
   o interpretador, "argv[0]" é definido como a string "'-c'". Se
   nenhum nome de script foi passado para o interpretador Python,
   "argv[0]" é a string vazia.

   Para percorrer a entrada padrão ou a lista de arquivos fornecida na
   linha de comando, consulte o módulo "fileinput".

   Nota:

     No Unix, os argumentos da linha de comando são passados por bytes
     do sistema operacional. O Python os decodifica com a codificação
     do sistema de arquivos e o tratador de erros "surrogateescape".
     Quando você precisar de bytes originais, você pode obtê-los por
     "[os.fsencode(arg) for arg in sys.argv]".

sys.base_exec_prefix

   Definido durante a inicialização do Python, antes de "site.py" ser
   executado, para o mesmo valor que "exec_prefix". Se não estiver
   executando em um ambiente virtual, os valores permanecerão os
   mesmos; se "site.py" descobrir que um ambiente virtual está em uso,
   os valores de "prefix" e "exec_prefix" serão alterados para apontar
   para o ambiente virtual, enquanto "base_prefix" e
   "base_exec_prefix" permanecerá apontando para a instalação base do
   Python (aquela a partir da qual o ambiente virtual foi criado).

   Novo na versão 3.3.

sys.base_prefix

   Definido durante a inicialização do Python, antes de "site.py" ser
   executado, para o mesmo valor que "prefix". Se não estiver
   executando em um ambiente virtual, os valores permanecerão os
   mesmos; se "site.py" descobrir que um ambiente virtual está em uso,
   os valores de "prefix" e "exec_prefix" serão alterados para apontar
   para o ambiente virtual, enquanto "base_prefix" e
   "base_exec_prefix" permanecerá apontando para a instalação base do
   Python (aquela a partir da qual o ambiente virtual foi criado).

   Novo na versão 3.3.

sys.byteorder

   Um indicador da ordem nativa de bytes. Isso terá o valor "'big'" em
   plataformas big endian (byte mais significativo primeiro) e
   "'little'" em plataformas little endian (byte menos significativo
   primeiro).

sys.builtin_module_names

   A tuple of strings giving the names of all modules that are
   compiled into this Python interpreter.  (This information is not
   available in any other way --- "modules.keys()" only lists the
   imported modules.)

sys.call_tracing(func, args)

   Chama "func(*args)", enquanto o rastreamento está habilitado. O
   estado de rastreamento é salvo e restaurado posteriormente. Isso
   deve ser chamado de um depurador de um ponto de verificação, para
   depurar recursivamente algum outro código.

sys.copyright

   Uma string contendo os direitos autorais pertencentes ao
   interpretador Python.

sys._clear_type_cache()

   Limpa o cache de tipo interno. O cache de tipo é usado para
   acelerar pesquisas de atributos e métodos. Use a função *apenas*
   para descartar referências desnecessárias durante a depuração de
   vazamento de referência.

   Esta função deve ser usada apenas para fins internos e
   especializados.

sys._current_frames()

   Retorna um dicionário mapeando o identificador de cada encadeamento
   (*thread*) para o quadro de pilha mais alto atualmente ativo nesse
   encadeamento no momento em que a função é chamada. Observe que as
   funções no módulo "traceback" podem construir a pilha de chamadas
   dado tal quadro.

   Isso é mais útil para depurar impasses: esta função não requer a
   cooperação dos encadeamentos em impasse e as pilhas de chamadas de
   tais encadeamentos são congeladas enquanto permanecerem em impasse
   (*deadlock*). O quadro retornado para um encadeamento sem impasse
   pode não ter nenhuma relação com a atividade atual desse
   encadeamento no momento em que o código de chamada examina o
   quadro.

   Esta função deve ser usada apenas para fins internos e
   especializados.

sys.breakpointhook()

   Esta função de gancho é chamada pela função embutida
   "breakpoint()". Por padrão, ela leva você ao depurador "pdb", mas
   pode ser configurado para qualquer outra função para que você possa
   escolher qual depurador será usado.

   A assinatura dessa função depende do que ela chama. Por exemplo, a
   ligação padrão (por exemplo, "pdb.set_trace()") não espera nenhum
   argumento, mas você pode vinculá-la a uma função que espera
   argumentos adicionais (posicionais e/ou nomeados). A função
   embutida "breakpoint()" passa seus "*args" e "**kws" diretamente. O
   que quer que "breakpointhooks()" retorne é retornado de
   "breakpoint()".

   A implementação padrão primeiro consulta a variável de ambiente
   "PYTHONBREAKPOINT". Se for definido como ""0"", então esta função
   retorna imediatamente; ou seja, é um no-op. Se a variável de
   ambiente não for definida, ou for definida como uma string vazia,
   "pdb.set_trace()" será chamado. Caso contrário, essa variável deve
   nomear uma função a ser executada, usando a nomenclatura de
   importação pontilhada do Python, por exemplo
   "package.subpackage.module.function". Neste caso,
   "package.subpackage.module" seria importado e o módulo resultante
   deve ter um chamável chamado "function()". Isso é executado,
   passando "*args" e "**kws", e qualquer que seja o retorno de
   "function()", "sys.breakpointhook()" retorna para a função embutida
   "breakpoint()".

   Observe que se algo der errado ao importar o chamável nomeado por
   "PYTHONBREAKPOINT", uma "RuntimeWarning" é relatado e o ponto de
   interrupção é ignorado.

   Observe também que se "sys.breakpointhook()" for sobrescrito
   programaticamente, "PYTHONBREAKPOINT" *não* será consultado.

   Novo na versão 3.7.

sys._debugmallocstats()

   Imprima informações de baixo nível para stderr sobre o estado do
   alocador de memória do CPython.

   If Python is configured --with-pydebug, it also performs some
   expensive internal consistency checks.

   Novo na versão 3.3.

   **CPython implementation detail:** Esta função é específica para
   CPython. O formato de saída exato não é definido aqui e pode mudar.

sys.dllhandle

   Número inteiro que especifica o identificador da DLL do Python.

   Disponibilidade: Windows.

sys.displayhook(value)

   Se *value* não for "None", esta função imprime "repr(value)" em
   "sys.stdout", e salva *value* em "builtins._". Se "repr(value)" não
   for codificável para "sys.stdout.encoding" com o tratador de erros
   "sys.stdout.errors" (que provavelmente é "'strict'"), codifica-o
   para "sys.stdout.encoding" com tratador de erros
   "'backslashreplace'".

   "sys.displayhook" é chamado no resultado da avaliação de uma
   *expressão* inserida em uma sessão interativa do Python. A exibição
   desses valores pode ser personalizada atribuindo outra função de um
   argumento a "sys.displayhook".

   Pseudocódigo:

      def displayhook(value):
          if value is None:
              return
          # Set '_' to None to avoid recursion
          builtins._ = None
          text = repr(value)
          try:
              sys.stdout.write(text)
          except UnicodeEncodeError:
              bytes = text.encode(sys.stdout.encoding, 'backslashreplace')
              if hasattr(sys.stdout, 'buffer'):
                  sys.stdout.buffer.write(bytes)
              else:
                  text = bytes.decode(sys.stdout.encoding, 'strict')
                  sys.stdout.write(text)
          sys.stdout.write("\n")
          builtins._ = value

   Alterado na versão 3.2: Usa o tratador de erros
   "'backslashreplace'" ao ser levantada "UnicodeEncodeError".

sys.dont_write_bytecode

   Se isso for true, o Python não tentará escrever arquivos ".pyc" na
   importação de módulos fonte. Este valor é inicialmente definido
   como "True" ou "False" dependendo da opção de linha de comando "-B"
   e da variável de ambiente "PYTHONDONTWRITEBYTECODE", mas você mesmo
   pode configurá-lo para controlar geração de arquivo bytecode.

sys.excepthook(type, value, traceback)

   Esta função imprime um determinado traceback (situação da pilha de
   execução) e exceção para "sys.stderr".

   Quando uma exceção é lançada e não capturada, o interpretador chama
   "sys.excepthook" com três argumentos, a classe de exceção, a
   instância de exceção e um objeto traceback. Em uma sessão
   interativa, isso acontece logo antes de o controle retornar ao
   prompt; em um programa Python, isso acontece pouco antes de o
   programa ser encerrado. A manipulação de tais exceções de nível
   superior pode ser personalizada atribuindo outra função de três
   argumentos a "sys.excepthook".

sys.__breakpointhook__
sys.__displayhook__
sys.__excepthook__

   These objects contain the original values of "breakpointhook",
   "displayhook", and "excepthook" at the start of the program.  They
   are saved so that "breakpointhook", "displayhook" and "excepthook"
   can be restored in case they happen to get replaced with broken or
   alternative objects.

   Novo na versão 3.7: __breakpointhook__

sys.exc_info()

   This function returns a tuple of three values that give information
   about the exception that is currently being handled.  The
   information returned is specific both to the current thread and to
   the current stack frame.  If the current stack frame is not
   handling an exception, the information is taken from the calling
   stack frame, or its caller, and so on until a stack frame is found
   that is handling an exception.  Here, "handling an exception" is
   defined as "executing an except clause."  For any stack frame, only
   information about the exception being currently handled is
   accessible.

   If no exception is being handled anywhere on the stack, a tuple
   containing three "None" values is returned.  Otherwise, the values
   returned are "(type, value, traceback)".  Their meaning is: *type*
   gets the type of the exception being handled (a subclass of
   "BaseException"); *value* gets the exception instance (an instance
   of the exception type); *traceback* gets a traceback object (see
   the Reference Manual) which encapsulates the call stack at the
   point where the exception originally occurred.

sys.exec_prefix

   Uma string que fornece o prefixo do diretório específico do site
   onde os arquivos Python dependentes da plataforma são instalados;
   por padrão, também é "'/usr/local'". Isso pode ser definido em
   tempo de compilação com o argumento "--exec-prefix" para o script
   **configure**. Especificamente, todos os arquivos de configuração
   (por exemplo, o arquivo de cabeçalho "pyconfig.h") são instalados
   no diretório "*exec_prefix*/lib/python*X.Y*/config", e os módulos
   da biblioteca compartilhada são instalados em
   "*exec_prefix*/lib/python*X.Y*/lib-dynload", onde *X.Y* é o número
   da versão do Python, por exemplo "3.2".

   Nota:

     Se um ambiente virtual estiver em vigor, este valor será alterado
     em "site.py" para apontar para o ambiente virtual. O valor para a
     instalação do Python ainda estará disponível, via
     "base_exec_prefix".

sys.executable

   Uma string que fornece o caminho absoluto do binário executável
   para o interpretador Python, em sistemas onde isso faz sentido. Se
   o Python não conseguir recuperar o caminho real para seu
   executável, "sys.executable" será uma string vazia ou "None".

sys.exit([arg])

   Exit from Python.  This is implemented by raising the "SystemExit"
   exception, so cleanup actions specified by finally clauses of "try"
   statements are honored, and it is possible to intercept the exit
   attempt at an outer level.

   O argumento opcional *arg* pode ser um número inteiro dando o
   status de saída (o padrão é zero) ou outro tipo de objeto. Se for
   um número inteiro, zero é considerado "terminação bem-sucedida" e
   qualquer valor diferente de zero é considerado "terminação anormal"
   por shells e similares. A maioria dos sistemas exige que ele esteja
   no intervalo de 0 a 127 e, caso contrário, produz resultados
   indefinidos. Alguns sistemas têm uma convenção para atribuir
   significados específicos a códigos de saída específicos, mas estes
   são geralmente subdesenvolvidos; Programas Unix geralmente usam 2
   para erros de sintaxe de linha de comando e 1 para todos os outros
   tipos de erros. Se outro tipo de objeto for passado, "None" é
   equivalente a passar zero, e qualquer outro objeto é impresso em
   "stderr" e resulta em um código de saída de 1. Em particular,
   "sys.exit( "alguma mensagem de erro")" é uma maneira rápida de sair
   de um programa quando ocorre um erro.

   Since "exit()" ultimately "only" raises an exception, it will only
   exit the process when called from the main thread, and the
   exception is not intercepted.

   Alterado na versão 3.6: Se ocorrer um erro na limpeza após o
   interpretador Python ter capturado "SystemExit" (como um erro ao
   liberar dados em buffer nos fluxos padrão), o status de saída é
   alterado para 120.

sys.flags

   A *tupla nomeada* *flags* expõe o status dos sinalizadores de linha
   de comando. Os atributos são somente leitura.

   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | atributo                      | sinalizador                                                                                                    |
   |===============================|================================================================================================================|
   | "debug"                       | "-d"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "inspect"                     | "-i"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "interactive"                 | "-i"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "isolated"                    | "-I"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "optimize"                    | "-O" or "-OO"                                                                                                  |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "dont_write_bytecode"         | "-B"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "no_user_site"                | "-s"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "no_site"                     | "-S"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "ignore_environment"          | "-E"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "verbose"                     | "-v"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "bytes_warning"               | "-b"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "quiet"                       | "-q"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "hash_randomization"          | "-R"                                                                                                           |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "dev_mode"                    | "-X" "dev"                                                                                                     |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "utf8_mode"                   | "-X" "utf8"                                                                                                    |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+
   | "int_max_str_digits"          | "-X int_max_str_digits" (integer string conversion length limitation)                                          |
   +-------------------------------+----------------------------------------------------------------------------------------------------------------+

   Alterado na versão 3.2: Adicionado o atributo "quiet" para o novo
   sinalizador "-q".

   Novo na versão 3.2.3: O atributo "hash_randomization".

   Alterado na versão 3.3: Removido o atributo obsoleto
   "division_warning".

   Alterado na versão 3.4: Adicionado o atributo "isolated" para o
   sinalizador:option:*-I* "isolated".

   Alterado na versão 3.7: Added "dev_mode" attribute for the new "-X"
   "dev" flag and "utf8_mode" attribute for the new  "-X" "utf8" flag.

   Alterado na versão 3.7.14: Added the "int_max_str_digits"
   attribute.

sys.float_info

   Uma *tupla nomeada* contendo informações sobre o tipo float, ponto
   flutuante. Ele contém informações de baixo nível sobre a precisão e
   a representação interna. Os valores correspondem às várias
   constantes de ponto flutuante definidas no arquivo de cabeçalho
   padrão "float.h" para a linguagem de programação 'C'; consulte a
   seção 5.2.4.2.2 do padrão ISO/IEC C de 1999 [C99], 'Características
   dos tipos flutuantes', para obter detalhes.

   +-----------------------+------------------+----------------------------------------------------+
   | atributo              | macro em float.h | explicação                                         |
   |=======================|==================|====================================================|
   | "epsilon"             | DBL_EPSILON      | diferença entre 1,0 e o menor valor maior que 1,0  |
   |                       |                  | que pode ser representado como ponto flutuante     |
   +-----------------------+------------------+----------------------------------------------------+
   | "dig"                 | DBL_DIG          | número máximo de dígitos decimais que podem ser    |
   |                       |                  | fielmente representados em um ponto flutuante;     |
   |                       |                  | Veja abaixo                                        |
   +-----------------------+------------------+----------------------------------------------------+
   | "mant_dig"            | DBL_MANT_DIG     | precisão do ponto flutuante: o número de dígitos   |
   |                       |                  | de base "radix" no significando de um ponto        |
   |                       |                  | flutuante                                          |
   +-----------------------+------------------+----------------------------------------------------+
   | "max"                 | DBL_MAX          | ponto flutuante finito positivo máximo             |
   |                       |                  | representável                                      |
   +-----------------------+------------------+----------------------------------------------------+
   | "max_exp"             | DBL_MAX_EXP      | inteiro máximo *e* de tal modo que``radix**(e-1)`` |
   |                       |                  | é um ponto flutuante finito representável          |
   +-----------------------+------------------+----------------------------------------------------+
   | "max_10_exp"          | DBL_MAX_10_EXP   | inteiro máximo *e* de tal modo que``10**e`` é um   |
   |                       |                  | intervalo de pontos flutuantes finitos             |
   |                       |                  | representáveis                                     |
   +-----------------------+------------------+----------------------------------------------------+
   | "min"                 | DBL_MIN          | ponto flutuante *normalizado* positivo mínimo      |
   |                       |                  | representável                                      |
   +-----------------------+------------------+----------------------------------------------------+
   | "min_exp"             | DBL_MIN_EXP      | inteiro mínimo *e* de tal modo que "radix**(e-1)"  |
   |                       |                  | é um ponto flutuante normalizado                   |
   +-----------------------+------------------+----------------------------------------------------+
   | "min_10_exp"          | DBL_MIN_10_EXP   | inteiro mínimo *e* de tal modo que "10**e" é um    |
   |                       |                  | ponto flutuante normalizado                        |
   +-----------------------+------------------+----------------------------------------------------+
   | "radix"               | FLT_RADIX        | raiz da representação do expoente                  |
   +-----------------------+------------------+----------------------------------------------------+
   | "rounds"              | FLT_ROUNDS       | integer constant representing the rounding mode    |
   |                       |                  | used for arithmetic operations.  This reflects the |
   |                       |                  | value of the system FLT_ROUNDS macro at            |
   |                       |                  | interpreter startup time.  See section 5.2.4.2.2   |
   |                       |                  | of the C99 standard for an explanation of the      |
   |                       |                  | possible values and their meanings.                |
   +-----------------------+------------------+----------------------------------------------------+

   O atributo "sys.float_info.dig" precisa de mais explicações. Se "s"
   for qualquer string representando um número decimal com no máximo
   "sys.float_info.dig" dígitos significativos, então converter "s"
   para ponto flutuante e vice-versa recuperará uma string
   representando o mesmo decimal valor:

      >>> import sys
      >>> sys.float_info.dig
      15
      >>> s = '3.14159265358979'    # decimal string with 15 significant digits
      >>> format(float(s), '.15g')  # convert to float and back -> same value
      '3.14159265358979'

   Mas para strings com mais de "sys.float_info.dig" dígitos
   significativos, isso nem sempre é verdade:

      >>> s = '9876543211234567'    # 16 significant digits is too many!
      >>> format(float(s), '.16g')  # conversion changes value
      '9876543211234568'

sys.float_repr_style

   Uma string indicando como a função "repr()" se comporta para
   floats. Se a string tem valor "'short'" então para um ponto
   flutuante finito "x", "repr(x)" visa produzir uma string curta com
   a propriedade que "float(repr(x)) == x". Este é o comportamento
   usual no Python 3.1 e posterior. Caso contrário, "float_repr_style"
   tem valor "'legacy'" e "repr(x)" se comporta da mesma forma que nas
   versões do Python anteriores a 3.1.

   Novo na versão 3.1.

sys.getallocatedblocks()

   Retorna o número de blocos de memória atualmente alocados pelo
   interpretador, independentemente de seu tamanho. Esta função é útil
   principalmente para rastrear e depurar vazamentos de memória.
   Devido aos caches internos do interpretador, o resultado pode
   variar de chamada para chamada; você pode ter que chamar
   "_clear_type_cache()" e "gc.collect()" para obter resultados mais
   previsíveis.

   Se uma construção ou implementação do Python não puder computar
   razoavelmente essas informações, "getallocatedblocks()" poderá
   retornar 0 em seu lugar.

   Novo na versão 3.4.

sys.getandroidapilevel()

   Retorna a versão da API de tempo de compilação do Android como um
   número inteiro.

   Disponibilidade: Android.

   Novo na versão 3.7.

sys.getcheckinterval()

   Return the interpreter's "check interval"; see
   "setcheckinterval()".

   Obsoleto desde a versão 3.2: Use "getswitchinterval()" instead.

sys.getdefaultencoding()

   Retorna o nome da codificação de string padrão atual usada pela
   implementação Unicode.

sys.getdlopenflags()

   Retorna o valor atual dos sinalizadores que são usados para
   chamadas "dlopen()". Nomes simbólicos para os valores dos
   sinalizadores podem ser encontrados no módulo "os" (constantes
   "RTLD_xxx", por exemplo "os.RTLD_LAZY").

   Disponibilidade: Unix.

sys.getfilesystemencoding()

   Return the name of the encoding used to convert between Unicode
   filenames and bytes filenames. For best compatibility, str should
   be used for filenames in all cases, although representing filenames
   as bytes is also supported. Functions accepting or returning
   filenames should support either str or bytes and internally convert
   to the system's preferred representation.

   This encoding is always ASCII-compatible.

   "os.fsencode()" e "os.fsdecode()" devem ser usados para garantir
   que a codificação correta e o modo de erros sejam usados.

   * In the UTF-8 mode, the encoding is "utf-8" on any platform.

   * On Mac OS X, the encoding is "'utf-8'".

   * On Unix, the encoding is the locale encoding.

   * On Windows, the encoding may be "'utf-8'" or "'mbcs'", depending
     on user configuration.

   Alterado na versão 3.2: O resultado de "getfilesystemencoding()"
   não pode mais ser "None".

   Alterado na versão 3.6: O Windows não tem mais garantia de retornar
   "'mbcs'". Veja **PEP 529** e "_enablelegacywindowsfsencoding()"
   para mais informações.

   Alterado na versão 3.7: Return 'utf-8' in the UTF-8 mode.

sys.getfilesystemencodeerrors()

   Return the name of the error mode used to convert between Unicode
   filenames and bytes filenames. The encoding name is returned from
   "getfilesystemencoding()".

   "os.fsencode()" e "os.fsdecode()" devem ser usados para garantir
   que a codificação correta e o modo de erros sejam usados.

   Novo na versão 3.6.

sys.get_int_max_str_digits()

   Returns the current value for the integer string conversion length
   limitation. See also "set_int_max_str_digits()".

   Novo na versão 3.7.14.

sys.getrefcount(object)

   Retorna a contagem de referências do *object*. A contagem retornada
   é geralmente um valor maior do que o esperado, porque inclui a
   referência (temporária) como um argumento para "getrefcount()".

sys.getrecursionlimit()

   Retorna o valor atual do limite de recursão, a profundidade máxima
   da pilha do interpretador Python. Esse limite evita que a recursão
   infinita cause um estouro da pilha C e falhe o Python. Pode ser
   definido por "setrecursionlimit()".

sys.getsizeof(object[, default])

   Retorna o tamanho de um objeto em bytes. O objeto pode ser qualquer
   tipo de objeto. Todos os objetos embutidos retornarão resultados
   corretos, mas isso não precisa ser verdadeiro para extensões de
   terceiros, pois é específico da implementação.

   Apenas o consumo de memória diretamente atribuído ao objeto é
   contabilizado, não o consumo de memória dos objetos a que ele se
   refere.

   Se fornecido, *default* será retornado se o objeto não fornecer
   meios para recuperar o tamanho. Caso contrário, uma exceção
   "TypeError" será levantada.

   "getsizeof()" chama o método "__sizeof__" do objeto e adiciona uma
   sobrecarga adicional do coletor de lixo se o objeto for gerenciado
   pelo coletor de lixo.

   Consulte receita de tamanho recursivo para obter um exemplo de uso
   de "getsizeof()" recursivamente para encontrar o tamanho dos
   contêineres e todo o seu conteúdo.

sys.getswitchinterval()

   Retorna o "intervalo de troca de thread" do interpretador; veja
   "setswitchinterval()".

   Novo na versão 3.2.

sys._getframe([depth])

   Retorna um objeto quadro da pilha de chamadas. Se o inteiro
   opcional *depth* for fornecido, retorna o objeto de quadro que
   muitos chamam abaixo do topo da pilha. Se for mais profundo do que
   a pilha de chamadas, "ValueError" é levantada. O padrão para
   *depth* é zero, retornando o quadro no topo da pilha de chamadas.

   **CPython implementation detail:** Esta função deve ser usada
   apenas para fins internos e especializados. Não é garantido que
   exista em todas as implementações do Python.

sys.getprofile()

   Obtém a função do criador de perfil conforme definido por
   "setprofile()".

sys.gettrace()

   Obtém a função trace conforme definido por "settrace()".

   **CPython implementation detail:** A função "gettrace()" destina-se
   apenas à implementação de depuradores, criadores de perfil,
   ferramentas de cobertura e similares. Seu comportamento faz parte
   da plataforma de implementação, e não da definição da linguagem e,
   portanto, pode não estar disponível em todas as implementações do
   Python.

sys.getwindowsversion()

   Retorna uma tupla nomeada que descreve a versão do Windows em
   execução no momento. Os elementos nomeados são *major*, *minor*,
   *build*, *platform*, *service_pack*, *service_pack_minor*,
   *service_pack_major*, *suite_mask*, *product_type* e
   *platform_version*. *service_pack* contém uma string,
   *platform_version* uma tupla de 3 elementos e todos os outros
   valores são inteiros. Os componentes também podem ser acessados
   pelo nome, então "sys.getwindowsversion()[0]" é equivalente a
   "sys.getwindowsversion().major". Para compatibilidade com versões
   anteriores, apenas os primeiros 5 elementos são recuperáveis por
   indexação.

   *platform* será "2 (VER_PLATFORM_WIN32_NT)".

   *product_type* pode ser um dos seguintes valores:

   +-----------------------------------------+-----------------------------------+
   | Constante                               | Significado                       |
   |=========================================|===================================|
   | "1 (VER_NT_WORKSTATION)"                | O sistema é uma estação de        |
   |                                         | trabalho                          |
   +-----------------------------------------+-----------------------------------+
   | "2 (VER_NT_DOMAIN_CONTROLLER)"          | O sistema é um controlador de     |
   |                                         | domínio.                          |
   +-----------------------------------------+-----------------------------------+
   | "3 (VER_NT_SERVER)"                     | O sistema é um servidor, mas não  |
   |                                         | um controlador de domínio.        |
   +-----------------------------------------+-----------------------------------+

   Esta função atua como um envólucro em volta da função Win32
   "GetVersionEx()"; consulte a documentação da Microsoft em
   "OSVERSIONINFOEX()" para obter mais informações sobre esses campos.

   *platform_version* returns the accurate major version, minor
   version and build number of the current operating system, rather
   than the version that is being emulated for the process. It is
   intended for use in logging rather than for feature detection.

   Disponibilidade: Windows.

   Alterado na versão 3.2: Alterado para uma tupla nomeada e
   adicionado *service_pack_minor*, *service_pack_major*, *suite_mask*
   e *product_type*.

   Alterado na versão 3.6: Adicionado *platform_version*

sys.get_asyncgen_hooks()

   Returns an *asyncgen_hooks* object, which is similar to a
   "namedtuple" of the form *(firstiter, finalizer)*, where
   *firstiter* and *finalizer* are expected to be either "None" or
   functions which take an *asynchronous generator iterator* as an
   argument, and are used to schedule finalization of an asynchronous
   generator by an event loop.

   Novo na versão 3.6: Veja **PEP 525** para mais detalhes.

   Nota:

     Esta função foi adicionada provisoriamente (veja **PEP 411** para
     detalhes.)

sys.get_coroutine_origin_tracking_depth()

   Obtém a profundidade de rastreamento da origem da corrotina atual,
   conforme definido por "set_coroutine_origin_tracking_depth()".

   Novo na versão 3.7.

   Nota:

     Esta função foi adicionada provisoriamente (veja **PEP 411** para
     detalhes.) Use-a apenas para propósitos de depuração.

sys.get_coroutine_wrapper()

   Returns "None", or a wrapper set by "set_coroutine_wrapper()".

   Novo na versão 3.5: See **PEP 492** for more details.

   Nota:

     Esta função foi adicionada provisoriamente (veja **PEP 411** para
     detalhes.) Use-a apenas para propósitos de depuração.

   Obsoleto desde a versão 3.7: The coroutine wrapper functionality
   has been deprecated, and will be removed in 3.8. See bpo-32591 for
   details.

sys.hash_info

   Uma *tupla nomeada* fornecendo parâmetros da implementação de hash
   numérico. Para mais detalhes sobre hashing de tipos numéricos, veja
   Hashing de tipos numéricos.

   +-----------------------+----------------------------------------------------+
   | atributo              | explicação                                         |
   |=======================|====================================================|
   | "width"               | largura em bits usada para fazer hash de valores   |
   +-----------------------+----------------------------------------------------+
   | "modulus"             | módulo primo P usado para esquema de hash numérico |
   +-----------------------+----------------------------------------------------+
   | "inf"                 | valor de hash retornado para um infinito positivo  |
   +-----------------------+----------------------------------------------------+
   | "nan"                 | hash value returned for a nan                      |
   +-----------------------+----------------------------------------------------+
   | "imag"                | multiplicador usado para a parte imaginária de um  |
   |                       | número complexo                                    |
   +-----------------------+----------------------------------------------------+
   | "algorithm"           | nome do algoritmo para hash de str, bytes e        |
   |                       | memoryview                                         |
   +-----------------------+----------------------------------------------------+
   | "hash_bits"           | tamanho da saída interna do algoritmo de hash      |
   +-----------------------+----------------------------------------------------+
   | "seed_bits"           | tamanho da chave semente do algoritmo hash         |
   +-----------------------+----------------------------------------------------+

   Novo na versão 3.2.

   Alterado na versão 3.4: Adicionado *algorithm*, *hash_bits* e
   *seed_bits*

sys.hexversion

   O número da versão codificado como um único inteiro. Isso é
   garantido para aumentar com cada versão, incluindo suporte adequado
   para lançamentos de não produção. Por exemplo, para testar se o
   interpretador Python é pelo menos a versão 1.5.2, use:

      if sys.hexversion >= 0x010502F0:
          # use some advanced feature
          ...
      else:
          # use an alternative implementation or warn the user
          ...

   Isso é chamado "hexversion" já que só parece realmente
   significativo quando visto como o resultado de passá-lo para a
   função embutida "hex()". A *tupla nomeada* "sys.version_info" pode
   ser usada para uma codificação mais amigável das mesmas
   informações.

   Mais detalhes sobre "hexversion" podem ser encontrados em API e
   versionamento ABI.

sys.implementation

   Um objeto que contém informações sobre a implementação do
   interpretador Python em execução no momento. Os atributos a seguir
   devem existir em todas as implementações do Python.

   *name* é o identificador da implementação, por exemplo "'cpython'".
   A string real é definida pela implementação do Python, mas é
   garantido que seja minúscula.

   *version* is a named tuple, in the same format as
   "sys.version_info".  It represents the version of the Python
   *implementation*.  This has a distinct meaning from the specific
   version of the Python *language* to which the currently running
   interpreter conforms, which "sys.version_info" represents.  For
   example, for PyPy 1.8 "sys.implementation.version" might be
   "sys.version_info(1, 8, 0, 'final', 0)", whereas "sys.version_info"
   would be "sys.version_info(2, 7, 2, 'final', 0)".  For CPython they
   are the same value, since it is the reference implementation.

   *hexversion* is the implementation version in hexadecimal format,
   like "sys.hexversion".

   *cache_tag* is the tag used by the import machinery in the
   filenames of cached modules.  By convention, it would be a
   composite of the implementation's name and version, like
   "'cpython-33'".  However, a Python implementation may use some
   other value if appropriate.  If "cache_tag" is set to "None", it
   indicates that module caching should be disabled.

   "sys.implementation" may contain additional attributes specific to
   the Python implementation.  These non-standard attributes must
   start with an underscore, and are not described here.  Regardless
   of its contents, "sys.implementation" will not change during a run
   of the interpreter, nor between implementation versions.  (It may
   change between Python language versions, however.)  See **PEP 421**
   for more information.

   Novo na versão 3.3.

   Nota:

     The addition of new required attributes must go through the
     normal PEP process. See **PEP 421** for more information.

sys.int_info

   A *named tuple* that holds information about Python's internal
   representation of integers.  The attributes are read only.

   +------------------------------------------+-------------------------------------------------+
   | Atributo                                 | Explanação                                      |
   |==========================================|=================================================|
   | "bits_per_digit"                         | number of bits held in each digit.  Python      |
   |                                          | integers are stored internally in base          |
   |                                          | "2**int_info.bits_per_digit"                    |
   +------------------------------------------+-------------------------------------------------+
   | "sizeof_digit"                           | size in bytes of the C type used to represent a |
   |                                          | digit                                           |
   +------------------------------------------+-------------------------------------------------+
   | "default_max_str_digits"                 | default value for                               |
   |                                          | "sys.get_int_max_str_digits()" when it is not   |
   |                                          | otherwise explicitly configured.                |
   +------------------------------------------+-------------------------------------------------+
   | "str_digits_check_threshold"             | minimum non-zero value for                      |
   |                                          | "sys.set_int_max_str_digits()",                 |
   |                                          | "PYTHONINTMAXSTRDIGITS", or "-X                 |
   |                                          | int_max_str_digits".                            |
   +------------------------------------------+-------------------------------------------------+

   Novo na versão 3.1.

   Alterado na versão 3.7.14: Added "default_max_str_digits" and
   "str_digits_check_threshold".

sys.__interactivehook__

   When this attribute exists, its value is automatically called (with
   no arguments) when the interpreter is launched in interactive mode.
   This is done after the "PYTHONSTARTUP" file is read, so that you
   can set this hook there.  The "site" module sets this.

   Novo na versão 3.4.

sys.intern(string)

   Enter *string* in the table of "interned" strings and return the
   interned string -- which is *string* itself or a copy. Interning
   strings is useful to gain a little performance on dictionary lookup
   -- if the keys in a dictionary are interned, and the lookup key is
   interned, the key comparisons (after hashing) can be done by a
   pointer compare instead of a string compare.  Normally, the names
   used in Python programs are automatically interned, and the
   dictionaries used to hold module, class or instance attributes have
   interned keys.

   Interned strings are not immortal; you must keep a reference to the
   return value of "intern()" around to benefit from it.

sys.is_finalizing()

   Return "True" if the Python interpreter is *shutting down*, "False"
   otherwise.

   Novo na versão 3.5.

sys.last_type
sys.last_value
sys.last_traceback

   These three variables are not always defined; they are set when an
   exception is not handled and the interpreter prints an error
   message and a stack traceback. Their intended use is to allow an
   interactive user to import a debugger module and engage in post-
   mortem debugging without having to re-execute the command that
   caused the error.  (Typical use is "import pdb; pdb.pm()" to enter
   the post-mortem debugger; see "pdb" module for more information.)

   The meaning of the variables is the same as that of the return
   values from "exc_info()" above.

sys.maxsize

   An integer giving the maximum value a variable of type "Py_ssize_t"
   can take.  It's usually "2**31 - 1" on a 32-bit platform and "2**63
   - 1" on a 64-bit platform.

sys.maxunicode

   An integer giving the value of the largest Unicode code point, i.e.
   "1114111" ("0x10FFFF" in hexadecimal).

   Alterado na versão 3.3: Before **PEP 393**, "sys.maxunicode" used
   to be either "0xFFFF" or "0x10FFFF", depending on the configuration
   option that specified whether Unicode characters were stored as
   UCS-2 or UCS-4.

sys.meta_path

   A list of *meta path finder* objects that have their "find_spec()"
   methods called to see if one of the objects can find the module to
   be imported. The "find_spec()" method is called with at least the
   absolute name of the module being imported. If the module to be
   imported is contained in a package, then the parent package's
   "__path__" attribute is passed in as a second argument. The method
   returns a *module spec*, or "None" if the module cannot be found.

   Ver também:

     "importlib.abc.MetaPathFinder"
        The abstract base class defining the interface of finder
        objects on "meta_path".

     "importlib.machinery.ModuleSpec"
        The concrete class which "find_spec()" should return instances
        of.

   Alterado na versão 3.4: *Module specs* were introduced in Python
   3.4, by **PEP 451**. Earlier versions of Python looked for a method
   called "find_module()". This is still called as a fallback if a
   "meta_path" entry doesn't have a "find_spec()" method.

sys.modules

   This is a dictionary that maps module names to modules which have
   already been loaded.  This can be manipulated to force reloading of
   modules and other tricks. However, replacing the dictionary will
   not necessarily work as expected and deleting essential items from
   the dictionary may cause Python to fail.

sys.path

   A list of strings that specifies the search path for modules.
   Initialized from the environment variable "PYTHONPATH", plus an
   installation-dependent default.

   As initialized upon program startup, the first item of this list,
   "path[0]", is the directory containing the script that was used to
   invoke the Python interpreter.  If the script directory is not
   available (e.g.  if the interpreter is invoked interactively or if
   the script is read from standard input), "path[0]" is the empty
   string, which directs Python to search modules in the current
   directory first.  Notice that the script directory is inserted
   *before* the entries inserted as a result of "PYTHONPATH".

   A program is free to modify this list for its own purposes.  Only
   strings and bytes should be added to "sys.path"; all other data
   types are ignored during import.

   Ver também:

     Module "site" This describes how to use .pth files to extend
     "sys.path".

sys.path_hooks

   A list of callables that take a path argument to try to create a
   *finder* for the path. If a finder can be created, it is to be
   returned by the callable, else raise "ImportError".

   Originally specified in **PEP 302**.

sys.path_importer_cache

   A dictionary acting as a cache for *finder* objects. The keys are
   paths that have been passed to "sys.path_hooks" and the values are
   the finders that are found. If a path is a valid file system path
   but no finder is found on "sys.path_hooks" then "None" is stored.

   Originally specified in **PEP 302**.

   Alterado na versão 3.3: "None" is stored instead of
   "imp.NullImporter" when no finder is found.

sys.platform

   This string contains a platform identifier that can be used to
   append platform-specific components to "sys.path", for instance.

   For Unix systems, except on Linux, this is the lowercased OS name
   as returned by "uname -s" with the first part of the version as
   returned by "uname -r" appended, e.g. "'sunos5'" or "'freebsd8'",
   *at the time when Python was built*.  Unless you want to test for a
   specific system version, it is therefore recommended to use the
   following idiom:

      if sys.platform.startswith('freebsd'):
          # FreeBSD-specific code here...
      elif sys.platform.startswith('linux'):
          # Linux-specific code here...

   For other systems, the values are:

   +------------------+-----------------------------+
   | System           | "platform" value            |
   |==================|=============================|
   | Linux            | "'linux'"                   |
   +------------------+-----------------------------+
   | Windows          | "'win32'"                   |
   +------------------+-----------------------------+
   | Windows/Cygwin   | "'cygwin'"                  |
   +------------------+-----------------------------+
   | Mac OS X         | "'darwin'"                  |
   +------------------+-----------------------------+

   Alterado na versão 3.3: On Linux, "sys.platform" doesn't contain
   the major version anymore. It is always "'linux'", instead of
   "'linux2'" or "'linux3'".  Since older Python versions include the
   version number, it is recommended to always use the "startswith"
   idiom presented above.

   Ver também:

     "os.name" has a coarser granularity.  "os.uname()" gives system-
     dependent version information.

     O módulo "platform" fornece verificações detalhadas sobre a
     identificação do sistema.

sys.prefix

   A string giving the site-specific directory prefix where the
   platform independent Python files are installed; by default, this
   is the string "'/usr/local'".  This can be set at build time with
   the "--prefix" argument to the **configure** script.  The main
   collection of Python library modules is installed in the directory
   "*prefix*/lib/python*X.Y*" while the platform independent header
   files (all except "pyconfig.h") are stored in
   "*prefix*/include/python*X.Y*", where *X.Y* is the version number
   of Python, for example "3.2".

   Nota:

     If a virtual environment is in effect, this value will be changed
     in "site.py" to point to the virtual environment. The value for
     the Python installation will still be available, via
     "base_prefix".

sys.ps1
sys.ps2

   Strings specifying the primary and secondary prompt of the
   interpreter.  These are only defined if the interpreter is in
   interactive mode.  Their initial values in this case are "'>>> '"
   and "'... '".  If a non-string object is assigned to either
   variable, its "str()" is re-evaluated each time the interpreter
   prepares to read a new interactive command; this can be used to
   implement a dynamic prompt.

sys.setcheckinterval(interval)

   Set the interpreter's "check interval".  This integer value
   determines how often the interpreter checks for periodic things
   such as thread switches and signal handlers.  The default is "100",
   meaning the check is performed every 100 Python virtual
   instructions. Setting it to a larger value may increase performance
   for programs using threads.  Setting it to a value "<=" 0 checks
   every virtual instruction, maximizing responsiveness as well as
   overhead.

   Obsoleto desde a versão 3.2: This function doesn't have an effect
   anymore, as the internal logic for thread switching and
   asynchronous tasks has been rewritten.  Use "setswitchinterval()"
   instead.

sys.setdlopenflags(n)

   Set the flags used by the interpreter for "dlopen()" calls, such as
   when the interpreter loads extension modules.  Among other things,
   this will enable a lazy resolving of symbols when importing a
   module, if called as "sys.setdlopenflags(0)".  To share symbols
   across extension modules, call as
   "sys.setdlopenflags(os.RTLD_GLOBAL)".  Symbolic names for the flag
   values can be found in the "os" module ("RTLD_xxx" constants, e.g.
   "os.RTLD_LAZY").

   Disponibilidade: Unix.

sys.set_int_max_str_digits(n)

   Set the integer string conversion length limitation used by this
   interpreter. See also "get_int_max_str_digits()".

   Novo na versão 3.7.14.

sys.setprofile(profilefunc)

   Set the system's profile function, which allows you to implement a
   Python source code profiler in Python.  See chapter The Python
   Profilers for more information on the Python profiler.  The
   system's profile function is called similarly to the system's trace
   function (see "settrace()"), but it is called with different
   events, for example it isn't called for each executed line of code
   (only on call and return, but the return event is reported even
   when an exception has been set). The function is thread-specific,
   but there is no way for the profiler to know about context switches
   between threads, so it does not make sense to use this in the
   presence of multiple threads. Also, its return value is not used,
   so it can simply return "None".  Error in the profile function will
   cause itself unset.

   Profile functions should have three arguments: *frame*, *event*,
   and *arg*. *frame* is the current stack frame.  *event* is a
   string: "'call'", "'return'", "'c_call'", "'c_return'", or
   "'c_exception'". *arg* depends on the event type.

   The events have the following meaning:

   "'call'"
      A function is called (or some other code block entered).  The
      profile function is called; *arg* is "None".

   "'return'"
      A function (or other code block) is about to return.  The
      profile function is called; *arg* is the value that will be
      returned, or "None" if the event is caused by an exception being
      raised.

   "'c_call'"
      A C function is about to be called.  This may be an extension
      function or a built-in.  *arg* is the C function object.

   "'c_return'"
      A C function has returned. *arg* is the C function object.

   "'c_exception'"
      A C function has raised an exception.  *arg* is the C function
      object.

sys.setrecursionlimit(limit)

   Set the maximum depth of the Python interpreter stack to *limit*.
   This limit prevents infinite recursion from causing an overflow of
   the C stack and crashing Python.

   The highest possible limit is platform-dependent.  A user may need
   to set the limit higher when they have a program that requires deep
   recursion and a platform that supports a higher limit.  This should
   be done with care, because a too-high limit can lead to a crash.

   If the new limit is too low at the current recursion depth, a
   "RecursionError" exception is raised.

   Alterado na versão 3.5.1: A "RecursionError" exception is now
   raised if the new limit is too low at the current recursion depth.

sys.setswitchinterval(interval)

   Set the interpreter's thread switch interval (in seconds).  This
   floating-point value determines the ideal duration of the
   "timeslices" allocated to concurrently running Python threads.
   Please note that the actual value can be higher, especially if
   long-running internal functions or methods are used.  Also, which
   thread becomes scheduled at the end of the interval is the
   operating system's decision.  The interpreter doesn't have its own
   scheduler.

   Novo na versão 3.2.

sys.settrace(tracefunc)

   Set the system's trace function, which allows you to implement a
   Python source code debugger in Python.  The function is thread-
   specific; for a debugger to support multiple threads, it must
   register a trace function using "settrace()" for each thread being
   debugged or use "threading.settrace()".

   Trace functions should have three arguments: *frame*, *event*, and
   *arg*. *frame* is the current stack frame.  *event* is a string:
   "'call'", "'line'", "'return'", "'exception'" or "'opcode'".  *arg*
   depends on the event type.

   The trace function is invoked (with *event* set to "'call'")
   whenever a new local scope is entered; it should return a reference
   to a local trace function to be used for the new scope, or "None"
   if the scope shouldn't be traced.

   The local trace function should return a reference to itself (or to
   another function for further tracing in that scope), or "None" to
   turn off tracing in that scope.

   If there is any error occurred in the trace function, it will be
   unset, just like "settrace(None)" is called.

   The events have the following meaning:

   "'call'"
      A function is called (or some other code block entered).  The
      global trace function is called; *arg* is "None"; the return
      value specifies the local trace function.

   "'line'"
      The interpreter is about to execute a new line of code or re-
      execute the condition of a loop.  The local trace function is
      called; *arg* is "None"; the return value specifies the new
      local trace function.  See "Objects/lnotab_notes.txt" for a
      detailed explanation of how this works. Per-line events may be
      disabled for a frame by setting "f_trace_lines" to "False" on
      that frame.

   "'return'"
      A function (or other code block) is about to return.  The local
      trace function is called; *arg* is the value that will be
      returned, or "None" if the event is caused by an exception being
      raised.  The trace function's return value is ignored.

   "'exception'"
      An exception has occurred.  The local trace function is called;
      *arg* is a tuple "(exception, value, traceback)"; the return
      value specifies the new local trace function.

   "'opcode'"
      The interpreter is about to execute a new opcode (see "dis" for
      opcode details).  The local trace function is called; *arg* is
      "None"; the return value specifies the new local trace function.
      Per-opcode events are not emitted by default: they must be
      explicitly requested by setting "f_trace_opcodes" to "True" on
      the frame.

   Note that as an exception is propagated down the chain of callers,
   an "'exception'" event is generated at each level.

   For more fine-grained usage, it's possible to set a trace function
   by assigning "frame.f_trace = tracefunc" explicitly, rather than
   relying on it being set indirectly via the return value from an
   already installed trace function. This is also required for
   activating the trace function on the current frame, which
   "settrace()" doesn't do. Note that in order for this to work, a
   global tracing function must have been installed with "settrace()"
   in order to enable the runtime tracing machinery, but it doesn't
   need to be the same tracing function (e.g. it could be a low
   overhead tracing function that simply returns "None" to disable
   itself immediately on each frame).

   For more information on code and frame objects, refer to A
   hierarquia de tipos padrão.

   **CPython implementation detail:** The "settrace()" function is
   intended only for implementing debuggers, profilers, coverage tools
   and the like.  Its behavior is part of the implementation platform,
   rather than part of the language definition, and thus may not be
   available in all Python implementations.

   Alterado na versão 3.7: "'opcode'" event type added;
   "f_trace_lines" and "f_trace_opcodes" attributes added to frames

sys.set_asyncgen_hooks(firstiter, finalizer)

   Accepts two optional keyword arguments which are callables that
   accept an *asynchronous generator iterator* as an argument. The
   *firstiter* callable will be called when an asynchronous generator
   is iterated for the first time. The *finalizer* will be called when
   an asynchronous generator is about to be garbage collected.

   Novo na versão 3.6: See **PEP 525** for more details, and for a
   reference example of a *finalizer* method see the implementation of
   "asyncio.Loop.shutdown_asyncgens" in Lib/asyncio/base_events.py

   Nota:

     Esta função foi adicionada provisoriamente (veja **PEP 411** para
     detalhes.)

sys.set_coroutine_origin_tracking_depth(depth)

   Allows enabling or disabling coroutine origin tracking. When
   enabled, the "cr_origin" attribute on coroutine objects will
   contain a tuple of (filename, line number, function name) tuples
   describing the traceback where the coroutine object was created,
   with the most recent call first. When disabled, "cr_origin" will be
   None.

   To enable, pass a *depth* value greater than zero; this sets the
   number of frames whose information will be captured. To disable,
   pass set *depth* to zero.

   This setting is thread-specific.

   Novo na versão 3.7.

   Nota:

     Esta função foi adicionada provisoriamente (veja **PEP 411** para
     detalhes.) Use-a apenas para propósitos de depuração.

sys.set_coroutine_wrapper(wrapper)

   Allows intercepting creation of *coroutine* objects (only ones that
   are created by an "async def" function; generators decorated with
   "types.coroutine()" or "asyncio.coroutine()" will not be
   intercepted).

   The *wrapper* argument must be either:

   * a callable that accepts one argument (a coroutine object);

   * "None", to reset the wrapper.

   If called twice, the new wrapper replaces the previous one.  The
   function is thread-specific.

   The *wrapper* callable cannot define new coroutines directly or
   indirectly:

      def wrapper(coro):
          async def wrap(coro):
              return await coro
          return wrap(coro)
      sys.set_coroutine_wrapper(wrapper)

      async def foo():
          pass

      # The following line will fail with a RuntimeError, because
      # ``wrapper`` creates a ``wrap(coro)`` coroutine:
      foo()

   See also "get_coroutine_wrapper()".

   Novo na versão 3.5: See **PEP 492** for more details.

   Nota:

     Esta função foi adicionada provisoriamente (veja **PEP 411** para
     detalhes.) Use-a apenas para propósitos de depuração.

   Obsoleto desde a versão 3.7: The coroutine wrapper functionality
   has been deprecated, and will be removed in 3.8. See bpo-32591 for
   details.

sys._enablelegacywindowsfsencoding()

   Changes the default filesystem encoding and errors mode to 'mbcs'
   and 'replace' respectively, for consistency with versions of Python
   prior to 3.6.

   This is equivalent to defining the "PYTHONLEGACYWINDOWSFSENCODING"
   environment variable before launching Python.

   Disponibilidade: Windows.

   Novo na versão 3.6: Veja **PEP 529** para mais detalhes.

sys.stdin
sys.stdout
sys.stderr

   *File objects* used by the interpreter for standard input, output
   and errors:

   * "stdin" is used for all interactive input (including calls to
     "input()");

   * "stdout" is used for the output of "print()" and *expression*
     statements and for the prompts of "input()";

   * The interpreter's own prompts and its error messages go to
     "stderr".

   These streams are regular *text files* like those returned by the
   "open()" function.  Their parameters are chosen as follows:

   * The character encoding is platform-dependent.  Non-Windows
     platforms use the locale encoding (see
     "locale.getpreferredencoding()").

     On Windows, UTF-8 is used for the console device.  Non-character
     devices such as disk files and pipes use the system locale
     encoding (i.e. the ANSI codepage).  Non-console character devices
     such as NUL (i.e. where "isatty()" returns "True") use the value
     of the console input and output codepages at startup,
     respectively for stdin and stdout/stderr. This defaults to the
     system locale encoding if the process is not initially attached
     to a console.

     The special behaviour of the console can be overridden by setting
     the environment variable PYTHONLEGACYWINDOWSSTDIO before starting
     Python. In that case, the console codepages are used as for any
     other character device.

     Under all platforms, you can override the character encoding by
     setting the "PYTHONIOENCODING" environment variable before
     starting Python or by using the new "-X" "utf8" command line
     option and "PYTHONUTF8" environment variable.  However, for the
     Windows console, this only applies when
     "PYTHONLEGACYWINDOWSSTDIO" is also set.

   * When interactive, "stdout" and "stderr" streams are line-
     buffered. Otherwise, they are block-buffered like regular text
     files.  You can override this value with the "-u" command-line
     option.

   Nota:

     To write or read binary data from/to the standard streams, use
     the underlying binary "buffer" object.  For example, to write
     bytes to "stdout", use "sys.stdout.buffer.write(b'abc')".However,
     if you are writing a library (and do not control in which context
     its code will be executed), be aware that the standard streams
     may be replaced with file-like objects like "io.StringIO" which
     do not support the "buffer" attribute.

sys.__stdin__
sys.__stdout__
sys.__stderr__

   These objects contain the original values of "stdin", "stderr" and
   "stdout" at the start of the program.  They are used during
   finalization, and could be useful to print to the actual standard
   stream no matter if the "sys.std*" object has been redirected.

   It can also be used to restore the actual files to known working
   file objects in case they have been overwritten with a broken
   object.  However, the preferred way to do this is to explicitly
   save the previous stream before replacing it, and restore the saved
   object.

   Nota:

     Under some conditions "stdin", "stdout" and "stderr" as well as
     the original values "__stdin__", "__stdout__" and "__stderr__"
     can be "None". It is usually the case for Windows GUI apps that
     aren't connected to a console and Python apps started with
     **pythonw**.

sys.thread_info

   A *named tuple* holding information about the thread
   implementation.

   +--------------------+-----------------------------------------------------------+
   | Atributo           | Explanação                                                |
   |====================|===========================================================|
   | "name"             | Name of the thread implementation:  * "'nt'": Windows     |
   |                    | threads  * "'pthread'": threads POSIX  * "'solaris'":     |
   |                    | Solaris threads                                           |
   +--------------------+-----------------------------------------------------------+
   | "lock"             | Name of the lock implementation:  * "'semaphore'": a lock |
   |                    | uses a semaphore  * "'mutex+cond'": a lock uses a mutex   |
   |                    | and a condition variable  * "None" if this information is |
   |                    | unknown                                                   |
   +--------------------+-----------------------------------------------------------+
   | "version"          | Name and version of the thread library. It is a string,   |
   |                    | or "None" if this information is unknown.                 |
   +--------------------+-----------------------------------------------------------+

   Novo na versão 3.3.

sys.tracebacklimit

   When this variable is set to an integer value, it determines the
   maximum number of levels of traceback information printed when an
   unhandled exception occurs. The default is "1000".  When set to "0"
   or less, all traceback information is suppressed and only the
   exception type and value are printed.

sys.version

   A string containing the version number of the Python interpreter
   plus additional information on the build number and compiler used.
   This string is displayed when the interactive interpreter is
   started.  Do not extract version information out of it, rather, use
   "version_info" and the functions provided by the "platform" module.

sys.api_version

   The C API version for this interpreter.  Programmers may find this
   useful when debugging version conflicts between Python and
   extension modules.

sys.version_info

   A tuple containing the five components of the version number:
   *major*, *minor*, *micro*, *releaselevel*, and *serial*.  All
   values except *releaselevel* are integers; the release level is
   "'alpha'", "'beta'", "'candidate'", or "'final'".  The
   "version_info" value corresponding to the Python version 2.0 is
   "(2, 0, 0, 'final', 0)".  The components can also be accessed by
   name, so "sys.version_info[0]" is equivalent to
   "sys.version_info.major" and so on.

   Alterado na versão 3.1: Added named component attributes.

sys.warnoptions

   This is an implementation detail of the warnings framework; do not
   modify this value.  Refer to the "warnings" module for more
   information on the warnings framework.

sys.winver

   The version number used to form registry keys on Windows platforms.
   This is stored as string resource 1000 in the Python DLL.  The
   value is normally the first three characters of "version".  It is
   provided in the "sys" module for informational purposes; modifying
   this value has no effect on the registry keys used by Python.

   Disponibilidade: Windows.

sys._xoptions

   A dictionary of the various implementation-specific flags passed
   through the "-X" command-line option.  Option names are either
   mapped to their values, if given explicitly, or to "True".
   Example:

      $ ./python -Xa=b -Xc
      Python 3.2a3+ (py3k, Oct 16 2010, 20:14:50)
      [GCC 4.4.3] on linux2
      Type "help", "copyright", "credits" or "license" for more information.
      >>> import sys
      >>> sys._xoptions
      {'a': 'b', 'c': True}

   **CPython implementation detail:** This is a CPython-specific way
   of accessing options passed through "-X".  Other implementations
   may export them through other means, or not at all.

   Novo na versão 3.2.

-[ Citations ]-

[C99] ISO/IEC 9899:1999.  "Programming languages -- C."  A public
      draft of this standard is available at http://www.open-
      std.org/jtc1/sc22/wg14/www/docs/n1256.pdf.
