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.
