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)

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:

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: Space is allowed around the slash for string inputs: Fraction('2 / 3').

Distinto en la versión 3.12: Fraction instances now support float-style formatting, with presentation types "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()

Return a tuple of two integers, whose ratio is equal to the original Fraction. The ratio is in lowest terms and has a positive denominator.

Added in version 3.8.

is_integer()

Return True if the Fraction is an integer.

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.

Here are some examples:

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