# 9.5. `fractions` — Nombres rationnels

Nouveau dans la version 2.6.

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)

  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 methods:

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

  `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

    From Python 2.7 onwards, you can also construct a `Fraction` instance directly from a `float`.

  `from_decimal`(dec)

    This class method constructs a `Fraction` representing the exact value of dec, which must be a `decimal.Decimal`.

    Note

    From Python 2.7 onwards, you can also construct a `Fraction` instance directly from a `decimal.Decimal` instance.

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

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

Voir aussi

Module `numbers`

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