# `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]

  onde o `sign` opcional pode ser ‘+’ ou ‘-’ e `numerator` e `denominator` (se presente) são strings de dígitos decimais (sublinhados podem ser usados ​para delimitar dígitos como com literais integrais no código). Além disso, qualquer string que represente um valor finito e seja aceita pelo construtor `float` também é aceita pelo construtor `Fraction`. Em qualquer forma, a string de entrada também pode ter espaços em branco à esquerda e/ou à direita. Aqui estão alguns exemplos:

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

  A classe `Fraction` herda da classe base abstrata `numbers.Rational` e implementa todos os métodos e operações dessa classe. As instâncias de `Fraction` são hasheável e devem ser tratadas como imutáveis. Além disso, `Fraction` tem as seguintes propriedades e métodos:

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

  Alterado na versão 3.9: The `math.gcd()` function is now used to normalize the numerator and denominator. `math.gcd()` always return a `int` type. Previously, the GCD type depended on numerator and denominator.

  Alterado na versão 3.11: Sublinhados agora são permitidos ao criar uma instância `Fraction` a partir de uma string, seguindo as regras PEP 515.

  Alterado na versão 3.11: `Fraction` implementa `__int__` agora para satisfazer verificações de instância `typing.SupportsInt`.

  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.

  classmethod from_float(flt)

    Construtor alternativo que aceita apenas instâncias de `float` ou `numbers.Integral`. Esteja ciente de que `Fraction.from_float(0.3)` não é o mesmo valor que `Fraction(3, 10)`.

    Nota

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

  classmethod from_decimal(dec)

    Construtor alternativo que aceita somente instâncias de `decimal.Decimal` ou `numbers.Integral`.

    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()`.

Ver também

Módulo `numbers`

  As classes base abstratas que compõem a torre numérica.