fractions — Nombres rationnels

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)

La première version demande que numerator et denominator soient des instance de numbers.Rational et renvoie une instance de Fraction valant numerator/denominator. Si denominator vaut 0, une ZeroDivisionError est levée. La seconde version demande que other_fraction soit une instance de numbers.Rational et renvoie une instance de Fraction avec la même valeur. Les deux versions suivantes acceptent un float ou une instance de decimal.Decimal, et renvoient une instance de Fraction avec exactement la même valeur. Notez que les problèmes usuels des virgules flottantes binaires (voir Arithmétique en nombres à virgule flottante : problèmes et limites) font que Fraction(1.1) n'est pas exactement égal à 11/10, et donc Fraction(1.1) ne renvoie pas Fraction(11, 10) comme on pourrait le penser. (Mais référez-vous à la documentation de la méthode limit_denominator() ci-dessous.) La dernière version du constructeur attend une chaîne de caractères ou Unicode. La représentation habituelle de cette forme est :

[sign] numerator ['/' denominator]

où le sign optionnel peut être soit + soit -, et numerator et denominator (si présent) sont des chaînes de chiffres décimaux. De plus, toute chaîne qui représente une valeur finie et acceptée par le constructeur de float est aussi acceptée par celui de Fraction. Dans ces deux formes, la chaîne d'entrée peut aussi contenir des espaces en début ou en fin de chaîne. Voici quelques exemples :

>>> 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 classe Fraction hérite de la classe abstraite numbers.Rational, et implémente toutes les méthodes et opérations de cette classe. Les instances de Fraction sont hachables, et doivent être traitées comme immuables. En plus de cela, Fraction possède les propriétés et méthodes suivantes :

Modifié dans la version 3.2: Le constructeur de Fraction accepte maintenant des instances de float et decimal.Decimal.

numerator

Numérateur de la fraction irréductible.

denominator

Dénominateur de la fraction irréductible.

as_integer_ratio()

Renvoie un n-uplet de deux entiers, dont le quotient est égal à la fraction et dont le dénominateur est positif.

Nouveau dans la version 3.8.

from_float(flt)

Cette méthode de classe construit un objet Fraction représentant la valeur exacte de flt, qui doit être de type float. Attention, Fraction.from_float(0.3) n'est pas la même valeur que Fraction(3, 10).

Note

Depuis Python 3.2, vous pouvez aussi construire une instance de Fraction directement depuis un float.

from_decimal(dec)

Cette méthode de classe construit un objet Fraction représentant la valeur exacte de dec, qui doit être de type decimal.Decimal.

Note

Depuis Python 3.2, vous pouvez aussi construire une instance de Fraction directement depuis une instance de decimal.Decimal.

limit_denominator(max_denominator=1000000)

Trouve et renvoie la Fraction la plus proche de self 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 fonction math.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 fonction math.ceil().

__round__()
__round__(ndigits)

La première version renvoie l'int le plus proche de self, arrondissant les demis au nombre pair le plus proche. La seconde version arrondit self au plus proche multiple de Fraction(1, 10**ndigits) (logiquement, si ndigits est négatif), arrondissant toujours les demis au nombre pair le plus proche. Cette méthode peut aussi être utilisée à via la fonction round().

fractions.gcd(a, b)

Renvoie le plus grand diviseur commun (PGCD) des entiers a et b. Si a et b sont tous deux non nuls, alors la valeur absolue de gcd(a, b) est le plus grand entier qui divise à la fois a et b. gcd(a,b) a le même signe que b si b n'est pas nul ; autrement il prend le signe de a. gcd(0, 0) renvoie 0.

Obsolète depuis la version 3.5: Utilisez plutôt math.gcd().

Voir aussi

Module numbers

Les classes abstraites représentant la hiérarchie des nombres.