stdtypes.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# willian ohara, 2026
# Adorilson Bezerra <adorilson@gmail.com>, 2026
# zanarelli, 2026
# python-doc bot, 2026
# Rafael Fontenelle <rffontenelle@gmail.com>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-13 19:59+0000\n"
"PO-Revision-Date: 2026-09-13 17:09+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2026\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pt_BR\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"

#: ../../builtins/stdtypes.rst:8
msgid "Built-in Types"
msgstr "Tipos embutidos"

#: ../../builtins/stdtypes.rst:10
msgid ""
"The following sections describe the standard types that are built into the "
"interpreter."
msgstr ""
"As seções a seguir descrevem os tipos padrão que são embutidos ao "
"interpretador."

#: ../../builtins/stdtypes.rst:15
msgid ""
"The principal built-in types are numerics, sequences, mappings, classes, "
"instances and exceptions."
msgstr ""
"Os principais tipos embutidos são numéricos, sequências, mapeamentos, "
"classes, instâncias e exceções."

#: ../../builtins/stdtypes.rst:18
msgid ""
"Some collection classes are mutable.  The methods that add, subtract, or "
"rearrange their members in place, and don't return a specific item, never "
"return the collection instance itself but ``None``."
msgstr ""
"Algumas classes de coleção são mutáveis. Os métodos que adicionam, subtraem "
"ou reorganizam seus membros no lugar, e não retornam um item específico, "
"nunca retornam a instância da coleção propriamente dita, mas um ``None``."

#: ../../builtins/stdtypes.rst:22
msgid ""
"Some operations are supported by several object types; in particular, "
"practically all objects can be compared for equality, tested for truth "
"value, and converted to a string (with the :func:`repr` function or the "
"slightly different :func:`str` function).  The latter function is implicitly "
"used when an object is written by the :func:`print` function."
msgstr ""
"Algumas operações são suportadas por vários tipos de objetos; em particular, "
"praticamente todos os objetos podem ser comparados em termos de igualdade, "
"testados quanto ao valor verdade e convertidos em uma string (com a função :"
"func:`repr` ou a função ligeiramente diferente :func:`str`). A última função "
"é implicitamente usada quando um objeto é escrito pela função :func:`print`."

#: ../../builtins/stdtypes.rst:32
msgid "Truth Value Testing"
msgstr "Teste do valor verdade"

#: ../../builtins/stdtypes.rst:41
msgid ""
"Any object can be tested for truth value, for use in an :keyword:`if` or :"
"keyword:`while` condition or as operand of the Boolean operations below."
msgstr ""
"Qualquer objeto pode ser testado quanto ao valor verdade, para uso em uma "
"condição :keyword:`if` ou :keyword:`while` ou como operando das operações "
"booleanas abaixo."

#: ../../builtins/stdtypes.rst:46
msgid ""
"By default, an object is considered true unless its class defines either a :"
"meth:`~object.__bool__` method that returns ``False`` or a :meth:`~object."
"__len__` method that returns zero, when called with the object. [1]_ If one "
"of the methods raises an exception when called, the exception is propagated "
"and the object does not have a truth value (for example, :data:"
"`NotImplemented`). Here are most of the built-in objects considered false:"
msgstr ""
"Por predefinição, um objeto é considerado verdadeiro, a menos que a sua "
"classe defina um método :meth:`~object.__bool__` que retorne ``False`` ou um "
"método :meth:`~object.__len__` que retorne zero, quando chamado com o "
"objeto. [1]_ Se um dos métodos levantar uma exceção quando chamado, a "
"exceção é propagada e o objeto não tem um valor verdadeiro (por exemplo, :"
"data:`NotImplemented`). Aqui estão a maioria dos objetos integrados "
"considerados falsos:"

#: ../../builtins/stdtypes.rst:58
msgid "constants defined to be false: ``None`` and ``False``"
msgstr "constantes definidas para serem falsas: ``None`` e ``False``"

#: ../../builtins/stdtypes.rst:60
msgid ""
"zero of any numeric type: ``0``, ``0.0``, ``0j``, ``Decimal(0)``, "
"``Fraction(0, 1)``"
msgstr ""
"zero de qualquer tipo numérico: ``0``, ``0.0``, ``0j``, ``Decimal(0)``, "
"``Fraction(0, 1)``"

#: ../../builtins/stdtypes.rst:63
msgid ""
"empty sequences and collections: ``''``, ``()``, ``[]``, ``{}``, ``set()``, "
"``range(0)``"
msgstr ""
"sequências e coleções vazias: ``''``, ``()``, ``[]``, ``{}``, ``set()``, "
"``range(0)``"

#: ../../builtins/stdtypes.rst:72
msgid ""
"Operations and built-in functions that have a Boolean result always return "
"``0`` or ``False`` for false and ``1`` or ``True`` for true, unless "
"otherwise stated. (Important exception: the Boolean operations ``or`` and "
"``and`` always return one of their operands.)"
msgstr ""
"Operações e funções embutidas que têm um resultado Booleano retornam ``0`` "
"ou ``False`` para falso e ``1`` ou ``True`` para verdadeiro, salvo "
"indicações ao contrário. (Exceção importante: as operações Booleanas ``or`` "
"e ``and`` sempre retornam um de seus operandos.)"

#: ../../builtins/stdtypes.rst:81
msgid "Boolean Operations --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not`"
msgstr ""
"Operações booleanas --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not`"

#: ../../builtins/stdtypes.rst:85
msgid "These are the Boolean operations, ordered by ascending priority:"
msgstr "Esses são as operações booleanas, ordenados por prioridade ascendente:"

#: ../../builtins/stdtypes.rst:88 ../../builtins/stdtypes.rst:146
#: ../../builtins/stdtypes.rst:292 ../../builtins/stdtypes.rst:382
#: ../../builtins/stdtypes.rst:432 ../../builtins/stdtypes.rst:1289
#: ../../builtins/stdtypes.rst:1513
msgid "Operation"
msgstr "Operação"

#: ../../builtins/stdtypes.rst:88 ../../builtins/stdtypes.rst:292
#: ../../builtins/stdtypes.rst:382 ../../builtins/stdtypes.rst:432
#: ../../builtins/stdtypes.rst:1289 ../../builtins/stdtypes.rst:1513
msgid "Result"
msgstr "Resultado"

#: ../../builtins/stdtypes.rst:88 ../../builtins/stdtypes.rst:292
#: ../../builtins/stdtypes.rst:432 ../../builtins/stdtypes.rst:1289
#: ../../builtins/stdtypes.rst:1513 ../../builtins/stdtypes.rst:3484
#: ../../builtins/stdtypes.rst:4786
msgid "Notes"
msgstr "Notas"

#: ../../builtins/stdtypes.rst:90
msgid "``x or y``"
msgstr "``x or y``"

#: ../../builtins/stdtypes.rst:90
msgid "if *x* is true, then *x*, else *y*"
msgstr "se *x* é true, então *x*, do contrário *y*"

#: ../../builtins/stdtypes.rst:90 ../../builtins/stdtypes.rst:1291
#: ../../builtins/stdtypes.rst:1294 ../../builtins/stdtypes.rst:1528
#: ../../builtins/stdtypes.rst:3490 ../../builtins/stdtypes.rst:4792
msgid "\\(1)"
msgstr "\\(1)"

#: ../../builtins/stdtypes.rst:93
msgid "``x and y``"
msgstr "``x and y``"

#: ../../builtins/stdtypes.rst:93
msgid "if *x* is false, then *x*, else *y*"
msgstr "se *x* é falso, então *x*, do contrário *y*"

#: ../../builtins/stdtypes.rst:93 ../../builtins/stdtypes.rst:305
#: ../../builtins/stdtypes.rst:325 ../../builtins/stdtypes.rst:1539
#: ../../builtins/stdtypes.rst:3494 ../../builtins/stdtypes.rst:3496
#: ../../builtins/stdtypes.rst:4796 ../../builtins/stdtypes.rst:4798
msgid "\\(2)"
msgstr "\\(2)"

#: ../../builtins/stdtypes.rst:96
msgid "``not x``"
msgstr "``not x``"

#: ../../builtins/stdtypes.rst:96
msgid "if *x* is false, then ``True``, else ``False``"
msgstr "se *x* é falso, então ``True``, caso contrário ``False``"

#: ../../builtins/stdtypes.rst:96 ../../builtins/stdtypes.rst:3498
#: ../../builtins/stdtypes.rst:3500 ../../builtins/stdtypes.rst:3502
#: ../../builtins/stdtypes.rst:3504 ../../builtins/stdtypes.rst:4800
#: ../../builtins/stdtypes.rst:4802 ../../builtins/stdtypes.rst:4804
#: ../../builtins/stdtypes.rst:4806
msgid "\\(3)"
msgstr "\\(3)"

#: ../../builtins/stdtypes.rst:105 ../../builtins/stdtypes.rst:336
#: ../../builtins/stdtypes.rst:450 ../../builtins/stdtypes.rst:1333
#: ../../builtins/stdtypes.rst:1543 ../../builtins/stdtypes.rst:3534
#: ../../builtins/stdtypes.rst:4836
msgid "Notes:"
msgstr "Notas:"

#: ../../builtins/stdtypes.rst:108
msgid ""
"This is a short-circuit operator, so it only evaluates the second argument "
"if the first one is false."
msgstr ""
"Esse é um operador de curto-circuito, por isso só avalia o segundo argumento "
"se o primeiro é falso."

#: ../../builtins/stdtypes.rst:112
msgid ""
"This is a short-circuit operator, so it only evaluates the second argument "
"if the first one is true."
msgstr ""
"Este é um operador de curto-circuito, por isso só avalia o segundo argumento "
"se o primeiro é verdadeiro."

#: ../../builtins/stdtypes.rst:116
msgid ""
"``not`` has a lower priority than non-Boolean operators, so ``not a == b`` "
"is interpreted as ``not (a == b)``, and ``a == not b`` is a syntax error."
msgstr ""
"``not`` tem uma prioridade mais baixa do que operadores não booleanos, então "
"``not a == b`` é interpretado como ``not (a == b)`` e ``a == not b`` é um "
"erro de sintaxe."

#: ../../builtins/stdtypes.rst:123
msgid "Comparisons"
msgstr "Comparações"

#: ../../builtins/stdtypes.rst:137
msgid ""
"There are eight comparison operations in Python.  They all have the same "
"priority (which is higher than that of the Boolean operations).  Comparisons "
"can be chained arbitrarily; for example, ``x < y <= z`` is equivalent to ``x "
"< y and y <= z``, except that *y* is evaluated only once (but in both cases "
"*z* is not evaluated at all when ``x < y`` is found to be false)."
msgstr ""
"Há oito operadores comparativos no Python. Todos eles possuem a mesma "
"prioridade (que é maior do que aquela das operações Booleanas). Comparações "
"podem ser encadeadas arbitrariamente; por exemplo, ``x < y <= z`` é "
"equivalente a ``x < y and y <= z``, exceto que *y* é avaliado apenas uma vez "
"(porém em ambos os casos *z* não é avaliado de todo quando ``x < y`` é "
"sabido ser falso)."

#: ../../builtins/stdtypes.rst:143
msgid "This table summarizes the comparison operations:"
msgstr "Esta tabela resume as operações de comparação:"

#: ../../builtins/stdtypes.rst:146 ../../builtins/stdtypes.rst:3461
#: ../../builtins/stdtypes.rst:3484 ../../builtins/stdtypes.rst:4763
#: ../../builtins/stdtypes.rst:4786
msgid "Meaning"
msgstr "Significado"

#: ../../builtins/stdtypes.rst:148
msgid "``<``"
msgstr "``<``"

#: ../../builtins/stdtypes.rst:148
msgid "strictly less than"
msgstr "estritamente menor que"

#: ../../builtins/stdtypes.rst:150
msgid "``<=``"
msgstr "``<=``"

#: ../../builtins/stdtypes.rst:150
msgid "less than or equal"
msgstr "menor que ou igual"

#: ../../builtins/stdtypes.rst:152
msgid "``>``"
msgstr "``>``"

#: ../../builtins/stdtypes.rst:152
msgid "strictly greater than"
msgstr "estritamente maior que"

#: ../../builtins/stdtypes.rst:154
msgid "``>=``"
msgstr "``>=``"

#: ../../builtins/stdtypes.rst:154
msgid "greater than or equal"
msgstr "maior que ou igual"

#: ../../builtins/stdtypes.rst:156
msgid "``==``"
msgstr "``==``"

#: ../../builtins/stdtypes.rst:156
msgid "equal"
msgstr "igual"

#: ../../builtins/stdtypes.rst:158
msgid "``!=``"
msgstr "``!=``"

#: ../../builtins/stdtypes.rst:158
msgid "not equal"
msgstr "não é igual"

#: ../../builtins/stdtypes.rst:160
msgid "``is``"
msgstr "``is``"

#: ../../builtins/stdtypes.rst:160
msgid "object identity"
msgstr "identidade do objeto"

#: ../../builtins/stdtypes.rst:162
msgid "``is not``"
msgstr "``is not``"

#: ../../builtins/stdtypes.rst:162
msgid "negated object identity"
msgstr "identidade de objeto negada"

#: ../../builtins/stdtypes.rst:169
msgid ""
"Unless stated otherwise, objects of different types never compare equal. The "
"``==`` operator is always defined but for some object types (for example, "
"class objects) is equivalent to :keyword:`is`. The ``<``, ``<=``, ``>`` and "
"``>=`` operators are only defined where they make sense; for example, they "
"raise a :exc:`TypeError` exception when one of the arguments is a complex "
"number."
msgstr ""
"Salvo indicação em contrário, objetos de tipos diferentes nunca são "
"comparados como iguais. O operador ``==`` é sempre definido, mas para alguns "
"tipos de objetos (por exemplo, objetos de classe) é equivalente a :keyword:"
"`is`. Os operadores ``<``, ``<=``, ``>`` e ``>=`` só são definidos onde "
"fazem sentido; por exemplo, eles levantam uma exceção :exc:`TypeError` "
"quando um dos argumentos é um número complexo."

#: ../../builtins/stdtypes.rst:183
msgid ""
"Non-identical instances of a class normally compare as non-equal unless the "
"class defines the :meth:`~object.__eq__` method."
msgstr ""
"Instâncias não idênticas de uma classe normalmente comparam-se como "
"desiguais ao menos que a classe defina o método :meth:`~object.__eq__`."

#: ../../builtins/stdtypes.rst:186
msgid ""
"Instances of a class cannot be ordered with respect to other instances of "
"the same class, or other types of object, unless the class defines enough of "
"the methods :meth:`~object.__lt__`, :meth:`~object.__le__`, :meth:`~object."
"__gt__`, and :meth:`~object.__ge__` (in general, :meth:`~object.__lt__` and :"
"meth:`~object.__eq__` are sufficient, if you want the conventional meanings "
"of the comparison operators)."
msgstr ""
"Instâncias de uma classe não podem ser ordenadas com respeito a outras "
"instâncias da mesma classe, ou outros tipos de objeto, ao menos que a classe "
"defina o suficiente dos métodos :meth:`~object.__lt__`, :meth:`~object."
"__le__`, :meth:`~object.__gt__` e :meth:`~object.__ge__` (no geral, :meth:"
"`~object.__lt__` e :meth:`~object.__eq__` são suficientes, se você quiser o "
"significado convencional dos operadores de comparação)."

#: ../../builtins/stdtypes.rst:193
msgid ""
"The behavior of the :keyword:`is` and :keyword:`is not` operators cannot be "
"customized; also they can be applied to any two objects and never raise an "
"exception."
msgstr ""
"O comportamento dos operadores :keyword:`is` e :keyword:`is not` não pode "
"ser personalizado; além disso eles podem ser aplicados a quaisquer dois "
"objetos e nunca levantam uma exceção."

#: ../../builtins/stdtypes.rst:201
msgid ""
"Two more operations with the same syntactic priority, :keyword:`in` and :"
"keyword:`not in`, are supported by types that are :term:`iterable` or "
"implement the :meth:`~object.__contains__` method."
msgstr ""
"Mais duas operações com a mesma prioridade sintática, :keyword:`in` e :"
"keyword:`not in`, são suportadas por tipos que são :term:`iteráveis "
"<iterável>` ou implementam o método :meth:`~object.__contains__`."

#: ../../builtins/stdtypes.rst:208
msgid "Numeric Types --- :class:`int`, :class:`float`, :class:`complex`"
msgstr "Tipos numéricos --- :class:`int`, :class:`float`, :class:`complex`"

#: ../../builtins/stdtypes.rst:218
msgid ""
"There are three distinct numeric types: :dfn:`integers`, :dfn:`floating-"
"point numbers`, and :dfn:`complex numbers`.  In addition, Booleans are a "
"subtype of integers.  Integers have unlimited precision.  Floating-point "
"numbers are usually implemented using :c:expr:`double` in C; information "
"about the precision and internal representation of floating-point numbers "
"for the machine on which your program is running is available in :data:`sys."
"float_info`.  Complex numbers have a real and imaginary part, which are each "
"a floating-point number.  To extract these parts from a complex number *z*, "
"use ``z.real`` and ``z.imag``. (The standard library includes the additional "
"numeric types :mod:`fractions.Fraction`, for rationals, and :mod:`decimal."
"Decimal`, for floating-point numbers with user-definable precision.)"
msgstr ""
"Existem três tipos numéricos distintos: :dfn:`inteiros`, :dfn:`números de "
"ponto flutuante` e :dfn:`números complexos`. Além disso, os booleanos são um "
"subtipo de números inteiros. Inteiros têm precisão ilimitada. Números de "
"ponto flutuante são geralmente implementados usando :c:expr:`double` em C; "
"informações sobre a precisão e representação interna dos números de ponto "
"flutuante para a máquina na qual seu programa está sendo executado estão "
"disponíveis em :data:`sys.float_info`. Números complexos têm uma parte real "
"e imaginária, cada um com um número de ponto flutuante. Para extrair essas "
"partes de um número complexo *z*, use ``z.real`` e ``z.imag``. (A biblioteca "
"padrão inclui os tipos numéricos adicionais :mod:`fractions.Fraction`, para "
"racionais, e :mod:`decimal.Decimal`, para números de ponto flutuante com "
"precisão definida pelo usuário.)"

#: ../../builtins/stdtypes.rst:240
msgid ""
"Numbers are created by numeric literals or as the result of built-in "
"functions and operators.  Unadorned integer literals (including hex, octal "
"and binary numbers) yield integers.  Numeric literals containing a decimal "
"point or an exponent sign yield floating-point numbers.  Appending ``'j'`` "
"or ``'J'`` to a numeric literal yields an imaginary number (a complex number "
"with a zero real part) which you can add to an integer or float to get a "
"complex number with real and imaginary parts."
msgstr ""
"Números são criados por literais numéricos ou como resultado de operadores e "
"funções embutidas. Integrais literais planos (incluindo números "
"hexadecimais, octais e binários) culminam em integrais. Literais numéricos "
"contendo um ponto decimal ou um sinal exponencial resultam em números de "
"ponto flutuante. Anexando ``'j'`` ou ``'J'`` para um literal numérico "
"resulta em um número imaginário (um número complexo com uma parte real zero) "
"com a qual você pode adicionar a um integral ou flutuante para receber um "
"número complexo com partes reais e imaginárias."

#: ../../builtins/stdtypes.rst:248
msgid ""
"The constructors :func:`int`, :func:`float`, and :func:`complex` can be used "
"to produce numbers of a specific type."
msgstr ""
"Os construtores :func:`int`, :func:`float`, e :func:`complex` podem ser "
"usados para produzir números de um tipo específico."

#: ../../builtins/stdtypes.rst:270
msgid ""
"Python fully supports mixed arithmetic: when a binary arithmetic operator "
"has operands of different built-in numeric types, the operand with the "
"\"narrower\" type is widened to that of the other:"
msgstr ""
"Python oferece suporte completo a aritmética mista: quando um operador de "
"aritmética binária tem operandos de tipos numéricos embutidos diferentes, o "
"operando com o tipo \"mais estreito\" é ampliado para o tipo do outro "
"operando."

#: ../../builtins/stdtypes.rst:274
msgid "If both arguments are complex numbers, no conversion is performed;"
msgstr ""
"Se ambos os argumentos forem números complexos, nenhuma conversão será "
"realizada;"

#: ../../builtins/stdtypes.rst:275
msgid ""
"if either argument is a complex or a floating-point number, the other is "
"converted to a floating-point number;"
msgstr ""
"se qualquer argumento for um número complexo ou de ponto flutuante, o outro "
"será convertido em um número de ponto flutuante;"

#: ../../builtins/stdtypes.rst:277
msgid "otherwise, both must be integers and no conversion is necessary."
msgstr ""
"caso contrário, ambos devem ser inteiros e nenhuma conversão é necessária."

#: ../../builtins/stdtypes.rst:279
msgid ""
"Arithmetic with complex and real operands is defined by the usual "
"mathematical formula, for example::"
msgstr ""
"A aritmética com operandos complexos e reais é definida pela fórmula "
"matemática usual, por exemplo::"

#: ../../builtins/stdtypes.rst:282
msgid ""
"x + complex(u, v) = complex(x + u, v)\n"
"x * complex(u, v) = complex(x * u, x * v)"
msgstr ""
"x + complex(u, v) = complex(x + u, v)\n"
"x * complex(u, v) = complex(x * u, x * v)"

#: ../../builtins/stdtypes.rst:285
msgid ""
"A comparison between numbers of different types behaves as though the exact "
"values of those numbers were being compared. [2]_"
msgstr ""
"Uma comparação entre números de tipos diferentes se comporta como se os "
"valores exatos desses números estivessem sendo comparados. [2]_"

#: ../../builtins/stdtypes.rst:288
msgid ""
"All numeric types (except complex) support the following operations (for "
"priorities of the operations, see :ref:`operator-summary`):"
msgstr ""
"Todos os tipos numéricos (exceto complexos) suportam as seguintes operações "
"(para prioridades das operações, consulte :ref:`operator-summary`):"

#: ../../builtins/stdtypes.rst:292
msgid "Full documentation"
msgstr "Documentação completa"

#: ../../builtins/stdtypes.rst:294
msgid "``x + y``"
msgstr "``x + y``"

#: ../../builtins/stdtypes.rst:294
msgid "sum of *x* and *y*"
msgstr "soma de *x* e *y*"

#: ../../builtins/stdtypes.rst:296
msgid "``x - y``"
msgstr "``x - y``"

#: ../../builtins/stdtypes.rst:296
msgid "difference of *x* and *y*"
msgstr "diferença de *x* e *y*"

#: ../../builtins/stdtypes.rst:298
msgid "``x * y``"
msgstr "``x * y``"

#: ../../builtins/stdtypes.rst:298
msgid "product of *x* and *y*"
msgstr "produto de *x* e *y*"

#: ../../builtins/stdtypes.rst:300
msgid "``x / y``"
msgstr "``x / y``"

#: ../../builtins/stdtypes.rst:300
msgid "quotient of *x* and *y*"
msgstr "quociente de *x* e *y*"

#: ../../builtins/stdtypes.rst:302
msgid "``x // y``"
msgstr "``x // y``"

#: ../../builtins/stdtypes.rst:302
msgid "floored quotient of *x* and *y*"
msgstr "piso do quociente de *x* e *y*"

#: ../../builtins/stdtypes.rst:302
msgid "\\(1)\\(2)"
msgstr "\\(1)\\(2)"

#: ../../builtins/stdtypes.rst:305
msgid "``x % y``"
msgstr "``x % y``"

#: ../../builtins/stdtypes.rst:305
msgid "remainder of ``x / y``"
msgstr "restante de ``x / y``"

#: ../../builtins/stdtypes.rst:307
msgid "``-x``"
msgstr "``-x``"

#: ../../builtins/stdtypes.rst:307
msgid "*x* negated"
msgstr "*x* negado"

#: ../../builtins/stdtypes.rst:309
msgid "``+x``"
msgstr "``+x``"

#: ../../builtins/stdtypes.rst:309
msgid "*x* unchanged"
msgstr "*x* inalterado"

#: ../../builtins/stdtypes.rst:311
msgid "``abs(x)``"
msgstr "``abs(x)``"

#: ../../builtins/stdtypes.rst:311
msgid "absolute value or magnitude of *x*"
msgstr "valor absoluto ou magnitude de *x*"

#: ../../builtins/stdtypes.rst:311
msgid ":func:`abs`"
msgstr ":func:`abs`"

#: ../../builtins/stdtypes.rst:314
msgid "``int(x)``"
msgstr "``int(x)``"

#: ../../builtins/stdtypes.rst:314
msgid "*x* converted to integer"
msgstr "*x* convertido em inteiro"

#: ../../builtins/stdtypes.rst:314
msgid "\\(3)\\(6)"
msgstr "\\(3)\\(6)"

#: ../../builtins/stdtypes.rst:314
msgid ":func:`int`"
msgstr ":func:`int`"

#: ../../builtins/stdtypes.rst:316
msgid "``float(x)``"
msgstr "``float(x)``"

#: ../../builtins/stdtypes.rst:316
msgid "*x* converted to floating point"
msgstr "*x* convertido em ponto flutuante"

#: ../../builtins/stdtypes.rst:316
msgid "\\(4)\\(6)"
msgstr "\\(4)\\(6)"

#: ../../builtins/stdtypes.rst:316
msgid ":func:`float`"
msgstr ":func:`float`"

#: ../../builtins/stdtypes.rst:318
msgid "``complex(re, im)``"
msgstr "``complex(re, im)``"

#: ../../builtins/stdtypes.rst:318
msgid ""
"a complex number with real part *re*, imaginary part *im*. *im* defaults to "
"zero."
msgstr ""
"um número complexo com parte real *re*, parte imaginária *im*. *im* tem como "
"padrão zero."

#: ../../builtins/stdtypes.rst:318 ../../builtins/stdtypes.rst:3492
#: ../../builtins/stdtypes.rst:4823
msgid "\\(6)"
msgstr "\\(6)"

#: ../../builtins/stdtypes.rst:318
msgid ":func:`complex`"
msgstr ":func:`complex`"

#: ../../builtins/stdtypes.rst:322
msgid "``c.conjugate()``"
msgstr "``c.conjugate()``"

#: ../../builtins/stdtypes.rst:322
msgid "conjugate of the complex number *c*"
msgstr "conjugado do número complexo *c*"

#: ../../builtins/stdtypes.rst:325
msgid "``divmod(x, y)``"
msgstr "``divmod(x, y)``"

#: ../../builtins/stdtypes.rst:325
msgid "the pair ``(x // y, x % y)``"
msgstr "o par ``(x // y, x % y)``"

#: ../../builtins/stdtypes.rst:325
msgid ":func:`divmod`"
msgstr ":func:`divmod`"

#: ../../builtins/stdtypes.rst:327
msgid "``pow(x, y)``"
msgstr "``pow(x, y)``"

#: ../../builtins/stdtypes.rst:327 ../../builtins/stdtypes.rst:329
msgid "*x* to the power *y*"
msgstr "*x* elevado a *y*"

#: ../../builtins/stdtypes.rst:327 ../../builtins/stdtypes.rst:329
#: ../../builtins/stdtypes.rst:3517 ../../builtins/stdtypes.rst:3520
#: ../../builtins/stdtypes.rst:3523 ../../builtins/stdtypes.rst:4819
#: ../../builtins/stdtypes.rst:4826
msgid "\\(5)"
msgstr "\\(5)"

#: ../../builtins/stdtypes.rst:327
msgid ":func:`pow`"
msgstr ":func:`pow`"

#: ../../builtins/stdtypes.rst:329
msgid "``x ** y``"
msgstr "``x ** y``"

#: ../../builtins/stdtypes.rst:339
msgid ""
"Also referred to as integer division.  For operands of type :class:`int`, "
"the result has type :class:`int`.  For operands of type :class:`float`, the "
"result has type :class:`float`.  In general, the result is a whole integer, "
"though the result's type is not necessarily :class:`int`.  The result is "
"always rounded towards minus infinity: ``1//2`` is ``0``, ``(-1)//2`` is "
"``-1``, ``1//(-2)`` is ``-1``, and ``(-1)//(-2)`` is ``0``."
msgstr ""
"Também referido como uma divisão inteira. Para operandos do tipo :class:"
"`int`, o resultado tem o tipo :class:`int`; Para operandos do tipo :class:"
"`float`, o resultado tem o tipo :class:`float`. Em geral o resultado é "
"inteiro como todo, apesar do tipo do resultado não necessariamente ser :"
"class:`int`. O resultado é sempre arredondado para menos infinito: ``1//2`` "
"é ``0``, ``(-1)//2`` é ``-1``, ``1//(-2)`` é ``-1`` e ``(-1)//(-2)`` é ``0``."

#: ../../builtins/stdtypes.rst:347
msgid ""
"Not for complex numbers.  Instead convert to floats using :func:`abs` if "
"appropriate."
msgstr ""
"Não para números complexos. Ao invés disso, converte para pontos flutuantes "
"usando :func:`abs` se for apropriado."

#: ../../builtins/stdtypes.rst:358
msgid ""
"Conversion from :class:`float` to :class:`int` truncates, discarding the "
"fractional part. See functions :func:`math.floor` and :func:`math.ceil` for "
"alternative conversions."
msgstr ""
"Conversão de :class:`float` para :class:`int` trunca, descartando a parte "
"fracionária. Veja as funções :func:`math.floor` e :func:`math.ceil` para "
"conversões alternativas."

#: ../../builtins/stdtypes.rst:363
msgid ""
"float also accepts the strings \"nan\" and \"inf\" with an optional prefix "
"\"+\" or \"-\" for Not a Number (NaN) and positive or negative infinity."
msgstr ""
"ponto flutuante também aceita a string \"nan\" e \"inf\" com um prefixo "
"opcional \"+\" ou \"-\" a Não é um Número (NaN) e infinidade positiva ou "
"negativa."

#: ../../builtins/stdtypes.rst:367
msgid ""
"Python defines ``pow(0, 0)`` and ``0 ** 0`` to be ``1``, as is common for "
"programming languages."
msgstr ""
"Python define ``pow(0, 0)`` e ``0 ** 0`` sendo ``1``, como é comum para "
"linguagens de programação."

#: ../../builtins/stdtypes.rst:371
msgid ""
"The numeric literals accepted include the digits ``0`` to ``9`` or any "
"Unicode equivalent (code points with the ``Nd`` property)."
msgstr ""
"Os literais numéricos aceitos incluem os dígitos de ``0`` a ``9`` ou "
"qualquer equivalente Unicode (pontos de código com a propriedade ``Nd``)."

#: ../../builtins/stdtypes.rst:374
msgid ""
"See `the Unicode Standard <https://unicode.org/Public/UNIDATA/extracted/"
"DerivedNumericType.txt>`_ for a complete list of code points with the ``Nd`` "
"property."
msgstr ""
"Veja `o Unicode Standard <https://unicode.org/Public/UNIDATA/extracted/"
"DerivedNumericType.txt>`_ para obter uma lista completa de pontos de código "
"com a propriedade ``Nd``."

#: ../../builtins/stdtypes.rst:378
msgid ""
"All :class:`numbers.Real` types (:class:`int` and :class:`float`) also "
"include the following operations:"
msgstr ""
"Todos os tipos :class:`numbers.Real` (:class:`int` e :class:`float`) também "
"incluem as seguintes operações."

#: ../../builtins/stdtypes.rst:384
msgid ":func:`math.trunc(\\ x) <math.trunc>`"
msgstr ":func:`math.trunc(\\ x) <math.trunc>`"

#: ../../builtins/stdtypes.rst:384
msgid "*x* truncated to :class:`~numbers.Integral`"
msgstr "*x* truncado para :class:`~numbers.Integral`"

#: ../../builtins/stdtypes.rst:387
msgid ":func:`round(x[, n]) <round>`"
msgstr ":func:`round(x[, n]) <round>`"

#: ../../builtins/stdtypes.rst:387
msgid ""
"*x* rounded to *n* digits, rounding half to even. If *n* is omitted, it "
"defaults to 0."
msgstr ""
"*x* arredondado para *n* dígitos, arredondando metade para igualar. Se *n* é "
"omitido, ele toma o padrão de 0."

#: ../../builtins/stdtypes.rst:391
msgid ":func:`math.floor(\\ x) <math.floor>`"
msgstr ":func:`math.floor(\\ x) <math.floor>`"

#: ../../builtins/stdtypes.rst:391
msgid "the greatest :class:`~numbers.Integral` <= *x*"
msgstr "o maior :class:`~numbers.Integral` <= *x*"

#: ../../builtins/stdtypes.rst:394
msgid ":func:`math.ceil(x) <math.ceil>`"
msgstr ":func:`math.ceil(x) <math.ceil>`"

#: ../../builtins/stdtypes.rst:394
msgid "the least :class:`~numbers.Integral` >= *x*"
msgstr "pelo menos :class:`~numbers.Integral` >= *x*"

#: ../../builtins/stdtypes.rst:398
msgid ""
"For additional numeric operations see the :mod:`math` and :mod:`cmath` "
"modules."
msgstr ""
"Para operações numéricas adicionais, consulte os módulos :mod:`math` e :mod:"
"`cmath`."

#: ../../builtins/stdtypes.rst:407
msgid "Bitwise Operations on Integer Types"
msgstr "Operações de bits em tipos inteiros"

#: ../../builtins/stdtypes.rst:421
msgid ""
"Bitwise operations only make sense for integers. The result of bitwise "
"operations is calculated as though carried out in two's complement with an "
"infinite number of sign bits."
msgstr ""
"Operações bit a bit só fazem sentido para números inteiros. O resultado de "
"operações bit a bit é calculado como se fosse realizado no complemento de "
"dois com um número infinito de bits de sinal."

#: ../../builtins/stdtypes.rst:425
msgid ""
"The priorities of the binary bitwise operations are all lower than the "
"numeric operations and higher than the comparisons; the unary operation "
"``~`` has the same priority as the other unary numeric operations (``+`` and "
"``-``)."
msgstr ""
"As prioridades das operações bit a bit binárias são todas menores do que as "
"operações numéricas e maiores que as comparações; a operação unária ``~`` "
"tem a mesma prioridade que as outras operações numéricas unárias (``+`` e ``-"
"``)."

#: ../../builtins/stdtypes.rst:429
msgid "This table lists the bitwise operations sorted in ascending priority:"
msgstr ""
"Esta tabela lista as operações de bits classificadas em prioridade "
"ascendente:"

#: ../../builtins/stdtypes.rst:434
msgid "``x | y``"
msgstr "``x | y``"

#: ../../builtins/stdtypes.rst:434
msgid "bitwise :dfn:`or` of *x* and *y*"
msgstr ":dfn:`ou` bit a bit de *x* e *y*"

#: ../../builtins/stdtypes.rst:434 ../../builtins/stdtypes.rst:437
#: ../../builtins/stdtypes.rst:440 ../../builtins/stdtypes.rst:3506
#: ../../builtins/stdtypes.rst:3510 ../../builtins/stdtypes.rst:4808
#: ../../builtins/stdtypes.rst:4812
msgid "\\(4)"
msgstr "\\(4)"

#: ../../builtins/stdtypes.rst:437
msgid "``x ^ y``"
msgstr "``x ^ y``"

#: ../../builtins/stdtypes.rst:437
msgid "bitwise :dfn:`exclusive or` of *x* and *y*"
msgstr ":dfn:`ou exclusivo` bit a bit de *x* e *y*"

#: ../../builtins/stdtypes.rst:440
msgid "``x & y``"
msgstr "``x & y``"

#: ../../builtins/stdtypes.rst:440
msgid "bitwise :dfn:`and` of *x* and *y*"
msgstr ":dfn:`e` bit a bit de *x* e *y*"

#: ../../builtins/stdtypes.rst:443
msgid "``x << n``"
msgstr "``x << n``"

#: ../../builtins/stdtypes.rst:443
msgid "*x* shifted left by *n* bits"
msgstr "*x* deslocado para a esquerda por *n* bits"

#: ../../builtins/stdtypes.rst:443
msgid "(1)(2)"
msgstr "(1)(2)"

#: ../../builtins/stdtypes.rst:445
msgid "``x >> n``"
msgstr "``x >> n``"

#: ../../builtins/stdtypes.rst:445
msgid "*x* shifted right by *n* bits"
msgstr "*x* deslocado para a direita por *n* bits"

#: ../../builtins/stdtypes.rst:445
msgid "(1)(3)"
msgstr "(1)(3)"

#: ../../builtins/stdtypes.rst:447
msgid "``~x``"
msgstr "``~x``"

#: ../../builtins/stdtypes.rst:447
msgid "the bits of *x* inverted"
msgstr "os bits de *x* invertidos"

#: ../../builtins/stdtypes.rst:453
msgid ""
"Negative shift counts are illegal and cause a :exc:`ValueError` to be raised."
msgstr ""
"Contagens de deslocamento negativo são ilegais e levantam uma :exc:"
"`ValueError` ."

#: ../../builtins/stdtypes.rst:456
msgid ""
"A left shift by *n* bits is equivalent to multiplication by ``pow(2, n)``."
msgstr ""
"Um deslocamento à esquerda por *n* bits é equivalente à multiplicação por "
"``pow(2, n)``."

#: ../../builtins/stdtypes.rst:459
msgid ""
"A right shift by *n* bits is equivalent to floor division by ``pow(2, n)``."
msgstr ""
"Um deslocamento à direita por *n* bits é equivalente à divisão pelo piso por "
"``pow(2, n)``."

#: ../../builtins/stdtypes.rst:462
msgid ""
"Performing these calculations with at least one extra sign extension bit in "
"a finite two's complement representation (a working bit-width of ``1 + max(x."
"bit_length(), y.bit_length())`` or more) is sufficient to get the same "
"result as if there were an infinite number of sign bits."
msgstr ""
"Executar esses cálculos com pelo menos um bit extra de extensão de sinal na "
"representação de complemento de dois finitos (uma largura de bit de trabalho "
"``1 + max(x.bit_length(), y.bit_length())`` ou mais) é suficiente para obter "
"o mesmo resultado como se houvesse um número infinito de bits de sinal."

#: ../../builtins/stdtypes.rst:469
msgid "Additional Methods on Integer Types"
msgstr "Métodos adicionais em tipos inteiros"

#: ../../builtins/stdtypes.rst:471
msgid ""
"The int type implements the :class:`numbers.Integral` :term:`abstract base "
"class`. In addition, it provides a few more methods:"
msgstr ""
"O tipo int implementa a :term:`classe base abstrata` :class:`numbers."
"Integral`. Além disso, ele provê mais alguns métodos:"

#: ../../builtins/stdtypes.rst:476
msgid ""
"Return the number of bits necessary to represent an integer in binary, "
"excluding the sign and leading zeros::"
msgstr ""
"Retorna o número de bits necessários para representar um inteiro em binário, "
"excluindo o sinal e entrelinha zeros::"

#: ../../builtins/stdtypes.rst:479
msgid ""
">>> n = -37\n"
">>> bin(n)\n"
"'-0b100101'\n"
">>> n.bit_length()\n"
"6"
msgstr ""
">>> n = -37\n"
">>> bin(n)\n"
"'-0b100101'\n"
">>> n.bit_length()\n"
"6"

#: ../../builtins/stdtypes.rst:485
msgid ""
"More precisely, if ``x`` is nonzero, then ``x.bit_length()`` is the unique "
"positive integer ``k`` such that ``2**(k-1) <= abs(x) < 2**k``. "
"Equivalently, when ``abs(x)`` is small enough to have a correctly rounded "
"logarithm, then ``k = 1 + int(log(abs(x), 2))``. If ``x`` is zero, then ``x."
"bit_length()`` returns ``0``."
msgstr ""
"Mais precisamente, se ``x`` for diferente de zero, então ``x.bit_length()`` "
"é o único positivo inteiro ``k`` tal que ``2**(k-1) <= abs(x) < 2**k``. "
"Equivalentemente, quando ``abs(x)`` for pequeno o suficiente para ter um "
"logaritmo corretamente arrendondado, então ``k = 1 + int(log(abs(x), 2))``. "
"Se ``x`` é zero, então ``x.bit_length()`` retorna ``0``."

#: ../../builtins/stdtypes.rst:491 ../../builtins/stdtypes.rst:514
#: ../../builtins/stdtypes.rst:559 ../../builtins/stdtypes.rst:603
msgid "Equivalent to::"
msgstr "Equivalente a::"

#: ../../builtins/stdtypes.rst:493
msgid ""
"def bit_length(self):\n"
"    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'\n"