"fractions" --- 유리수
**********************

**소스 코드:** Lib/fractions.py

======================================================================

"fractions" 모듈은 유리수 산술을 지원합니다.

Fraction 인스턴스는 한 쌍의 정수, 다른 유리수 또는 문자열로 만들 수 있
습니다.

class fractions.Fraction(numerator=0, denominator=1)
class fractions.Fraction(other_fraction)
class fractions.Fraction(float)
class fractions.Fraction(decimal)
class fractions.Fraction(string)

   첫 번째 버전에서는 *numerator* 와 *denominator*가
   "numbers.Rational"의 인스턴스이고, "numerator/denominator" 값의 새
   "Fraction" 인스턴스를 반환합니다. *denominator*가 "0"이면,
   "ZeroDivisionError"를 발생시킵니다. 두 번째 버전에서는
   *other_fraction*이 "numbers.Rational"의 인스턴스이고, 같은 값을 가
   진 "Fraction" 인스턴스를 반환합니다. 다음 두 버전은 "float" 나
   "decimal.Decimal" 인스턴스를 받아들이고, 정확히 같은 값의
   "Fraction" 인스턴스를 반환합니다. 이진 부동 소수점(부동 소수점 산술
   : 문제점 및 한계 참조)의 일반적인 문제로 인해, "Fraction(1.1)"에 대
   한 인자가 정확히 11/10이 아니므로, "Fraction(1.1)"는 흔히 기대하듯
   이 "Fraction(11, 10)"를 반환하지 *않습니다*. (그러나 아래의
   "limit_denominator()" 메서드에 대한 설명서를 참조하십시오.) 생성자
   의 마지막 버전은 문자열이나 유니코드 인스턴스를 기대합니다. 이 인스
   턴스의 일반적인 형식은 다음과 같습니다:

      [sign] numerator ['/' denominator]

   이때, 선택적 "sign"은 '+' 나 '-'일 수 있으며 "numerator" 와
   "denominator"(있다면)는 십진수 문자열입니다. 또한, 유한한 값을 나타
   내고 "float" 생성자에서 허용하는 모든 문자열은 "Fraction" 생성자에
   서도 허용됩니다. 모든 형식에서, 입력 문자열에는 선행과/이나 후행 공
   백이 있을 수도 있습니다. 여기 예제가 있습니다:

      >>> from fractions import Fraction
      >>> Fraction(16, -10)
      Fraction(-8, 5)
      >>> Fraction(123)
      Fraction(123, 1)
      >>> Fraction()
      Fraction(0, 1)
      >>> Fraction('3/7')
      Fraction(3, 7)
      >>> Fraction(' -3/7 ')
      Fraction(-3, 7)
      >>> Fraction('1.414213 \t\n')
      Fraction(1414213, 1000000)
      >>> Fraction('-.125')
      Fraction(-1, 8)
      >>> Fraction('7e-6')
      Fraction(7, 1000000)
      >>> Fraction(2.25)
      Fraction(9, 4)
      >>> Fraction(1.1)
      Fraction(2476979795053773, 2251799813685248)
      >>> from decimal import Decimal
      >>> Fraction(Decimal('1.1'))
      Fraction(11, 10)

   "Fraction" 클래스는 추상 베이스 클래스 "numbers.Rational"를 상속하
   며, 그 클래스의 모든 메서드와 연산을 구현합니다. "Fraction" 인스턴
   스는 해시 가능하고, 불변으로 취급해야 합니다. 또한, "Fraction"에는
   다음과 같은 프로퍼티와 메서드가 있습니다:

   버전 3.2에서 변경: "Fraction" 생성자는 이제 "float"와
   "decimal.Decimal" 인스턴스를 받아들입니다.

   numerator

      기약 분수로 나타낼 때 Fraction의 분자.

   denominator

      기약 분수로 나타낼 때 Fraction의 분모.

   as_integer_ratio()

      비율이 Fraction과 같고 양의 분모를 갖는 두 정수의 튜플을 반환합
      니다.

      버전 3.8에 추가.

   from_float(flt)

      이 클래스 메서드는 "float" *flt*의 정확한 값을 나타내는
      "Fraction"을 생성합니다. "Fraction.from_float(0.3)"가
      "Fraction(3, 10)"와 같은 값이 아니라는 점에 유의하십시오.

      참고:

        파이썬 3.2 이상에서는, "float"에서 직접 "Fraction" 인스턴스를
        생성할 수도 있습니다.

   from_decimal(dec)

      이 클래스 메서드는 "decimal.Decimal" 인스턴스 *dec*의 정확한 값
      을 나타내는 "Fraction"을 생성합니다.

      참고:

        파이썬 3.2 이상에서는, "decimal.Decimal" 인스턴스에서 직접
        "Fraction" 인스턴스를 생성할 수도 있습니다.

   limit_denominator(max_denominator=1000000)

      분모가 최대 max_denominator인 "self"에 가장 가까운 "Fraction"을
      찾아서 반환합니다. 이 메서드는 주어진 부동 소수점 수에 대한 유리
      한 근사를 찾는 데 유용합니다:

      >>> from fractions import Fraction
      >>> Fraction('3.1415926535897932').limit_denominator(1000)
      Fraction(355, 113)

      또는 float로 표현된 유리수를 복구할 때 유용합니다:

      >>> from math import pi, cos
      >>> Fraction(cos(pi/3))
      Fraction(4503599627370497, 9007199254740992)
      >>> Fraction(cos(pi/3)).limit_denominator()
      Fraction(1, 2)
      >>> Fraction(1.1).limit_denominator()
      Fraction(11, 10)

   __floor__()

      가장 큰 "int" "<= self"를 반환합니다. 이 메서드는 "math.floor()"
      함수를 통해 액세스할 수도 있습니다:

      >>> from math import floor
      >>> floor(Fraction(355, 113))
      3

   __ceil__()

      가장 작은 "int" ">= self"를 반환합니다. 이 메서드는
      "math.ceil()" 함수를 통해 액세스할 수도 있습니다.

   __round__()
   __round__(ndigits)

      첫 번째 버전은 "self"에 가장 가까운 "int"를 반환하는데, 절반은
      짝수로 자리 올림 합니다. 두 번째 버전은 "self"를 가장 가까운
      "Fraction(1, 10**ndigits)"의 배수로 자리 올림 하는데 ("ndigits"
      가 음수면 논리적으로), 역시 짝수로 자리 올림 합니다. 이 메서드는
      "round()" 함수를 통해 액세스할 수도 있습니다.

fractions.gcd(a, b)

   정수 *a*와 *b*의 최대 공약수를 반환합니다. *a* 나 *b*가 0이 아니면,
   "gcd(a, b)"의 절댓값은 *a*와 *b*를 모두 나누는 가장 큰 정수입니다.
   *b*가 0이 아니면, "gcd(a,b)"는 *b*와 같은 부호를 가집니다; 그렇지
   않으면 *a*의 부호를 취합니다. "gcd(0, 0)"는 "0"을 반환합니다.

   버전 3.5부터 폐지: 대신 "math.gcd()"를 사용하십시오.

더 보기:

  모듈 "numbers"
     숫자 계층을 구성하는 추상 베이스 클래스.
