"fractions" --- 有理数
**********************

**ソースコード:** Lib/fractions.py

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

The "fractions" module provides support for rational number
arithmetic.

A Fraction instance can be constructed from a pair of rational
numbers, from a single number, or from a string.

class fractions.Fraction(numerator=0, denominator=1)
class fractions.Fraction(number)
class fractions.Fraction(string)

   The first version requires that *numerator* and *denominator* are
   instances of "numbers.Rational" and returns a new "Fraction"
   instance with a value equal to "numerator/denominator". If
   *denominator* is zero, it raises a "ZeroDivisionError".

   The second version requires that *number* is an instance of
   "numbers.Rational" or has the "as_integer_ratio()" method (this
   includes "float" and "decimal.Decimal"). It returns a "Fraction"
   instance with exactly the same value. Assumed, that the
   "as_integer_ratio()" method returns a pair of coprime integers and
   last one is positive. Note that due to the usual issues with binary
   point (see 浮動小数点演算、その問題と制限), the argument to
   "Fraction(1.1)" is not exactly equal to 11/10, and so
   "Fraction(1.1)" does *not* return "Fraction(11, 10)" as one might
   expect. (But see the documentation for the "limit_denominator()"
   method below.)

   The last version of the constructor expects a string. The usual
   form for this instance is:

      [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" インスタンスは *ハッ
   シュ可能* で、不変 (immutable) であるものとして扱われます。加えて、
   "Fraction" には以下のプロパティとメソッドがあります:

   バージョン 3.2 で変更: "Fraction" のコンストラクタが "float" および
   "decimal.Decimal" インスタンスを受け付けるようになりました。

   バージョン 3.9 で変更: The "math.gcd()" function is now used to
   normalize the *numerator* and *denominator*. "math.gcd()" always
   returns an "int" type. Previously, the GCD type depended on
   *numerator* and *denominator*.

   バージョン 3.11 で変更: Underscores are now permitted when creating
   a "Fraction" instance from a string, following **PEP 515** rules.

   バージョン 3.11 で変更: "Fraction" implements "__int__" now to
   satisfy "typing.SupportsInt" instance checks.

   バージョン 3.12 で変更: Space is allowed around the slash for
   string inputs: "Fraction('2 / 3')".

   バージョン 3.12 で変更: "Fraction" instances now support float-
   style formatting, with presentation types ""e"", ""E"", ""f"",
   ""F"", ""g"", ""G"" and ""%""".

   バージョン 3.13 で変更: Formatting of "Fraction" instances without
   a presentation type now supports fill, alignment, sign handling,
   minimum width and grouping.

   バージョン 3.14 で変更: The "Fraction" constructor now accepts any
   objects with the "as_integer_ratio()" method.

   numerator

      有理数を既約分数で表したときの分子。

   denominator

      Denominator of the Fraction in lowest terms. Guaranteed to be
      positive.

   as_integer_ratio()

      Return a tuple of two integers, whose ratio is equal to the
      original Fraction.  The ratio is in lowest terms and has a
      positive denominator.

      Added in version 3.8.

   is_integer()

      Return "True" if the Fraction is an integer.

      Added in version 3.12.

   classmethod from_float(f)

      Alternative constructor which only accepts instances of "float"
      or "numbers.Integral". Beware that "Fraction.from_float(0.3)" is
      not the same value as "Fraction(3, 10)".

      注釈:

        Python 3.2 以降では、 "float" から直接 "Fraction" インスタンス
        を構築できるようになりました。

   classmethod from_decimal(dec)

      Alternative constructor which only accepts instances of
      "decimal.Decimal" or "numbers.Integral".

      注釈:

        Python 3.2 以降では、 "decimal.Decimal" インスタンスから直接
        "Fraction" インスタンスを構築できるようになりました。

   classmethod from_number(number)

      Alternative constructor which only accepts instances of
      "numbers.Integral", "numbers.Rational", "float" or
      "decimal.Decimal", and objects with the "as_integer_ratio()"
      method, but not strings.

      Added in version 3.14.

   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()" 関数からでもアクセス
      できます。

   __format__(format_spec, /)

      Provides support for formatting of "Fraction" instances via the
      "str.format()" method, the "format()" built-in function, or
      Formatted string literals.

      If the "format_spec" format specification string does not end
      with one of the presentation types "'e'", "'E'", "'f'", "'F'",
      "'g'", "'G'" or "'%'" then formatting follows the general rules
      for fill, alignment, sign handling, minimum width, and grouping
      as described in the format specification mini-language. The
      "alternate form" flag "'#'" is supported: if present, it forces
      the output string to always include an explicit denominator,
      even when the value being formatted is an exact integer. The
      zero-fill flag "'0'" is not supported.

      If the "format_spec" format specification string ends with one
      of the presentation types "'e'", "'E'", "'f'", "'F'", "'g'",
      "'G'" or "'%'" then formatting follows the rules outlined for
      the "float" type in the Format specification mini-language
      section.

      ここに例があります:

         >>> from fractions import Fraction
         >>> format(Fraction(103993, 33102), '_')
         '103_993/33_102'
         >>> format(Fraction(1, 7), '.^+10')
         '...+1/7...'
         >>> format(Fraction(3, 1), '')
         '3'
         >>> format(Fraction(3, 1), '#')
         '3/1'
         >>> format(Fraction(1, 7), '.40g')
         '0.1428571428571428571428571428571428571429'
         >>> format(Fraction('1234567.855'), '_.2f')
         '1_234_567.86'
         >>> f"{Fraction(355, 113):*>20.6e}"
         '********3.141593e+00'
         >>> old_price, new_price = 499, 672
         >>> "{:.2%} price increase".format(Fraction(new_price, old_price) - 1)
         '34.67% price increase'

参考:

  "numbers" モジュール
     数値の塔を作り上げる抽象基底クラス。
