fractions module provides support for rational number arithmetic.
A Fraction instance can be constructed from a pair of integers, from another rational number, or from a 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.Rationaland returns a new
Fractioninstance with value
numerator/denominator. If denominator is
0, it raises a
ZeroDivisionError. The second version requires that other_fraction is an instance of
numbers.Rationaland returns a
Fractioninstance with the same value. The next two versions accept either a
decimal.Decimalinstance, and return a
Fractioninstance 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
signmay be either ‘+’ or ‘-’ and
denominator(if present) are strings of decimal digits (underscores may be used to delimit digits as with integral literals in code). In addition, any string that represents a finite value and is accepted by the
floatconstructor is also accepted by the
Fractionconstructor. 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)
Fractionclass inherits from the abstract base class
numbers.Rational, and implements all of the methods and operations from that class.
Fractioninstances are hashable, and should be treated as immutable. In addition,
Fractionhas the following properties and methods:
Alterado na versão 3.9: The
math.gcd()function is now used to normalize the numerator and denominator.
math.gcd()always return a
inttype. Previously, the GCD type depended on numerator and denominator.
Alterado na versão 3.11:
__int__now to satisfy
Numerator of the Fraction in lowest term.
Denominator of the Fraction in lowest term.
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)¶
- classmethod from_decimal(dec)¶
Finds and returns the closest
selfthat has denominator at most max_denominator. This method is useful for finding rational approximations to a given floating-point number:
>>> from fractions import Fraction >>> Fraction('3.1415926535897932').limit_denominator(1000) Fraction(355, 113)
or for recovering a rational number that’s represented as a float:
>>> 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)
>>> from math import floor >>> floor(Fraction(355, 113)) 3
The first version returns the nearest
self, rounding half to even. The second version rounds
selfto the nearest multiple of
Fraction(1, 10**ndigits)(logically, if
ndigitsis negative), again rounding half toward even. This method can also be accessed through the
The abstract base classes making up the numeric tower.