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

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

   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
   Floating-Point Arithmetic:  Issues and Limitations), 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]

   donde el "sign" opcional puede ser '+' o '-' y "numerator" y
   "denominator" (si están presentes) son cadenas de caracteres de
   dígitos decimales (guiones bajos se pueden usar para delimitar
   dígitos como con las integrales literales en el código). 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 propiedades y métodos:

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

   Distinto en la versión 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*.

   Distinto en la versión 3.11: Ahora se permiten guiones bajos al
   crear una instancia de "Fraction" a partir de una cadena de
   caracteres, siguiendo las reglas de **PEP 515**.

   Distinto en la versión 3.11: "Fraction" ahora implementa "__int__"
   para satisfacer las comprobaciones de instancia de
   "typing.SupportsInt".

   Distinto en la versión 3.12: Se permite espacio alrededor de la
   barra para entrada de cadena de caracteres: "Fraction('2 / 3')".

   Distinto en la versión 3.12: "Fraction" instancias ahora apoya
   formato de estilo flotante, con tipos de presentación ""e"", ""E"",
   ""f"", ""F"", ""g"", ""G"" and ""%""".

   Distinto en la versión 3.13: Formatting of "Fraction" instances
   without a presentation type now supports fill, alignment, sign
   handling, minimum width and grouping.

   numerator

      Numerador de la fracción irreducible.

   denominator

      Denominador de la fracción irreducible.

   as_integer_ratio()

      Retorna una tupla de dos números enteros, cuyo relación es igual
      a la fracción original.La relación está en términos más bajos y
      tiene un denominador positivo.

      Added in version 3.8.

   is_integer()

      Retorna "True" si la fracción es un número entero.

      Added in version 3.12.

   classmethod from_float(flt)

      Constructor alternativo que solo acepta instancias de "float" o
      "numbers.Integral". Ten cuidado que "Fraction.from_float(0.3)"
      no es lo mismo  que "Fraction(3, 10)".

      Nota:

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

   classmethod from_decimal(dec)

      Constructor alternativo que solo acepta instancias de
      "decimal.Decimal" o "numbers.Integral".

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

   __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 Especificación de formato Mini-Lenguaje
      section.

      Aquí hay unos ejemplos:

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

Ver también:

  Módulo "numbers"
     Las clases base abstractas que representan la jerarquía de
     números.
