# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2025, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # # Translators: # python-doc bot, 2025 # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.11\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2025-09-22 20:37+0000\n" "PO-Revision-Date: 2025-09-22 16:51+0000\n" "Last-Translator: python-doc bot, 2025\n" "Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/" "teams/5390/pt_BR/)\n" "Language: pt_BR\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % " "1000000 == 0 ? 1 : 2;\n" #: ../../tutorial/floatingpoint.rst:9 msgid "Floating Point Arithmetic: Issues and Limitations" msgstr "Aritmética de ponto flutuante: problemas e limitações" #: ../../tutorial/floatingpoint.rst:14 msgid "" "Floating-point numbers are represented in computer hardware as base 2 " "(binary) fractions. For example, the **decimal** fraction ``0.125`` has " "value 1/10 + 2/100 + 5/1000, and in the same way the **binary** fraction " "``0.001`` has value 0/2 + 0/4 + 1/8. These two fractions have identical " "values, the only real difference being that the first is written in base 10 " "fractional notation, and the second in base 2." msgstr "" "Os números de ponto flutuante são representados no hardware do computador " "como frações de base 2 (binárias). Por exemplo, a fração **decimal** " "``0.125`` tem valor 1/10 + 2/100 + 5/1000, e da mesma forma a fração " "**binária** ``0.001`` tem valor 0/2 + 0/4 + 1/8. Essas duas frações têm " "valores idênticos, a única diferença real é que a primeira é escrita em " "notação fracionária de base 10 e a segunda em base 2." #: ../../tutorial/floatingpoint.rst:21 msgid "" "Unfortunately, most decimal fractions cannot be represented exactly as " "binary fractions. A consequence is that, in general, the decimal floating-" "point numbers you enter are only approximated by the binary floating-point " "numbers actually stored in the machine." msgstr "" "Infelizmente, muitas frações decimais não podem ser representadas " "precisamente como frações binárias. O resultado é que, em geral, os números " "decimais de ponto flutuante que você digita acabam sendo armazenados de " "forma apenas aproximada, na forma de números binários de ponto flutuante." #: ../../tutorial/floatingpoint.rst:26 msgid "" "The problem is easier to understand at first in base 10. Consider the " "fraction 1/3. You can approximate that as a base 10 fraction::" msgstr "" "O problema é mais fácil de entender primeiro em base 10. Considere a fração " "1/3. Podemos representá-la aproximadamente como uma fração base 10::" #: ../../tutorial/floatingpoint.rst:31 ../../tutorial/floatingpoint.rst:35 msgid "or, better, ::" msgstr "ou melhor, ::" #: ../../tutorial/floatingpoint.rst:39 msgid "" "and so on. No matter how many digits you're willing to write down, the " "result will never be exactly 1/3, but will be an increasingly better " "approximation of 1/3." msgstr "" "e assim por diante. Não importa quantos dígitos você está disposto a " "escrever, o resultado nunca será exatamente 1/3, mas será uma aproximação de " "cada vez melhor de 1/3." #: ../../tutorial/floatingpoint.rst:43 msgid "" "In the same way, no matter how many base 2 digits you're willing to use, the " "decimal value 0.1 cannot be represented exactly as a base 2 fraction. In " "base 2, 1/10 is the infinitely repeating fraction ::" msgstr "" "Da mesma forma, não importa quantos dígitos de base 2 estejas disposto a " "usar, o valor decimal 0.1 não pode ser representado exatamente como uma " "fração de base 2. No sistema de base 2, 1/10 é uma fração binária que se " "repete infinitamente::" #: ../../tutorial/floatingpoint.rst:49 msgid "" "Stop at any finite number of bits, and you get an approximation. On most " "machines today, floats are approximated using a binary fraction with the " "numerator using the first 53 bits starting with the most significant bit and " "with the denominator as a power of two. In the case of 1/10, the binary " "fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly " "equal to the true value of 1/10." msgstr "" "Se parares em qualquer número finito de bits, obterás uma aproximação. Hoje " "em dia, na maioria dos computadores, as casas decimais são aproximados " "usando uma fração binária onde o numerado utiliza os primeiros 53 bits " "iniciando no bit mais significativo e tendo como denominador uma potência de " "dois. No caso de 1/10, a fração binária seria ``602879701896397 / 2 ** 55`` " "o que chega bem perto, mas mesmo assim, não é igual ao valor original de " "1/10." #: ../../tutorial/floatingpoint.rst:56 msgid "" "Many users are not aware of the approximation because of the way values are " "displayed. Python only prints a decimal approximation to the true decimal " "value of the binary approximation stored by the machine. On most machines, " "if Python were to print the true decimal value of the binary approximation " "stored for 0.1, it would have to display ::" msgstr "" "Muitos usuários não estão cientes da aproximação devido à forma como os " "valores são exibidos. O Python exibe apenas uma aproximação decimal do " "verdadeiro valor decimal da aproximação binária armazenada pela máquina. Na " "maioria das máquinas, se o Python exibisse o verdadeiro valor decimal da " "aproximação binária que representa o decimal 0.1, seria necessário mostrar:" #: ../../tutorial/floatingpoint.rst:65 msgid "" "That is more digits than most people find useful, so Python keeps the number " "of digits manageable by displaying a rounded value instead ::" msgstr "" "Isto contém muito mais dígitos do que é o esperado e utilizado pela grande " "maioria dos desenvolvedores, portanto, o Python limita o número de dígitos " "exibidos, apresentando um valor arredondado, ao invés de mostrar todas as " "casas decimais:" #: ../../tutorial/floatingpoint.rst:71 msgid "" "Just remember, even though the printed result looks like the exact value of " "1/10, the actual stored value is the nearest representable binary fraction." msgstr "" "Lembre-se, mesmo que o resultado impresso seja o valor exato de 1/10, o " "valor que verdadeiramente estará armazenado será uma fração binária " "representável que mais se aproxima." #: ../../tutorial/floatingpoint.rst:74 msgid "" "Interestingly, there are many different decimal numbers that share the same " "nearest approximate binary fraction. For example, the numbers ``0.1`` and " "``0.10000000000000001`` and " "``0.1000000000000000055511151231257827021181583404541015625`` are all " "approximated by ``3602879701896397 / 2 ** 55``. Since all of these decimal " "values share the same approximation, any one of them could be displayed " "while still preserving the invariant ``eval(repr(x)) == x``." msgstr "" "Curiosamente, existem muitos números decimais diferentes que compartilham a " "mesma fração binária aproximada. Por exemplo, os números ``0.1`` ou o " "``0.10000000000000001`` e " "``0.1000000000000000055511151231257827021181583404541015625`` são todos " "aproximações de ``3602879701896397 / 2 ** 55``. Como todos esses valores " "decimais compartilham um mesma de aproximação, qualquer um poderá ser " "exibido enquanto for preservado o invariante ``eval(repr(x)) == x``." #: ../../tutorial/floatingpoint.rst:82 msgid "" "Historically, the Python prompt and built-in :func:`repr` function would " "choose the one with 17 significant digits, ``0.10000000000000001``. " "Starting with Python 3.1, Python (on most systems) is now able to choose the " "shortest of these and simply display ``0.1``." msgstr "" "Historicamente, o prompt do Python e a função embutida :func:`repr` " "utilizariam o que contivesse 17 dígitos significativos, " "``0.10000000000000001``. Desde a versão do Python 3.1, o Python (na maioria " "dos sistemas) agora é possível optar pela forma mais reduzida, exibindo " "simplesmente o número ``0.1``." #: ../../tutorial/floatingpoint.rst:87 msgid "" "Note that this is in the very nature of binary floating-point: this is not a " "bug in Python, and it is not a bug in your code either. You'll see the same " "kind of thing in all languages that support your hardware's floating-point " "arithmetic (although some languages may not *display* the difference by " "default, or in all output modes)." msgstr "" "Note que essa é a própria natureza do ponto flutuante binário: não é um bug " "do Python, e nem é um bug do seu código. Essa situação pode ser observada em " "todas as linguagens que usam as instruções aritméticas de ponto flutuante do " "hardware (apesar de algumas linguagens não *mostrarem* a diferença, por " "padrão, ou em todos os modos de saída)." #: ../../tutorial/floatingpoint.rst:93 msgid "" "For more pleasant output, you may wish to use string formatting to produce a " "limited number of significant digits::" msgstr "" "Para obter um valor mais agradável, poderás utilizar a formatação de " "sequência de caracteres para produzir um número limitado de dígitos " "significativos:" #: ../../tutorial/floatingpoint.rst:105 msgid "" "It's important to realize that this is, in a real sense, an illusion: you're " "simply rounding the *display* of the true machine value." msgstr "" "É importante perceber que tudo não passa de pura ilusão: estas simplesmente " "arredondando a *exibição* da verdadeira maquinaria do valor." #: ../../tutorial/floatingpoint.rst:108 msgid "" "One illusion may beget another. For example, since 0.1 is not exactly 1/10, " "summing three values of 0.1 may not yield exactly 0.3, either::" msgstr "" "Uma ilusão pode gerar outra. Por exemplo, uma vez que 0.1 não é exatamente " "1/10, somar três vezes o valor 0.1, não garantirá que o resultado seja " "exatamente 0.3, isso porque:" #: ../../tutorial/floatingpoint.rst:114 msgid "" "Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 " "cannot get any closer to the exact value of 3/10, then pre-rounding with :" "func:`round` function cannot help::" msgstr "" "Inclusive, uma vez que o 0.1 não consegue aproximar-se do valor exato de " "1/10 e 0.3 não pode se aproximar mais do valor exato de 3/10, temos então " "que o pré-arredondamento com a função :func:`round` não servirá como ajuda:" #: ../../tutorial/floatingpoint.rst:121 msgid "" "Though the numbers cannot be made closer to their intended exact values, " "the :func:`round` function can be useful for post-rounding so that results " "with inexact values become comparable to one another::" msgstr "" "Embora os números não possam se aproximar mais dos exatos valores que " "desejamos, a função :func:`round` poderá ser útil na obtenção do pós-" "arredondamento para que os resultados contendo valores inexatos se tornem " "comparáveis uns aos outros:" #: ../../tutorial/floatingpoint.rst:128 msgid "" "Binary floating-point arithmetic holds many surprises like this. The " "problem with \"0.1\" is explained in precise detail below, in the " "\"Representation Error\" section. See `Examples of Floating Point Problems " "`_ for " "a pleasant summary of how binary floating-point works and the kinds of " "problems commonly encountered in practice. Also see `The Perils of Floating " "Point `_ for a more complete " "account of other common surprises." msgstr "" "A aritmética binária de ponto flutuante contém muitas surpresas como essa. O " "problema com \"0.1\" é explicado em detalhes precisos abaixo, na seção " "\"Erro de representação\". Consulte `Exemplos de problemas de ponto " "flutuante `_ (em inglês) para obter um resumo agradável de como o ponto " "flutuante binário funciona e os tipos de problemas comumente encontrados na " "prática. Veja também `Os perigos do ponto flutuante `_ (em inglês) para um relato mais completo de outras " "surpresas comuns." #: ../../tutorial/floatingpoint.rst:137 msgid "" "As that says near the end, \"there are no easy answers.\" Still, don't be " "unduly wary of floating-point! The errors in Python float operations are " "inherited from the floating-point hardware, and on most machines are on the " "order of no more than 1 part in 2\\*\\*53 per operation. That's more than " "adequate for most tasks, but you do need to keep in mind that it's not " "decimal arithmetic and that every float operation can suffer a new rounding " "error." msgstr "" "Como dizemos perto do final, \"não há respostas fáceis\". Ainda assim, não " "se percam indevidamente no uso do ponto flutuante! Os erros nas operações do " "tipo float do Python são heranças do hardware de ponto flutuante e, a " "maioria dos computadores estão na ordem de não mais do que 1 parte em " "2\\*\\*53 por operação. Isso é mais do que o suficiente para a maioria das " "tarefas, portanto, é importante lembrar que não se trata de uma aritmética " "decimal e que toda operação com o tipo float poderá via a apresentar novos " "problemas referentes ao arredondamento." #: ../../tutorial/floatingpoint.rst:144 msgid "" "While pathological cases do exist, for most casual use of floating-point " "arithmetic you'll see the result you expect in the end if you simply round " "the display of your final results to the number of decimal digits you " "expect. :func:`str` usually suffices, and for finer control see the :meth:" "`str.format` method's format specifiers in :ref:`formatstrings`." msgstr "" "Embora existam casos patológicos, na maior parte das vezes, terás como " "resultado final o valor esperado, se simplesmente arredondares a exibição " "final dos resultados para a quantidade de dígitos decimais que esperas a " "função :func:`str` geralmente será o suficiente, e , para seja necessário um " "valor refinado, veja os especificadores de formato :meth:`str.format` " "contido na seção :ref:`formatstrings`." #: ../../tutorial/floatingpoint.rst:150 msgid "" "For use cases which require exact decimal representation, try using the :mod:" "`decimal` module which implements decimal arithmetic suitable for accounting " "applications and high-precision applications." msgstr "" "Para as situações que exijam uma representação decimal exata, experimente o " "módulo :mod:`decimal` que possui, a implementação de uma adequada aritmética " "decimal bastante utilizada nas aplicações contábeis e pelas aplicações que " "demandam alta precisão." #: ../../tutorial/floatingpoint.rst:154 msgid "" "Another form of exact arithmetic is supported by the :mod:`fractions` module " "which implements arithmetic based on rational numbers (so the numbers like " "1/3 can be represented exactly)." msgstr "" "Uma outra forma de obter uma aritmética exata tem suporte pelo módulo :mod:" "`fracções` que implementa a aritmética baseada em números racionais " "(portanto, os números fracionários como o 1/3 conseguem uma representação " "precisa)." #: ../../tutorial/floatingpoint.rst:158 msgid "" "If you are a heavy user of floating-point operations you should take a look " "at the NumPy package and many other packages for mathematical and " "statistical operations supplied by the SciPy project. See ." msgstr "" "Caso necessites fazer um intenso uso das operações de ponto flutuante, é " "importante que conheças o pacote NumPy e, também é importante dizer, que " "existem diversos pacotes destinados ao trabalho intenso com operações " "matemáticas e estatísticas que são fornecidas pelo projeto SciPy. Veja " "." #: ../../tutorial/floatingpoint.rst:162 msgid "" "Python provides tools that may help on those rare occasions when you really " "*do* want to know the exact value of a float. The :meth:`float." "as_integer_ratio` method expresses the value of a float as a fraction::" msgstr "" "O Python fornece ferramentas que podem ajudar nessas raras ocasiões em que " "realmente *faz* necessário conhecer o valor exato de um ponto flutuante. O " "método :meth:`float.as_integer_ratio` expressa o valor de um número do tipo " "float em sua forma fracionária:" #: ../../tutorial/floatingpoint.rst:171 msgid "" "Since the ratio is exact, it can be used to losslessly recreate the original " "value::" msgstr "" "Uma vez que a relação seja exata, será possível utiliza-la para obter, sem " "que haja quaisquer perda do valor original:" #: ../../tutorial/floatingpoint.rst:177 msgid "" "The :meth:`float.hex` method expresses a float in hexadecimal (base 16), " "again giving the exact value stored by your computer::" msgstr "" "O método :meth:`float.hex` expressa um ponto flutuante em hexadecimal (base " "16), o mesmo também retornará o valor exato pelo computador:" #: ../../tutorial/floatingpoint.rst:183 msgid "" "This precise hexadecimal representation can be used to reconstruct the float " "value exactly::" msgstr "" "Sua precisa representação hexadecimal poderá ser utilizada para reconstruir " "o valor exato do ponto flutuante:" #: ../../tutorial/floatingpoint.rst:189 msgid "" "Since the representation is exact, it is useful for reliably porting values " "across different versions of Python (platform independence) and exchanging " "data with other languages that support the same format (such as Java and " "C99)." msgstr "" "Como a representação será exata, é interessante utilizar valores confiáveis " "em diferentes versões do Python (independente da plataforma) e a troca de " "dados entre idiomas diferentes que forneçam o mesmo formato (como o Java e o " "C99)." #: ../../tutorial/floatingpoint.rst:193 msgid "" "Another helpful tool is the :func:`math.fsum` function which helps mitigate " "loss-of-precision during summation. It tracks \"lost digits\" as values are " "added onto a running total. That can make a difference in overall accuracy " "so that the errors do not accumulate to the point where they affect the " "final total:" msgstr "" "Uma outra ferramenta que poderá ser útil é a função :func:`math.fsum` que " "ajuda a mitigar a perda de precisão durante a soma. Ele rastreia \"digitos " "perdidos\" como valores para serem adicionados ao um total da execução. Isso " "poderá fazer a diferença na precisão geral de forma que os erros não se " "acumulem chegando ao ponto de afetar o resultado final:" #: ../../tutorial/floatingpoint.rst:207 msgid "Representation Error" msgstr "Erro de representação" #: ../../tutorial/floatingpoint.rst:209 msgid "" "This section explains the \"0.1\" example in detail, and shows how you can " "perform an exact analysis of cases like this yourself. Basic familiarity " "with binary floating-point representation is assumed." msgstr "" "Esta seção explica o exemplo do \"0.1\" em detalhes, e mostra como poderás " "realizar uma análise exata de casos semelhantes. Presumimos que tenhas uma " "familiaridade básica com a representação binária de ponto flutuante." #: ../../tutorial/floatingpoint.rst:213 msgid "" ":dfn:`Representation error` refers to the fact that some (most, actually) " "decimal fractions cannot be represented exactly as binary (base 2) " "fractions. This is the chief reason why Python (or Perl, C, C++, Java, " "Fortran, and many others) often won't display the exact decimal number you " "expect." msgstr "" ":dfn:`Erro de representação` refere-se ao fato de que algumas frações " "decimais (a maioria, na verdade) não podem ser representadas exatamente como " "frações binárias (base 2). Esta é a principal razão por que o Python (ou " "Perl, C, C++, Java, Fortran, e muitas outras) frequentemente não exibe o " "número decimal exato conforme o esperado::" #: ../../tutorial/floatingpoint.rst:218 msgid "" "Why is that? 1/10 is not exactly representable as a binary fraction. Since " "at least 2000, almost all machines use IEEE 754 binary floating-point " "arithmetic, and almost all platforms map Python floats to IEEE 754 binary64 " "\"double precision\" values. IEEE 754 binary64 values contain 53 bits of " "precision, so on input the computer strives to convert 0.1 to the closest " "fraction it can of the form *J*/2**\\ *N* where *J* is an integer containing " "exactly 53 bits. Rewriting ::" msgstr "" "Por que isso acontece? 1/10 não é representado exatamente sendo fração " "binária. Desde pelo menos 2000, quase todas as máquinas usam aritmética " "binária de ponto flutuante da IEEE 754 e quase todas as plataformas " "representam pontos flutuante do Python como valores binary64 de \"double " "precision\" (dupla precisão) da IEEE 754. Os valores binary64 da IEEE 754 " "têm 53 bits de precisão, por isso na entrada o computador se esforça para " "converter \"0.1\" para a fração mais próxima que puder, na forma *J*/2**\\ " "*N* onde *J* é um número inteiro contendo exatamente 53 bits. Reescrevendo::" #: ../../tutorial/floatingpoint.rst:229 msgid "as ::" msgstr "como ::" #: ../../tutorial/floatingpoint.rst:233 msgid "" "and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< " "2**53``), the best value for *N* is 56::" msgstr "" "e recordando que *J* tenha exatamente 53 bits (é ``>= 2**52``, mas ``< " "2**53``), o melhor valor para *N* é 56::" #: ../../tutorial/floatingpoint.rst:239 msgid "" "That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits. " "The best possible value for *J* is then that quotient rounded::" msgstr "" "Ou seja, 56 é o único valor de *N* que deixa *J* com exatamente 53 bits. " "Portanto, o melhor valor que conseguimos obter pra *J* será aquele que " "possui o quociente arredondado:" #: ../../tutorial/floatingpoint.rst:246 msgid "" "Since the remainder is more than half of 10, the best approximation is " "obtained by rounding up::" msgstr "" "Uma vez que o resto seja maior do que a metade de 10, a melhor aproximação " "que poderá ser obtida se arredondarmos para cima:" #: ../../tutorial/floatingpoint.rst:252 msgid "" "Therefore the best possible approximation to 1/10 in IEEE 754 double " "precision is::" msgstr "" "Portanto, a melhor aproximação possível de 1/10 como um \"IEEE 754 double " "precision\" é::" #: ../../tutorial/floatingpoint.rst:257 msgid "" "Dividing both the numerator and denominator by two reduces the fraction to::" msgstr "Dividir o numerador e o denominador por dois reduzirá a fração para::" #: ../../tutorial/floatingpoint.rst:261 msgid "" "Note that since we rounded up, this is actually a little bit larger than " "1/10; if we had not rounded up, the quotient would have been a little bit " "smaller than 1/10. But in no case can it be *exactly* 1/10!" msgstr "" "Note que, como arredondamos para cima, esse valor é, de fato, um pouco maior " "que 1/10; se não tivéssemos arredondado para cima, o quociente teria sido um " "pouco menor que 1/10. Mas em nenhum caso seria possível obter *exatamente* o " "valor 1/10!" #: ../../tutorial/floatingpoint.rst:265 msgid "" "So the computer never \"sees\" 1/10: what it sees is the exact fraction " "given above, the best IEEE 754 double approximation it can get:" msgstr "" "Por isso, o computador nunca \"vê\" 1/10: o que ele vê é exatamente a fração " "que é obtida pra cima, a melhor aproximação \"IEEE 754 double\" possível é:" #: ../../tutorial/floatingpoint.rst:271 msgid "" "If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 " "decimal digits::" msgstr "" "Se multiplicarmos essa fração por 10\\*\\*55, podemos ver o valor contendo " "os 55 dígitos mais significativos:" #: ../../tutorial/floatingpoint.rst:277 msgid "" "meaning that the exact number stored in the computer is equal to the decimal " "value 0.1000000000000000055511151231257827021181583404541015625. Instead of " "displaying the full decimal value, many languages (including older versions " "of Python), round the result to 17 significant digits::" msgstr "" "o que significa que o número exato armazenado no computador é igual ao valor " "decimal 0.1000000000000000055511151231257827021181583404541015625. Em vez de " "exibir o valor decimal completo, muitas linguagens (incluindo versões mais " "antigas do Python), arredondam o resultado para 17 dígitos significativos:" #: ../../tutorial/floatingpoint.rst:285 msgid "" "The :mod:`fractions` and :mod:`decimal` modules make these calculations " "easy::" msgstr "" "Módulos como o :mod:`fractions` e o :mod:`decimal` tornam esses cálculos " "muito mais fáceis:"