fractions
--- Rational numbers¶
Code source : Lib/fractions.py
Le module fractions
fournit un support de l'arithmétique des nombres rationnels.
Une instance de Fraction peut être construite depuis une paire d'entiers, depuis un autre nombre rationnel, ou depuis une chaîne de caractères.
- 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 newFraction
instance with valuenumerator/denominator
. If denominator is0
, it raises aZeroDivisionError
. The second version requires that other_fraction is an instance ofnumbers.Rational
and returns aFraction
instance with the same value. The next two versions accept either afloat
or adecimal.Decimal
instance, and return aFraction
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 toFraction(1.1)
is not exactly equal to 11/10, and soFraction(1.1)
does not returnFraction(11, 10)
as one might expect. (But see the documentation for thelimit_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
sign
may be either '+' or '-' andnumerator
anddenominator
(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 thefloat
constructor is also accepted by theFraction
constructor. 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)
The
Fraction
class inherits from the abstract base classnumbers.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:Modifié dans la version 3.2: Le constructeur de
Fraction
accepte maintenant des instances defloat
etdecimal.Decimal
.Modifié dans la version 3.9: The
math.gcd()
function is now used to normalize the numerator and denominator.math.gcd()
always returns anint
type. Previously, the GCD type depended on numerator and denominator.Modifié dans la version 3.11: Underscores are now permitted when creating a
Fraction
instance from a string, following PEP 515 rules.Modifié dans la version 3.11:
Fraction
implements__int__
now to satisfytyping.SupportsInt
instance checks.Modifié dans la version 3.12: Space is allowed around the slash for string inputs:
Fraction('2 / 3')
.Modifié dans la version 3.12:
Fraction
instances now support float-style formatting, with presentation types"e"
,"E"
,"f"
,"F"
,"g"
,"G"
and"%""
.Modifié dans la version 3.13: Formatting of
Fraction
instances without a presentation type now supports fill, alignment, sign handling, minimum width and grouping.- numerator¶
Numérateur de la fraction irréductible.
- denominator¶
Dénominateur de la fraction irréductible.
- 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.
Ajouté dans la version 3.8.
- is_integer()¶
Return
True
if the Fraction is an integer.Ajouté dans la version 3.12.
- classmethod from_float(flt)¶
Ce constructeur alternatif accepte (uniquement) des nombres à virgule flottante, de classe
float
, ou plus généralement des instances denumbers.Integral
. Attention,Fraction.from_float(0.3)
est différent deFraction(3, 10)
.
- classmethod from_decimal(dec)¶
Ce constructeur alternatif accepte (uniquement) les instances de
decimal.Decimal
ounumbers.Integral
.Note
Depuis Python 3.2, vous pouvez aussi construire une instance de
Fraction
directement depuis une instance dedecimal.Decimal
.
- limit_denominator(max_denominator=1000000)¶
Trouve et renvoie la
Fraction
la plus proche deself
qui a au plus max_denominator comme dénominateur. Cette méthode est utile pour trouver des approximations rationnelles de nombres flottants donnés :>>> from fractions import Fraction >>> Fraction('3.1415926535897932').limit_denominator(1000) Fraction(355, 113)
ou pour retrouver un nombre rationnel représenté par un flottant :
>>> 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__()¶
Renvoie le plus grand
int
<= self
. Cette méthode peut aussi être utilisée à travers la fonctionmath.floor()
:>>> from math import floor >>> floor(Fraction(355, 113)) 3
- __ceil__()¶
Renvoie le plus petit
int
>= self
. Cette méthode peut aussi être utilisée à travers la fonctionmath.ceil()
.
- __round__()¶
- __round__(ndigits)
La première version renvoie l'
int
le plus proche deself
, arrondissant les demis au nombre pair le plus proche. La seconde version arronditself
au plus proche multiple deFraction(1, 10**ndigits)
(logiquement, sindigits
est négatif), arrondissant toujours les demis au nombre pair le plus proche. Cette méthode peut aussi être utilisée à via la fonctionround()
.
- __format__(format_spec, /)¶
Provides support for formatting of
Fraction
instances via thestr.format()
method, theformat()
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 thefloat
type in the Mini-langage de spécification de format section.Voici quelques exemples :
>>> 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'
Voir aussi
- Module
numbers
Les classes abstraites représentant la hiérarchie des nombres.