854 - remove fuzzy flags

Author: flowdas

library/numbers.po

@@ -3,7 +3,6 @@
 # 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"
@@ -18,23 +17,21 @@ msgstr ""
 "Generated-By: Babel 2.17.0\n"
 
 #: ../../library/numbers.rst:2
-#, fuzzy
 msgid ":mod:`!numbers` --- Numeric abstract base classes"
-msgstr ":mod:`numbers` --- 숫자 추상 베이스 클래스"
+msgstr ":mod:`!numbers` --- 숫자 추상 베이스 클래스"
 
 #: ../../library/numbers.rst:7
 msgid "**Source code:** :source:`Lib/numbers.py`"
 msgstr "**소스 코드:** :source:`Lib/numbers.py`"
 
 #: ../../library/numbers.rst:11
-#, fuzzy
 msgid ""
 "The :mod:`!numbers` module (:pep:`3141`) defines a hierarchy of numeric "
 ":term:`abstract base classes <abstract base class>` which progressively "
 "define more operations.  None of the types defined in this module are "
 "intended to be instantiated."
 msgstr ""
-":mod:`numbers` 모듈(:pep:`3141`)은 숫자에 대한 :term:`추상 베이스 클래스 <abstract base "
+":mod:`!numbers` 모듈(:pep:`3141`)은 숫자에 대한 :term:`추상 베이스 클래스 <abstract base "
 "class>` 의 계층 구조를 정의합니다. 계층 구조가 깊어질수록 더 많은 연산이 정의되어 있습니다. 이 모듈에 정의된 모든 형은 "
 "인스턴스로 만들 수 없습니다."
 
@@ -52,7 +49,6 @@ msgid "The numeric tower"
 msgstr "숫자 계층"
 
 #: ../../library/numbers.rst:27
-#, fuzzy
 msgid ""
 "Subclasses of this type describe complex numbers and include the "
 "operations that work on the built-in :class:`complex` type. These are: "
@@ -63,8 +59,8 @@ msgid ""
 msgstr ""
 "이 서브 클래스는 복소수를 표현하고 내장 :class:`complex` 형에 사용되는 연산을 포함합니다. 여기에는 "
 ":class:`complex` 와 :class:`bool` 형으로의 변환과 :attr:`.real`, :attr:`.imag`, "
-"``+``, ``-``, ``*``, ``/``, :func:`abs`, :meth:`conjugate`, ``==``, "
-"``!=`` 이 포함됩니다. ``-`` 와 ``!=`` 를 제외하고는 모두 추상입니다. "
+"``+``, ``-``, ``*``, ``/``, ``**``, :func:`abs`, :meth:`conjugate`, "
+"``==``, ``!=`` 이 포함됩니다. ``-`` 와 ``!=`` 를 제외하고는 모두 추상입니다."
 
 #: ../../library/numbers.rst:35
 msgid "Abstract. Retrieves the real component of this number."
@@ -81,11 +77,10 @@ msgid ""
 msgstr "추상 메서드. 켤레 복소수를 반환합니다. 예를 들어 ``(1+3j).conjugate() == (1-3j)`` 입니다."
 
 #: ../../library/numbers.rst:49
-#, fuzzy
 msgid ""
 "To :class:`Complex`, :class:`!Real` adds the operations that work on real"
 " numbers."
-msgstr ":class:`Real` 클래스는 :class:`Complex` 클래스에 실수 연산을 추가합니다."
+msgstr ":class:`!Real` 클래스는 :class:`Complex` 클래스에 실수 연산을 추가합니다."
 
 #: ../../library/numbers.rst:52
 msgid ""
@@ -106,15 +101,14 @@ msgstr ""
 ":meth:`~Complex.conjugate` 를 위한 기본값을 제공합니다."
 
 #: ../../library/numbers.rst:62
-#, fuzzy
 msgid ""
 "Subtypes :class:`Real` and adds :attr:`~Rational.numerator` and "
 ":attr:`~Rational.denominator` properties. It also provides a default for "
 ":func:`float`."
 msgstr ""
 ":class:`Real` 의 하위 형이고 :attr:`~Rational.numerator` 와 "
-":attr:`~Rational.denominator` 프로퍼티가 추가됩니다. 이 프로퍼티는 기약 분수의 값이어야 합니다. 또한 "
-":func:`float` 함수를 위한 기본값으로 사용됩니다."
+":attr:`~Rational.denominator` 프로퍼티가 추가됩니다. 또한 :func:`float` 함수를 위한 기본값을 "
+"제공합니다."
 
 #: ../../library/numbers.rst:66
 msgid ""
@@ -128,7 +122,6 @@ msgid "Abstract."
 msgstr "프로퍼티(추상 메서드)"
 
 #: ../../library/numbers.rst:81
-#, fuzzy
 msgid ""
 "Subtypes :class:`Rational` and adds a conversion to :class:`int`.  "
 "Provides defaults for :func:`float`, :attr:`~Rational.numerator`, and "
@@ -138,16 +131,14 @@ msgid ""
 msgstr ""
 ":class:`Rational` 의 하위 형이고 :class:`int` 클래스로 변환 기능이 추가됩니다. :func:`float`,"
 " :attr:`~Rational.numerator`, :attr:`~Rational.denominator` 를 위한 기본값을 "
-"제공합니다. ``**`` 를 위한 메서드와 비트 연산 ``<<``, ``>>``, ``&``, ``^``, ``|``, ``~`` "
-"를 추가합니다."
+"제공합니다. 모듈러스가 있는 :func:`pow`\\를 위한 추상 메서드와 비트 연산 ``<<``, ``>>``, ``&``, "
+"``^``, ``|``, ``~`` 를 추가합니다."
 
 #: ../../library/numbers.rst:89
-#, fuzzy
 msgid "Notes for type implementers"
-msgstr "형 구현을 위한 주의 사항"
+msgstr "형 구현자를 위한 주의 사항"
 
 #: ../../library/numbers.rst:91
-#, fuzzy
 msgid ""
 "Implementers should be careful to make equal numbers equal and hash them "
 "to the same values. This may be subtle if there are two different "
@@ -172,6 +163,16 @@ msgid ""
 "        # simple fractions.\n"
 "        return hash((self.numerator, self.denominator))"
 msgstr ""
+"def __hash__(self):\n"
+"    if self.denominator == 1:\n"
+"        # 정수입니다.\n"
+"        return hash(self.numerator)\n"
+"    # 비싼 검사이지만, 확실히 맞습니다.\n"
+"    if self == float(self):\n"
+"        return hash(float(self))\n"
+"    else:\n"
+"        # 간단한 분수에서의 높은 충돌률을 피하기위해 튜플의 해시를 사용합니다.\n"
+"        return hash((self.numerator, self.denominator))"
 
 #: ../../library/numbers.rst:110
 msgid "Adding More Numeric ABCs"
@@ -191,13 +192,14 @@ msgid ""
 "class MyFoo(Complex): ...\n"
 "MyFoo.register(Real)"
 msgstr ""
+"class MyFoo(Complex): ...\n"
+"MyFoo.register(Real)"
 
 #: ../../library/numbers.rst:124
 msgid "Implementing the arithmetic operations"
 msgstr "산술 연산 구현"
 
 #: ../../library/numbers.rst:126
-#, fuzzy
 msgid ""
 "We want to implement the arithmetic operations so that mixed-mode "
 "operations either call an implementation whose author knew about the "
@@ -207,8 +209,9 @@ msgid ""
 "defined as::"
 msgstr ""
 "다른 형에 대한 연산은 두 인자의 형에 관해 알고 있는 구현을 호출하거나 두 인자를 가장 비슷한 내장형으로 변환하여 연산하도록 산술"
-" 연산을 구현하는 것이 좋습니다. :class:`Integral` 클래스의 하위 형일 경우에 :meth:`__add__` 와 "
-":meth:`__radd__` 메서드는 다음과 같이 정의되어야 함을 의미합니다::"
+" 연산을 구현하는 것이 좋습니다. :class:`Integral` 클래스의 하위 형일 경우에 "
+":meth:`~object.__add__` 와 :meth:`~object.__radd__` 메서드는 다음과 같이 정의되어야 함을 "
+"의미합니다::"
 
 #: ../../library/numbers.rst:133
 msgid ""
@@ -236,6 +239,29 @@ msgid ""
 "        else:\n"
 "            return NotImplemented"
 msgstr ""
+"class MyIntegral(Integral):\n"
+"\n"
+"    def __add__(self, other):\n"
+"        if isinstance(other, MyIntegral):\n"
+"            return do_my_adding_stuff(self, other)\n"
+"        elif isinstance(other, OtherTypeIKnowAbout):\n"
+"            return do_my_other_adding_stuff(self, other)\n"
+"        else:\n"
+"            return NotImplemented\n"
+"\n"
+"    def __radd__(self, other):\n"
+"        if isinstance(other, MyIntegral):\n"
+"            return do_my_adding_stuff(other, self)\n"
+"        elif isinstance(other, OtherTypeIKnowAbout):\n"
+"            return do_my_other_adding_stuff(other, self)\n"
+"        elif isinstance(other, Integral):\n"
+"            return int(other) + int(self)\n"
+"        elif isinstance(other, Real):\n"
+"            return float(other) + float(self)\n"
+"        elif isinstance(other, Complex):\n"
+"            return complex(other) + complex(self)\n"
+"        else:\n"
+"            return NotImplemented"
 
 #: ../../library/numbers.rst:158
 msgid ""
@@ -251,34 +277,31 @@ msgstr ""
 "비슷하게 ``b : B <: Complex`` 입니다. ``a + b`` 인 경우를 생각해 보겠습니다:"
 
 #: ../../library/numbers.rst:165
-#, fuzzy
 msgid ""
 "If ``A`` defines an :meth:`~object.__add__` which accepts ``b``, all is "
 "well."
-msgstr "만약 ``A`` 가 ``b`` 를 받는 :meth:`__add__` 메서드를 정의했다면 모든 것이 문제없이 처리됩니다."
+msgstr "만약 ``A`` 가 ``b`` 를 받는 :meth:`~object.__add__` 메서드를 정의했다면 모든 것이 문제없이 처리됩니다."
 
 #: ../../library/numbers.rst:167
-#, fuzzy
 msgid ""
 "If ``A`` falls back to the boilerplate code, and it were to return a "
 "value from :meth:`~object.__add__`, we'd miss the possibility that ``B`` "
 "defines a more intelligent :meth:`~object.__radd__`, so the boilerplate "
 "should return :data:`NotImplemented` from :meth:`!__add__`. (Or ``A`` may"
 " not implement :meth:`!__add__` at all.)"
 msgstr ""
-"``A`` 가 기본구조 코드로 진입하고 :meth:`__add__`\\로 부터 어떤 값을 반환한다면 ``B`` 가 똑똑하게 정의한 "
-":meth:`__radd__` 메서드를 놓칠 수 있습니다. 이를 피하려면 기본구조는 :meth:`__add__` 에서 "
-":const:`NotImplemented` 를 반환해야 합니다. (또는 ``A`` 가 :meth:`__add__` 메서드를 전혀 "
-"구현하지 않을 수도 있습니다.)"
+"``A`` 가 기본구조 코드로 진입하고 :meth:`~object.__add__`\\로 부터 어떤 값을 반환한다면 ``B`` 가 "
+"똑똑하게 정의한 :meth:`~object.__radd__` 메서드를 놓칠 수 있습니다. 이를 피하려면 기본구조는 "
+":meth:`!__add__` 에서 :data:`NotImplemented` 를 반환해야 합니다. (또는 ``A`` 가 "
+":meth:`!__add__` 메서드를 전혀 구현하지 않을 수도 있습니다.)"
 
 #: ../../library/numbers.rst:173
-#, fuzzy
 msgid ""
 "Then ``B``'s :meth:`~object.__radd__` gets a chance. If it accepts ``a``,"
 " all is well."
 msgstr ""
-"그다음 ``B`` 의 :meth:`__radd__` 메서드가 기회를 얻습니다. 이 메서드가 ``a`` 를 받을 수 있다면 모든 것이"
-" 문제없이 처리됩니다."
+"그다음 ``B`` 의 :meth:`~object.__radd__` 메서드가 기회를 얻습니다. 이 메서드가 ``a`` 를 받을 수 "
+"있다면 모든 것이 문제없이 처리됩니다."
 
 #: ../../library/numbers.rst:175
 msgid ""
@@ -297,16 +320,15 @@ msgstr ""
 "이 인스턴스를 처리할 수 있습니다."
 
 #: ../../library/numbers.rst:183
-#, fuzzy
 msgid ""
 "If ``A <: Complex`` and ``B <: Real`` without sharing any other "
 "knowledge, then the appropriate shared operation is the one involving the"
 " built in :class:`complex`, and both :meth:`~object.__radd__` s land "
 "there, so ``a+b == b+a``."
 msgstr ""
 "만약 어떤 것도 공유하지 않는 ``A <: Complex`` 와 ``B <: Real`` 라면 적절한 공유 연산(shared "
-"operation)은 내장 :class:`complex` 클래스에 연관된 것입니다. 양쪽의 :meth:`__radd__` 메서드가 "
-"여기에 해당하므로 ``a+b == b+a`` 가 됩니다."
+"operation)은 내장 :class:`complex` 클래스에 연관된 것입니다. 양쪽의 "
+":meth:`~object.__radd__` 메서드가 여기에 해당하므로 ``a+b == b+a`` 가 됩니다."
 
 #: ../../library/numbers.rst:188
 msgid ""
@@ -359,4 +381,41 @@ msgid ""
 "\n"
 "# ..."
 msgstr ""
+"def _operator_fallbacks(monomorphic_operator, fallback_operator):\n"
+"    def forward(a, b):\n"
+"        if isinstance(b, (int, Fraction)):\n"
+"            return monomorphic_operator(a, b)\n"
+"        elif isinstance(b, float):\n"
+"            return fallback_operator(float(a), b)\n"
+"        elif isinstance(b, complex):\n"
+"            return fallback_operator(complex(a), b)\n"
+"        else:\n"
+"            return NotImplemented\n"
+"    forward.__name__ = '__' + fallback_operator.__name__ + '__'\n"
+"    forward.__doc__ = monomorphic_operator.__doc__\n"
+"\n"
+"    def reverse(b, a):\n"
+"        if isinstance(a, Rational):\n"
+"            # 정수를 포함합니다.\n"
+"            return monomorphic_operator(a, b)\n"
+"        elif isinstance(a, Real):\n"
+"            return fallback_operator(float(a), float(b))\n"
+"        elif isinstance(a, Complex):\n"
+"            return fallback_operator(complex(a), complex(b))\n"
+"        else:\n"
+"            return NotImplemented\n"
+"    reverse.__name__ = '__r' + fallback_operator.__name__ + '__'\n"
+"    reverse.__doc__ = monomorphic_operator.__doc__\n"
+"\n"
+"    return forward, reverse\n"
+"\n"
+"def _add(a, b):\n"
+"    \"\"\"a + b\"\"\"\n"
+"    return Fraction(a.numerator * b.denominator +\n"
+"                    b.numerator * a.denominator,\n"
+"                    a.denominator * b.denominator)\n"
+"\n"
+"__add__, __radd__ = _operator_fallbacks(_add, operator.add)\n"
+"\n"
+"# ..."