9.5. "fractions" --- 分数
*************************

**源代码** Lib/fractions.py

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

"fractions" 模块支持分数运算。

分数实例可以由一对整数，一个分数，或者一个字符串构建而成。

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

   The first version requires that *numerator* and *denominator* are
   instances of "numbers.Rational" and returns a new "Fraction"
   instance with value "numerator/denominator". If *denominator* is
   "0", it raises a "ZeroDivisionError". The second version requires
   that *other_fraction* is an instance of "numbers.Rational" and
   returns a "Fraction" instance with the same value.  The next two
   versions accept either a "float" or a "decimal.Decimal" instance,
   and return a "Fraction" instance with exactly the same value.  Note
   that due to the usual issues with binary floating-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 or unicode instance. The usual
   form for this instance is:

      [sign] numerator ['/' denominator]

   where the optional "sign" may be either '+' or '-' and "numerator"
   and "denominator" (if present) are strings of decimal digits.  In
   addition, any string that represents a finite value and is accepted
   by the "float" constructor is also accepted by the "Fraction"
   constructor.  In either form the input string may also have leading
   and/or trailing whitespace. Here are some examples:

      >>> 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)

   The "Fraction" class inherits from the abstract base class
   "numbers.Rational", and implements all of the methods and
   operations from that class.  "Fraction" instances are hashable, and
   should be treated as immutable.  In addition, "Fraction" has the
   following properties and methods:

   在 3.2 版更改: The "Fraction" constructor now accepts "float" and
   "decimal.Decimal" instances.

   numerator

      最简分数形式的分子。

   denominator

      最简分数形式的分母。

   from_float(flt)

      This class method constructs a "Fraction" representing the exact
      value of *flt*, which must be a "float". Beware that
      "Fraction.from_float(0.3)" is not the same value as "Fraction(3,
      10)".

      注解: From Python 3.2 onwards, you can also construct a
        "Fraction" instance directly from a "float".

   from_decimal(dec)

      This class method constructs a "Fraction" representing the exact
      value of *dec*, which must be a "decimal.Decimal" instance.

      注解: From Python 3.2 onwards, you can also construct a
        "Fraction" instance directly from a "decimal.Decimal"
        instance.

   limit_denominator(max_denominator=1000000)

      Finds and returns the closest "Fraction" to "self" that has
      denominator at most max_denominator.  This method is useful for
      finding rational approximations to a given floating-point
      number:

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

      or for recovering a rational number that's represented as a
      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__()

      Returns the greatest "int" "<= self".  This method can also be
      accessed through the "math.floor()" function:

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

   __ceil__()

      Returns the least "int" ">= self".  This method can also be
      accessed through the "math.ceil()" function.

   __round__()
   __round__(ndigits)

      The first version returns the nearest "int" to "self", rounding
      half to even. The second version rounds "self" to the nearest
      multiple of "Fraction(1, 10**ndigits)" (logically, if "ndigits"
      is negative), again rounding half toward even.  This method can
      also be accessed through the "round()" function.

fractions.gcd(a, b)

   返回整数 *a* 和 *b* 的最大公约数。如果 *a* 或 *b* 之一非零，则
   "gcd(a, b)" 的绝对值是能同时整除 *a* 和 *b* 的最大整数。若 *b* 非零
   ，则 "gcd(a,b)" 与 *b* 同号；否则返回值与 *a* 同号。"gcd(0, 0)" 返
   回 "0"。

   3.5 版后已移除: 由 "math.gcd()" 取代.

参见:

  "numbers" 模块
     The abstract base classes making up the numeric tower.
