# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2017.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-11-26 18:49+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh <flowdas@gmail.com>\n"
"Language-Team: Korean (http://python.flowdas.com)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.5.1\n"

#: ../Doc/tutorial/floatingpoint.rst:9
msgid "Floating Point Arithmetic:  Issues and Limitations"
msgstr "부동 소수점 산술: 문제점 및 한계"

#: ../Doc/tutorial/floatingpoint.rst:14
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the decimal fraction ::"
msgstr "부동 소수점 숫자는 컴퓨터 하드웨어에서 밑(base)이 2인(이진) 소수로 표현됩니다. 예를 들어, 소수 ::"

#: ../Doc/tutorial/floatingpoint.rst:19
msgid ""
"has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction "
"::"
msgstr "는 1/10 + 2/100 + 5/1000의 값을 가지며, 같은 방식으로 이진 소수 ::"

#: ../Doc/tutorial/floatingpoint.rst:23
msgid ""
"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 ""
"는 값 0/2 + 0/4 + 1/8을 가집니다. 이 두 소수는 같은 값을 가지며, 유일한 차이점은 첫 번째가 밑이 10인 분수 표기법으로 "
"작성되었고 두 번째는 밑이 2라는 것입니다."

#: ../Doc/tutorial/floatingpoint.rst:27
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 ""
"불행히도, 대부분의 십진 소수는 정확하게 이진 소수로 표현될 수 없습니다. 결과적으로, 일반적으로 입력하는 십진 부동 소수점 숫자가 실제로 "
"기계에 저장될 때는 이진 부동 소수점 수로 근사 될 뿐입니다."

#: ../Doc/tutorial/floatingpoint.rst:32
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 ""
"이 문제는 먼저 밑 10에서 따져보는 것이 이해하기 쉽습니다. 분수 1/3을 생각해봅시다. 이 값을 십진 소수로 근사할 수 있습니다::"

#: ../Doc/tutorial/floatingpoint.rst:37 ../Doc/tutorial/floatingpoint.rst:41
msgid "or, better, ::"
msgstr "또는, 더 정확하게, ::"

#: ../Doc/tutorial/floatingpoint.rst:45
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 "등등. 아무리 많은 자릿수를 적어도 결과가 정확하게 1/3이 될 수 없지만, 점점 더 1/3에 가까운 근사치가 됩니다."

#: ../Doc/tutorial/floatingpoint.rst:49
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 ""
"같은 방식으로, 아무리 많은 자릿수의 숫자를 사용해도, 십진수 0.1은 이진 소수로 정확하게 표현될 수 없습니다. 이진법에서, 1/10은 "
"무한히 반복되는 소수입니다 ::"

#: ../Doc/tutorial/floatingpoint.rst:55
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 ""
"유한 한 비트 수에서 멈추면, 근삿값을 얻게 됩니다. 오늘날 대부분 기계에서, float는 이진 분수로 근사 되는 데, 최상위 비트로부터 "
"시작하는 53비트를 분자로 사용하고, 2의 거듭제곱 수를 분모로 사용합니다. 1/10의 경우, 이진 분수는 "
"``3602879701896397 / 2 ** 55`` 인데, 실제 값 1/10과 거의 같지만 정확히 같지는 않습니다."

#: ../Doc/tutorial/floatingpoint.rst:62
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 ""
"많은 사용자는 값이 표시되는 방식 때문에 근사를 인식하지 못합니다. 파이썬은 기계에 저장된 이진 근삿값의 진짜 십진 값에 대한 십진 "
"근삿값을 인쇄할 뿐입니다. 대부분 기계에서, 만약 파이썬이 0.1로 저장된 이진 근삿값의 진짜 십진 값을 출력한다면 다음과 같이 표시해야 "
"합니다 ::"

#: ../Doc/tutorial/floatingpoint.rst:71
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 ""
"이것은 대부분 사람이 유용하다고 생각하는 것보다 많은 숫자이므로, 파이썬은 반올림된 값을 대신 표시하여 숫자를 다룰만하게 만듭니다 ::"

#: ../Doc/tutorial/floatingpoint.rst:77
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 "인쇄된 결과가 정확히 1/10인 것처럼 보여도, 실제 저장된 값은 가장 가까운 표현 가능한 이진 소수임을 기억하세요."

#: ../Doc/tutorial/floatingpoint.rst:80
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 ""
"흥미롭게도, 가장 가까운 근사 이진 소수를 공유하는 여러 다른 십진수가 있습니다. 예를 들어, ``0.1`` 과 "
"``0.10000000000000001`` 및 "
"``0.1000000000000000055511151231257827021181583404541015625`` 는 모두 "
"``3602879701896397 / 2 ** 55`` 로 근사 됩니다. 이 십진 값들이 모두 같은 근삿값을 공유하기 때문에 "
"``eval(repr(x)) == x`` 불변을 그대로 유지하면서 그중 하나를 표시할 수 있습니다."

#: ../Doc/tutorial/floatingpoint.rst:88
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 ""
"역사적으로, 파이썬 프롬프트와 내장 :func:`repr` 함수는 유효 숫자 17개의 숫자인 ``0.10000000000000001`` "
"을 선택합니다. 파이썬 3.1부터, 이제 파이썬(대부분 시스템에서)이 가장 짧은 것을 선택할 수 있으며, 단순히 ``0.1`` 만 "
"표시합니다."

#: ../Doc/tutorial/floatingpoint.rst:93
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 ""
"이것이 이진 부동 소수점의 본질임에 주목하세요: 파이썬의 버그는 아니며, 여러분의 코드에 있는 버그도 아닙니다. 하드웨어의 부동 소수점"
" 산술을 지원하는 모든 언어에서 같은 종류의 것을 볼 수 있습니다 (일부 언어는 기본적으로 혹은 모든 출력 모드에서 차이를 *표시하지* 않을"
" 수 있지만)."

#: ../Doc/tutorial/floatingpoint.rst:99
msgid ""
"For more pleasant output, you may wish to use string formatting to "
"produce a limited number of significant digits::"
msgstr "좀 더 만족스러운 결과를 얻으려면, 문자열 포매팅을 사용하여 제한된 수의 유효 숫자를 생성할 수 있습니다::"

#: ../Doc/tutorial/floatingpoint.rst:111
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 "이것이, 진정한 의미에서, 환영임을 깨닫는 것이 중요합니다: 여러분은 단순히 진짜 기곗값의 *표시* 를 반올림하고 있습니다."

#: ../Doc/tutorial/floatingpoint.rst:114
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 ""
"하나의 환상은 다른 환상을 낳을 수 있습니다. 예를 들어, 0.1은 정확히 1/10이 아니므로, 0.1의 세 개를 합한 것 역시 정확히 "
"0.3이 아닙니다::"

#: ../Doc/tutorial/floatingpoint.rst:120
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 ""
"또한, 0.1은 1/10의 정확한 값에 더 가까워질 수 없고, 0.3도 3/10의 정확한 값에 더 가까워질 수 없으므로, "
":func:`round` 함수로 미리 반올림하는 것은 도움이 되지 않습니다::"

#: ../Doc/tutorial/floatingpoint.rst:127
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 ""
"숫자를 의도한 정확한 값에 더 가깝게 만들 수는 없지만, :func:`round` 함수는 사후 반올림에 유용하여 부정확한 값을 가진 "
"결과를 서로 비교할 수 있게 합니다::"

#: ../Doc/tutorial/floatingpoint.rst:134
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 `The Perils of Floating Point "
"<http://www.lahey.com/float.htm>`_ for a more complete account of other "
"common surprises."
msgstr ""
"이진 부동 소수점 산술은 이처럼 많은 놀라움을 안겨줍니다. \"0.1\"의 문제는 아래의 \"표현 오류\" 섹션에서 자세하게 설명합니다. "
"`부동 소수점의 위험 <http://www.lahey.com/float.htm>`_ 은 다른 흔히 만나는 놀라움에 대해 더욱 완전한 "
"설명을 제공합니다."

#: ../Doc/tutorial/floatingpoint.rst:139
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 ""
"끝이 가까이 오면 말하듯이, \"쉬운 답은 없습니다.\" 아직, 부동 소수점수를 지나치게 경계할 필요는 없습니다! 파이썬 float 연산의 "
"에러는 부동 소수점 하드웨어에서 상속된 것이고, 대부분 기계에서는 연산당 2\\*\\*53분의 1을 넘지 않는 규모입니다. 이것은 대부분 "
"작업에서 필요한 수준 이상입니다. 하지만, 십진 산술이 아니며 모든 float 연산에 새로운 반올림 에러가 발생할 수 있다는 점을 명심해야"
" 합니다."

#: ../Doc/tutorial/floatingpoint.rst:146
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 ""
"병리학적 경우가 존재하지만, 무심히 부동 소수점 산술을 사용하는 대부분은, 단순히 최종 결과를 기대하는 자릿수로 반올림해서 표시하면 "
"기대하는 결과를 보게 될 것입니다. 보통 :func:`str` 만으로도 충분하며, 더 세밀하게 제어하려면 "
":ref:`formatstrings` 에서 :meth:`str.format` 메서드의 포맷 지정자를 보세요."

#: ../Doc/tutorial/floatingpoint.rst:152
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 ""
"정확한 십진 표현이 필요한 사용 사례의 경우, 회계 응용 프로그램 및 고정밀 응용 프로그램에 적합한 십진 산술을 구현하는 "
":mod:`decimal` 모듈을 사용해보세요."

#: ../Doc/tutorial/floatingpoint.rst:156
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 ""
"정확한 산술의 또 다른 형태는 유리수를 기반으로 산술을 구현하는 :mod:`fractions` 모듈에 의해 지원됩니다 (따라서 1/3과 "
"같은 숫자는 정확하게 나타낼 수 있습니다)."

#: ../Doc/tutorial/floatingpoint.rst:160
msgid ""
"If you are a heavy user of floating point operations you should take a "
"look at the Numerical Python package and many other packages for "
"mathematical and statistical operations supplied by the SciPy project. "
"See <https://scipy.org>."
msgstr ""
"부동 소수점 연산을 많이 하는 사용자면 Numerical Python 패키지와 SciPy 프로젝트에서 제공하는 수학 및 통계 연산을 위한"
" 다른 많은 패키지를 살펴봐야 합니다. <https://scipy.org> 를 보세요."

#: ../Doc/tutorial/floatingpoint.rst:164
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 ""
"파이썬은 여러분이 float의 정확한 값을 진짜로 *알아야 하는* 드문 경우를 지원할 수 있는 도구들을 제공합니다. "
":meth:`float.as_integer_ratio` 메서드는 float의 값을 분수로 표현합니다::"

#: ../Doc/tutorial/floatingpoint.rst:173
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the "
"original value::"
msgstr "비율은 정확한 값이기 때문에, 원래 값을 손실 없이 다시 만드는 데 사용할 수 있습니다::"

#: ../Doc/tutorial/floatingpoint.rst:179
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer::"
msgstr ""
":meth:`float.hex` 메서드는 float를 16진수(밑이 16이다)로 표현하는데, 컴퓨터에 저장된 정확한 값을 줍니다::"

#: ../Doc/tutorial/floatingpoint.rst:185
msgid ""
"This precise hexadecimal representation can be used to reconstruct the "
"float value exactly::"
msgstr "이 정확한 16진수 표현은 float 값을 정확하게 재구성하는 데 사용할 수 있습니다::"

#: ../Doc/tutorial/floatingpoint.rst:191
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 ""
"표현이 정확하므로, 파이썬의 다른 버전 에 걸쳐 값을 신뢰성 있게 이식하고 (플랫폼 독립성), 같은 형식을 지원하는 다른 언어(자바나 "
"C99 같은)와 데이터를 교환하는 데 유용합니다."

#: ../Doc/tutorial/floatingpoint.rst:195
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 ""
"또 다른 유용한 도구는 :func:`math.fsum` 함수입니다. 이 함수는 합산 동안 정밀도 상실을 완화합니다. 누적 합계에 값이 "
"더해지면서 \"잃어버린 숫자들\"을 추적합니다. 최종 합계에 영향을 주는 지점까지 에러가 누적되지 않아서 전체적인 정확도에 차이를 만들 수"
" 있습니다:"

#: ../Doc/tutorial/floatingpoint.rst:209
msgid "Representation Error"
msgstr "표현 오류"

#: ../Doc/tutorial/floatingpoint.rst:211
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 ""
"이 섹션에서는 \"0.1\" 예제를 자세히 설명하고, 이러한 사례에 대한 정확한 분석을 여러분이 직접 수행하는 방법을 보여줍니다. 이진 "
"부동 소수점 표현에 대한 기본 지식이 있다고 가정합니다."

#: ../Doc/tutorial/floatingpoint.rst:215
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:`표현 오류 (Representation error)` 는 일부 (실제로는, 대부분의) 십진 소수가 이진(밑 2) 소수로 "
"정확하게 표현될 수 없다는 사실을 나타냅니다. 이것이 파이썬(또는 펄, C, C++, 자바, 포트란 및 기타 여러 언어)이 종종 여러분이 "
"기대하는 정확한 십진수를 표시하지 않는 주된 이유입니다."

#: ../Doc/tutorial/floatingpoint.rst:220
msgid ""
"Why is that?  1/10 is not exactly representable as a binary fraction. "
"Almost all machines today (November 2000) use IEEE-754 floating point "
"arithmetic, and almost all platforms map Python floats to IEEE-754 "
"\"double precision\".  754 doubles 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 ""
"왜 그럴까? 1/10은 이진 소수로 정확히 표현할 수 없습니다. 오늘날 (2000년 11월) 거의 모든 기계는 IEEE-754 부동 소수점 "
"산술을 사용하고, 거의 모든 플랫폼은 파이썬 float를 IEEE-754 \"배정밀도\"에 매핑합니다. 754 배정밀도는 53비트의 "
"정밀도가 포함되어 있어서, 입력 시 컴퓨터는 0.1을 *J*/2**\\ *N* 형태의 가장 가까운 분수로 변환하려고 노력합니다. 여기서 "
"*J* 는 정확히 53비트를 포함하는 정수입니다.::"

#: ../Doc/tutorial/floatingpoint.rst:229
msgid "as ::"
msgstr "를 ::"

#: ../Doc/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 ""
"로 다시 쓰고, *J*가 정확히 53 비트(``>= 2**52`` 이지만 ``< 2**53`` 다)임을 고려하면, *N* 의 최적값은 "
"56입니다::"

#: ../Doc/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 ""
"즉, 56은 *J* 가 정확히 53비트가 되도록 만드는 *N* 의 유일한 값입니다. *J* 의 가능한 값 중 가장 좋은 것은 반올림한 "
"몫입니다::"

#: ../Doc/tutorial/floatingpoint.rst:246
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up::"
msgstr "나머지가 10의 절반보다 크므로, 가장 가까운 근삿값은 올림 해서 얻어집니다::"

#: ../Doc/tutorial/floatingpoint.rst:252
msgid ""
"Therefore the best possible approximation to 1/10 in 754 double precision"
" is::"
msgstr "따라서 754 배정밀도로 1/10 에 가장 가까운 근삿값은 다음과 같습니다::"

#: ../Doc/tutorial/floatingpoint.rst:256
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction "
"to::"
msgstr "분자와 분모를 둘로 나누면 다음과 같이 약분됩니다::"

#: ../Doc/tutorial/floatingpoint.rst:260
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 ""
"올림을 했기 때문에, 이것은 실제로 1/10 보다 약간 크다는 것에 유의하세요; 내림을 했다면, 몫이 1/10 보다 약간 작아졌을 것입니다."
" 그러나 어떤 경우에도 *정확하게* 1/10일 수는 없습니다!"

#: ../Doc/tutorial/floatingpoint.rst:264
msgid ""
"So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
"given above, the best 754 double approximation it can get::"
msgstr ""
"따라서 컴퓨터는 결코 1/10을 \"보지\" 못합니다: 볼 수 있는 것은 위에서 주어진 정확한 분수, 얻을 수 있는 최선의 754 배정밀도"
" 근삿값입니다::"

#: ../Doc/tutorial/floatingpoint.rst:270
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to "
"55 decimal digits::"
msgstr "그 분수에 10\\*\\*55를 곱하면, 55개의 십진 숫자를 볼 수 있습니다.::"

#: ../Doc/tutorial/floatingpoint.rst:276
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 ""
"이는 컴퓨터에 저장된 정확한 숫자가 십진수 "
"0.1000000000000000055511151231257827021181583404541015625와 같음을 의미합니다. 전체 십진법 "
"값을 표시하는 대신, 많은 언어(이전 버전의 파이썬 포함)는 결과를 17개의 유효숫자로 반올림합니다::"

#: ../Doc/tutorial/floatingpoint.rst:284
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations "
"easy::"
msgstr ":mod:`fractions` 와 :mod:`decimal` 모듈은 이 계산을 쉽게 만듭니다::"