# `fractions` — Números racionales

Source code: Lib/fractions.py

El módulo `fractions` provee soporte para aritmética de números racionales.

Una instancia de Fraction puede construirse desde dos enteros, desde otro número racional, o desde una cadena de caracteres.

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

  La primera versión necesita que numerator y denominator sean instancias de `numbers.Rational` y retorna una nueva instancia de `Fraction` con valor `numerator/denominator`. Si denominator es `0`, esto arrojará un error `ZeroDivisionError`. La segunda versión necesita que other_fraction sea una instancia de `numbers.Rational` y retorna una instancia `Fraction` con el mismo valor. Las restantes dos versiones aceptan igualmente instancias `float` o `decimal.Decimal` y retornan una instancia `Fraction` con exactamente el mismo valor. Nota que debido a los problemas usuales con la representación binaria en punto flotante (ver Aritmética de Punto Flotante: Problemas y Limitaciones), el argumento de `Fraction(1.1)` no es exactamente igual a 11/10, por lo que `Fraction(1.1)` no retorna `Fraction(11, 10)` como uno esperaría. (Mira la documentación para el método `limit_denominator()` abajo.) La última versión del constructor espera una cadena de caracteres o una instancia Unicode. La forma usual para esta instancia es:

      [sign] numerator ['/' denominator]

  donde el `sign` opcional puede ser “+” o “-“ y `numerator` y `denominator` (si están presentes) son cadenas de caracteres de dígitos decimales. Además, cualquier cadena de caracteres que represente un valor finito y sea aceptado por el constructor de `float` también es aceptado por el constructor de `Fraction`. En cualquier caso, la cadena de caracteres de entrada también puede tener espacios en blanco iniciales y / o finales. Aquí hay unos ejemplos:

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

  La clase `Fraction` hereda de la clase base abstracta `numbers.Rational`, e implementa todos los métodos y operaciones de esa clase. Las instancias `Fraction` son hashable, y deben ser tratadas como inmutables. Adicionalmente `Fraction` tiene los siguientes métodos y propiedades:

  Distinto en la versión 3.2: El constructor de `Fraction` ahora acepta instancias de `float` y `decimal`.

  `numerator`

    Numerador de la fracción irreducible.

  `denominator`

    Denominador de la fracción irreducible.

  `as_integer_ratio`()

    Retorna una tupla de dos enteros, cuyo ratio es igual a la fracción y con un denominador positivo.

    Nuevo en la versión 3.8.

  `from_float`(flt)

    Este método de clase construye una instancia de `Fraction` representando el valor exacto de flt que debe ser un `float`. Ten cuidado, observa que `Fraction.from_float(0.3)` no es el mismo valor que `Fraction(3, 10)`.

    Nota

    Desde Python 3.2 en adelante, puedes construir una instancia `Fraction` directamente desde `float`.

  `from_decimal`(dec)

    Este método de clase construye una instancia de `Fraction` representando el valor exacto de dec, que debe ser una instancia de `decimal.Decimal`.

    Nota

    Desde Python 3.2 en adelante, puedes construir una instancia `Fraction` directamente desde una instancia `decimal.Decimal`.

  `limit_denominator`(max_denominator=1000000)

    Busca y retorna la instancia de `Fraction` mas cercana a `self` que tenga como denominador max_denominator. Este método es útil para encontrar aproximaciones racionales a un número en punto flotante determinado:

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

    o para recuperar un numero racional que esta representado como flotante:

        >>> 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 el máximo `int` `<= self`. Este método puede accederse también a través de la función `math.floor()`:

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

  `__ceil__`()

    Retorna el mínimo `int` `>= self`. Este método puede accederse también a través de la función `math.ceil()`.

  `__round__`()
  `__round__`(ndigits)

    La primera versión retorna el valor `int` mas cercano a `self` redondeando mitades al valor par. La segunda versión redondea `self` al múltiplo mas cercano de `Fraction(1, 10**ndigits)` (lógicamente, si `ndigits` es negativo), nuevamente redondeando mitades al valor par. Este método también puede accederse a través de la función `round()`.

`fractions.``gcd`(a, b)

  Retorna el máximo común divisor de los enteros a y b. Si a o b no son cero, entonces el valor absoluto de `gcd(a, b)` es el entero mas grande que divide ambos, a y b. `gcd(a,b)` tiene el mismo signo que b si b no es cero; sino toma el signo de a. `gcd(0, 0)` retorna `0`.

  Obsoleto desde la versión 3.5: Usa en cambio la función `math.gcd()`.

Ver también

Módulo `numbers`

  Las clases base abstractas que representan la jerarquía de números.