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

The first version requires that numerator and denominator are instances of `numbers.Rational` and returns a new `Fraction` instance with value `numerator/denominator`. If denominator is `0`, it raises a `ZeroDivisionError`. The second version requires that other_fraction is an instance of `numbers.Rational` and returns a `Fraction` instance with the same value. The next two versions accept either a `float` or a `decimal.Decimal` instance, and return a `Fraction` instance with exactly the same value. Note that due to the usual issues with binary floating-point (see Arithmétique en nombres à virgule flottante : problèmes et limites), 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 `sign` may be either '+' or '-' and `numerator` 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 `float` constructor is also accepted by the `Fraction` 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 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 properties and methods:

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

Modifié dans la version 3.9: La fonction `math.gcd()` est maintenant utilisée pour normaliser le numerator et le denominator. `math.gcd()` renvoie toujours un type `int`. Auparavant, le type du PGCD dépendait du numerator et du 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 satisfy `typing.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 `"%""`.

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.

Nouveau dans la version 3.8.

is_integer()

Return `True` if the Fraction is an integer.

Nouveau 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 de `numbers.Integral`. Attention, `Fraction.from_float(0.3)` est différent de `Fraction(3, 10)`.

Note

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

classmethod from_decimal(dec)

Ce constructeur alternatif accepte (uniquement) les instances de `decimal.Decimal` ou `numbers.Integral`.

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

__format__(format_spec, /)

Provides support for float-style formatting of `Fraction` instances via the `str.format()` method, the `format()` built-in function, or Formatted string literals. The presentation types `"e"`, `"E"`, `"f"`, `"F"`, `"g"`, `"G"` and `"%"` are supported. For these presentation types, formatting for a `Fraction` object `x` follows the rules outlined for the `float` type in the Mini-langage de spécification de format section.

Here are some examples:

```>>> from fractions import Fraction
>>> 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.