"fractions" --- Rational numbers
********************************

**Código-fonte:** Lib/fractions.py

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

O módulo "fractions" fornece suporte para aritmética de números
racionais.

Uma instância de Fraction pode ser construída a partir de um par de
números inteiros, de outro número racional ou de uma string.

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
   Aritmética de ponto flutuante: problemas e limitações), 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:

   Alterado na versão 3.2: O construtor "Fraction" agora aceita
   instâncias "float" e "decimal.Decimal".

   numerator

      Numerador de Fraction no menor termo.

   denominator

      Denominador de Fraction no menor termo.

   as_integer_ratio()

      Return a tuple of two integers, whose ratio is equal to the
      Fraction and with a positive denominator.

      Novo na versão 3.8.

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

      Nota:

        A partir do Python 3.2, você também pode construir uma
        instância "Fraction" diretamente de um "float".

   from_decimal(dec)

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

      Nota:

        A partir do Python 3.2, você também pode construir uma
        instância "Fraction" diretamente de uma instância de
        "decimal.Decimal".

   limit_denominator(max_denominator=1000000)

      Encontra e retorna o "Fraction" mais próximo de "self" que tem
      denominador no máximo max_denominator. Este método é útil para
      encontrar aproximações racionais para um dado número de ponto
      flutuante:

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

      ou para recuperar um número racional que é representado como um
      ponto flutuante:

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

      Retorna o maior "int" "<= self". Este método também pode ser
      acessado por meio da função "math.floor()":

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

   __ceil__()

      Retorna o menor "int" ">= self". Este método também pode ser
      acessado por meio da função "math.ceil()".

   __round__()
   __round__(ndigits)

      A primeira versão retorna o "int" mais próximo de "self",
      arredondando a metade para par. A segunda versão arredonda
      "self" para o múltiplo mais próximo de "Fraction(1,
      10**ndigits)" (logicamente, se "ndigits" for negativo),
      novamente arredondando a metade para par. Este método também
      pode ser acessado por meio da função "round()".

fractions.gcd(a, b)

   Return the greatest common divisor of the integers *a* and *b*.  If
   either *a* or *b* is nonzero, then the absolute value of "gcd(a,
   b)" is the largest integer that divides both *a* and *b*.
   "gcd(a,b)" has the same sign as *b* if *b* is nonzero; otherwise it
   takes the sign of *a*.  "gcd(0, 0)" returns "0".

   Obsoleto desde a versão 3.5: Use "math.gcd()" instead.

Ver também:

  Módulo "numbers"
     As classes base abstratas que compõem a torre numérica.
