python-docs-ru/tutorial/floatingpoint.po at 3.14 · python/python-docs-ru

716 lines (640 loc) · 35.2 KB
# 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:
# python-doc bot, 2025
# Dmitry Luschan, 2025
# Daniil Kolesnikov, 2026
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-08-11 14:51+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: Daniil Kolesnikov, 2026\n"
"Language-Team: Russian (https://app.transifex.com/python-doc/teams/5390/"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ru\n"
"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && "
"n%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || "
"(n%100>=11 && n%100<=14)? 2 : 3);\n"
msgid "Floating-Point Arithmetic:  Issues and Limitations"
msgstr "Арифметика с плавающей точкой: проблемы и ограничения"
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the **decimal** fraction ``0.625`` has "
"value 6/10 + 2/100 + 5/1000, and in the same way the **binary** fraction "
"``0.101`` has value 1/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."
"Числа с плавающей точкой представлены в компьютерном оборудовании в виде "
"дробей с основанием 2 (двоичных). Например, **десятичная** дробь ``0.625`` "
"имеет значение 6/10 + 2/100 + 5/1000, и таким же образом **двоичная** дробь "
"``0.101`` имеет значение 1/2 + 0/4 + 1/8. У этих двух дробей одинаковые "
"значения, единственное реальное отличие заключается в том, что первая "
"записана в десятичной системе счисления, а вторая — в двоичной."
"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."
"К сожалению, большинство десятичных дробей невозможно точно представить в "
"виде двоичных дробей. В результате, как правило, введённые вами десятичные "
"числа с плавающей точкой лишь приближенно соответствуют двоичным числам с "
"плавающей точкой, которые реально хранятся в компьютере."
"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::"
"Эту проблему проще понять сначала на десятичной системе счисления. "
"Рассмотрим дробь 1/3. Её можно приблизить как десятичную дробь::"
msgid "0.3"
msgstr "0.3"
msgid "or, better, ::"
msgstr "или, точнее, ::"
msgid "0.33"
msgstr "0.33"
msgid "0.333"
msgstr "0.333"
"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."
"и так далее. Неважно как много цифр вы готовы написать, результат никогда не "
"будет равен ровно 1/3, но будет всё более лучшим приближением к 1/3."
"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 ::"
"Точно так же, как бы много двоичных знаков вы ни использовали, десятичное "
"значение 0.1 невозможно представить точно как двоичную дробь. В двоичной "
"системе счисления 1/10 — это бесконечно повторяющаяся дробь ::"
"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."
"Если остановиться на любом конечном количестве бит, получится приближение. "
"На большинстве современных машин числа с плавающей точкой представляются "
"двоичной дробью, где числитель занимает первые 53 бита (начиная со "
"старшего), а знаменатель — это степень двойки. В случае с 1/10 двоичная "
"дробь имеет вид ``3602879701896397 / 2 ** 55`` — это близко, но не точно "
"равно 1/10."
"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::"
"Многие пользователи не знают об аппроксимации из-за того, как числа "
"отображаются. Python выводит лишь десятичное приближение к точному "
"десятичному значению того двоичного приближения, которая хранится в памяти. "
"На большинстве компьютеров, если бы Python выводил истинное десятичное "
"значение двоичного приближения, сохраненное для 0.1, вывод выглядел бы так::"
">>> 0.1\n"
">>> 0.1\n"
"That is more digits than most people find useful, so Python keeps the number "
"of digits manageable by displaying a rounded value instead:"
"Это больше цифр, чем большинство людей считает полезным, поэтому Python "
"позволяет управлять количеством цифр, отображая вместо этого округлённое "
"значение:"
">>> 1 / 10\n"
">>> 1 / 10\n"
"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."
"Просто запомните, даже если результат выводится похожим на точное значение "
"1/10, на самом деле значение хранится как ближайшая представимая двоичная "
"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 "
"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``."
"Интересно, что существует много различных десятичных чисел, которые имеют "
"одно и то же ближайшее двоичное приближение. Например, числа ``0.1``, "
"``0.10000000000000001`` и "
"округляются до ``3602879701896397 / 2 ** 55``. Поскольку все эти десятичные "
"значения имеют одинаковое двоичное приближение, любое из них может быть "
"выбрано для отображения, и инвариант ``eval(repr(x)) == x`` при этом "
"сохранится."
"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``."
"Исторически сложилось так, что интерактивная консоль Python и встроенная "
"функция :func:`repr` выбирали вариант с 17 значащими цифрами, "
"``0.10000000000000001``. Начиная с Python 3.1 на большинстве систем теперь "
"выбирается самый короткий из них, и просто отображается ``0.1``."
"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)."
"Обратите внимание, что это заложено в самой природе двоичных чисел с "
"плавающей точкой — это не ошибка в Python или в вашем коде. То же самое вы "
"увидите во всех языках, использующих арифметику с плавающей точкой "
"аппаратного уровня (хотя некоторые языки могут не *отображать* разницу по "
"умолчанию или во всех режимах вывода)."
"For more pleasant output, you may wish to use string formatting to produce a "
"limited number of significant digits:"
"Для более красивого вывода вы можете использовать форматирование строк для "
"получения ограниченного количества значащих цифр:"
">>> format(math.pi, '.12g')  # give 12 significant digits\n"
"'3.14159265359'\n"
">>> format(math.pi, '.2f')   # give 2 digits after the point\n"
">>> repr(math.pi)\n"
"'3.141592653589793'"
">>> format(math.pi, '.12g')  # получить 12 значащих цифр\n"
"'3.14159265359'\n"
">>> format(math.pi, '.2f')   # получить 2 цифры после точки\n"
">>> repr(math.pi)\n"
"'3.141592653589793'"
"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."
"Важно понимать, что в действительности это иллюзия: вы просто округляете "
"*отображаемое* истинное значение, хранящегося в машине."
"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:"
"Одна иллюзия может порождать другую. Например, поскольку 0.1 не является "
"точно 1/10, сумма трёх значений 0.1 может не дать точно 0.3:"
">>> 0.1 + 0.1 + 0.1 == 0.3\n"
">>> 0.1 + 0.1 + 0.1 == 0.3\n"
"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:"
"Кроме того, поскольку 0.1 не может стать ближе к точному значению 1/10, а "
"0.3 — к точному значению 3/10, предварительное округление с помощью функции :"
"func:`round` не может помочь:"
">>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)\n"
">>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)\n"
"Though the numbers cannot be made closer to their intended exact values, "
"the :func:`math.isclose` function can be useful for comparing inexact values:"
"Хотя числа невозможно сильнее приблизить к их предполагаемым точным "
"значениям, функция :func:`math.isclose` может быть полезна для сравнения "
"неточных значений:"
">>> math.isclose(0.1 + 0.1 + 0.1, 0.3)\n"
">>> math.isclose(0.1 + 0.1 + 0.1, 0.3)\n"
"Alternatively, the :func:`round` function can be used to compare rough "
"approximations:"
"В качестве альтернативы для сравнения грубых приближений можно использовать "
"функцию :func:`round`:"
">>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)\n"
">>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)\n"
"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 "
"<https://jvns.ca/blog/2023/01/13/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 <http://www.indowsway.com/floatingpoint.htm>`_ for a more complete "
"account of other common surprises."
"Двоичная арифметика с плавающей точкой таит в себе много подобных сюрпризов. "
"Проблема с «0.1» подробно описана ниже, в разделе «Ошибка представления». "
"См. `Примеры проблем с плавающей точкой <https://jvns.ca/blog/2023/01/13/"
"examples-of-floating-point-problems/>`_ для наглядного обзора работы "
"двоичной арифметики с плавающей точкой и проблем, наиболее часто "
"встречающихся на практике. Также см. `Опасности плавающей точки <http://www."
"indowsway.com/floatingpoint.htm>`_ для более полного описания других "
"типичных сюрпризов."
"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 "
"Как сказано почти в самом конце: «простых решений нет». Тем не менее, не "
"стоит чрезмерно опасаться чисел с плавающей точкой! Ошибки при операциях с "
"float в Python наследуются от аппаратного обеспечения с плавающей точкой и "
"на большинстве машин составляют не более 1 части из 2\\*\\*53 за операцию. "
"Этого более чем достаточно для большинства задач, но нужно помнить, что это "
"не десятичная арифметика и каждая операция с float может привести к новой "
"ошибке округления."
"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`."
"Хотя патологические случаи действительно встречаются, при обычном "
"использовании арифметики с плавающей точкой вы, как правило, получите "
"ожидаемый результат, если просто округлите его до нужного количества "
"десятичных цифр. Функции :func:`str` обычно достаточно, а для более точного "
"контроля используйте спецификаторы формата метода :meth:`str.format` из :ref:"
"`formatstrings`."
"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."
"Для случаев, когда требуется точное десятичное представление, попробуйте "
"использовать модуль :mod:`decimal`, реализующий десятичную арифметику, "
"подходящую для бухгалтерских задач и приложений с высокой точностью."
"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)."
"Другая форма точной арифметики поддерживается модулем :mod:`fractions`, "
"который реализует арифметику, основанную на рациональных числах (поэтому "
"числа типа 1/3 могут быть представлены точно)."
"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 <https://scipy."
"Если вы активно пользуетесь вычислениями с плавающей точкой, вам следует "
"взглянуть на пакет NumPy и многие другие пакеты для математических и "
"статистических операций, поставляемые проектом SciPy. См. <https://scipy."
"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:"
"Python предоставляет инструменты, которые могут помочь в тех редких случаях, "
"когда вы *действительно* хотите узнать точное значение числа с плавающей "
"точкой. Метод :meth:`float.as_integer_ratio` выражает значение float в виде "
">>> x = 3.14159\n"
">>> x.as_integer_ratio()\n"
">>> x = 3.14159\n"
">>> x.as_integer_ratio()\n"
"Since the ratio is exact, it can be used to losslessly recreate the original "
"Поскольку это отношение точное, его можно использовать для воссоздания "
"исходного значения без потерь:"
">>> x == 3537115888337719 / 1125899906842624\n"
">>> x == 3537115888337719 / 1125899906842624\n"
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer:"
"Метод :meth:`float.hex` выражает число с плавающей точкой в "
"шестнадцатеричном виде (по основанию 16), снова предоставляя точное "
"значение, сохраненное на вашем компьютере:"
">>> x.hex()\n"
"'0x1.921f9f01b866ep+1'"
">>> x.hex()\n"
"'0x1.921f9f01b866ep+1'"
"This precise hexadecimal representation can be used to reconstruct the float "
"value exactly:"
"Это точное шестнадцатеричное представление можно использовать для "
"восстановления значения float в точности:"
">>> x == float.fromhex('0x1.921f9f01b866ep+1')\n"
">>> x == float.fromhex('0x1.921f9f01b866ep+1')\n"
"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 "
"Поскольку представление является точным, оно полезно для надежного переноса "
"значений между разными версиями Python (независимость от платформы) и обмена "
"данными с другими языками, поддерживающими тот же формат (например, Java и "
"Another helpful tool is the :func:`sum` function which helps mitigate loss-"
"of-precision during summation.  It uses extended precision for intermediate "
"rounding steps 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:"
"Ещё одним полезным инструментом является функция :func:`sum`, которая "
"помогает уменьшить потерю точности во время суммирования. Она использует "
"расширенную точность для промежуточных шагов округления по мере добавления "
"значений к сумме. Это может повлиять на общую точность, предотвращая "
"накопление ошибок до уровня, когда они влияют на итоговый результат:"
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
">>> sum([0.1] * 10) == 1.0\n"
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
">>> sum([0.1] * 10) == 1.0\n"
"The :func:`math.fsum` goes further and tracks all of the \"lost digits\" as "
"values are added onto a running total so that the result has only a single "
"rounding.  This is slower than :func:`sum` but will be more accurate in "
"uncommon cases where large magnitude inputs mostly cancel each other out "
"leaving a final sum near zero:"
"Функция :func:`math.fsum` идёт дальше и отслеживает все «потерянные цифры» "
"при добавлении значений к сумме, так что результат подвергается только "
"одному округлению. Это медленнее, чем :func:`sum`, но даёт большую точность "
"в редких случаях, когда слагаемые большой величины в основном взаимно "
"компенсируют друг друга, оставляя итоговую сумму близкой к нулю:"
">>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,\n"
">>> float(sum(map(Fraction, arr)))   # Exact summation with single rounding\n"
"8.042173697819788e-13\n"
">>> math.fsum(arr)                   # Single rounding\n"
"8.042173697819788e-13\n"
">>> sum(arr)                         # Multiple roundings in extended "
"precision\n"
"8.042178034628478e-13\n"
">>> total = 0.0\n"
">>> for x in arr:\n"
"...     total += x                   # Multiple roundings in standard "
"precision\n"
">>> total                            # Straight addition has no correct "
"digits!\n"
">>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,\n"
">>> float(sum(map(Fraction, arr)))   # Точное суммирование с одним "
"округлением\n"
"8.042173697819788e-13\n"
">>> math.fsum(arr)                   # Одно округление\n"
"8.042173697819788e-13\n"
">>> sum(arr)                         # Многократное округление с расширенной "
"точностью\n"
"8.042178034628478e-13\n"
">>> total = 0.0\n"
">>> for x in arr:\n"
"...     total += x                   # Многократное округление со "
"стандартной точностью\n"
">>> total                            # Прямое сложение не даёт корректный "
"результат!\n"
msgid "Representation Error"
msgstr "Ошибка представления"
"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."
"В этом разделе подробно объясняется пример «0.1» и показывается, как можно "
"самостоятельно выполнить точный анализ подобных случаев. Предполагается "
"базовое знакомство с двоичным представлением чисел с плавающей точкой."
":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 "
":dfn:`Ошибка представления` относится к тому факту, что некоторые (на самом "
"деле большинство) десятичные дроби не могут быть представлены точно как "
"двоичные дроби (по основанию 2). Это основная причина, по которой Python "
"(или Perl, C, C++, Java, Fortran и многие другие) часто не отображает точное "
"десятичное число, которое вы ожидаете."
"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 ::"
"Почему так происходит? Число 1/10 нельзя точно представить как двоичную "
"дробь. По крайней мере, с 2000 года почти все машины используют двоичную "
"арифметику с плавающей точкой стандарта IEEE 754, и почти все платформы "
"сопоставляют числа float в Python со значениями IEEE 754 binary64 «двойной "
"точности». Эти значения имеют точность 53 бита, поэтому при вводе компьютер "
"стремится преобразовать 0.1 в ближайшую дробь вида *J*/2**\\ *N*, где *J* — "
"целое число, содержащее ровно 53 бита. Переписав ::"
msgid "1 / 10 ~= J / (2**N)"
msgstr "1 / 10 ~= J / (2**N)"
msgid "as ::"
msgstr "как ::"
msgid "J ~= 2**N / 10"
msgstr "J ~= 2**N / 10"
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56:"
"и учитывая, что *J* имеет ровно 53 бита (оно ``>= 2**52``, но ``< 2**53``), "
"лучшее значение для *N* — это 56:"
">>> 2**52 <=  2**56 // 10  < 2**53\n"
">>> 2**52 <=  2**56 // 10  < 2**53\n"
"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:"
"То есть 56 — единственное значение для *N*, при котором в *J* остаётся ровно "
"53 бита. Наилучшее возможное значение для *J* — это округленное частное:"
">>> q, r = divmod(2**56, 10)\n"
">>> q, r = divmod(2**56, 10)\n"
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up:"
"Поскольку остаток больше половины от 10, наилучшее приближение получается "
"округлением в большую сторону:"
">>> q+1\n"
">>> q+1\n"
"Therefore the best possible approximation to 1/10 in IEEE 754 double "
"precision is::"
msgstr "Поэтому наилучшее приближение к 1/10 в двойной точности IEEE 754:"
msgid "7205759403792794 / 2 ** 56"
msgstr "7205759403792794 / 2 ** 56"
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr "Деление числителя и знаменателя на два уменьшает дробь до:"
msgid "3602879701896397 / 2 ** 55"
msgstr "3602879701896397 / 2 ** 55"
"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!"
"Обратите внимание: поскольку мы округлили в большую сторону, на самом деле "
"это немного больше, чем 1/10; если бы мы не округляли в большую сторону, "
"частное было бы немного меньше 1/10. Но ни в коем случае оно не может быть "
"*ровно* 1/10!"
"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:"
"Таким образом, компьютер никогда не «видит» 1/10: он работает с точной "
"дробью, указанной выше — лучшим приближение двойной точности IEEE 754, "
"которое он может получить:"
">>> 0.1 * 2 ** 55\n"
">>> 0.1 * 2 ** 55\n"
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits:"
"Если мы умножим эту дробь на 10\\*\\*55, мы увидим значение из 55 десятичных "
">>> 3602879701896397 * 10 ** 55 // 2 ** 55\n"
">>> 3602879701896397 * 10 ** 55 // 2 ** 55\n"
"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:"
"это означает, что точное число, хранящееся в компьютере, равно десятичному "
"значению 0,1000000000000000055511151231257827021181583404541015625. Вместо "
"отображения полного десятичного значения во многих языках (включая старые "
"версии Python) результат округляется до 17 значащих цифр:"
">>> format(0.1, '.17f')\n"
"'0.10000000000000001'"
">>> format(0.1, '.17f')\n"
"'0.10000000000000001'"
"The :mod:`fractions` and :mod:`decimal` modules make these calculations easy:"
msgstr "Модули :mod:`fractions` и :mod:`decimal` упрощают эти вычисления:"
">>> from decimal import Decimal\n"
">>> from fractions import Fraction\n"
">>> Fraction.from_float(0.1)\n"
"Fraction(3602879701896397, 36028797018963968)\n"
">>> (0.1).as_integer_ratio()\n"
">>> Decimal.from_float(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
">>> format(Decimal.from_float(0.1), '.17')\n"
"'0.10000000000000001'"
">>> from decimal import Decimal\n"
">>> from fractions import Fraction\n"
">>> Fraction.from_float(0.1)\n"
"Fraction(3602879701896397, 36028797018963968)\n"
">>> (0.1).as_integer_ratio()\n"
">>> Decimal.from_float(0.1)\n"
"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"
">>> format(Decimal.from_float(0.1), '.17')\n"
"'0.10000000000000001'"
Navigation Menu

Uh oh!

Uh oh!

FilesExpand file tree

floatingpoint.po

Latest commit

History

floatingpoint.po

File metadata and controls
