Les nombres en

À propos de Les nombres

Python possède trois types différents de nombres intégrés : les entiers (int), les nombres à virgule flottante (float) et les nombres complexes (complex). Les fractions (fractions.Fraction) et les décimaux (decimal.Decimal) sont également disponibles en les important depuis la bibliothèque standard.

Les nombres entiers, y compris les nombres hexadécimaux (hex()), octaux (oct()) et binaires (bin()) sans décimales, sont eux aussi identifiés comme des ints :

# Ints are whole numbers.
>>> 1234
1234
>>> type(1234)
<class 'int'>

>>> -12
-12

Les nombres contenant un point décimal (avec ou sans partie fractionnaire) sont identifiés comme des floats :

>>> 3.45
3.45
>>> type(3.45)
<class 'float'>

Arithmétique

Python gère parfaitement l'arithmétique entre ces différents types de nombres, et convertit les nombres les plus étroits pour les faire correspondre à leurs homologues plus larges lorsqu'ils sont utilisés avec les opérateurs arithmétiques binaires (+, -, *, /, // et %).

Tous les nombres (sauf les complexes) prennent en charge toutes les opérations arithmétiques, évaluées selon la priorité des opérateurs. La prise en charge des fonctions mathématiques (au-delà de + et -) pour les nombres complexes se trouve dans le module cmath.

Addition et soustraction

Les opérateurs d'addition et de soustraction se comportent comme en mathématiques habituelles. Si un ou plusieurs des opérandes sont des float, les int restants seront eux aussi convertis en float :

>>> 5 - 3
2
# The int is widened to a float here, and a float is returned.
>>> 3 + 4.0
7.0

Multiplication

Comme pour l'addition et la soustraction, la multiplication convertit les nombres les plus étroits pour les faire correspondre à leurs homologues plus larges :

>>> 3 * 2
6

>>> 3 * 2.0
6.0

Division

La division renvoie toujours un float, même si le résultat est un nombre entier :

>>> 6/5
1.2

>>> 6/2
3.0

Division entière

Si un résultat de type int est nécessaire, on peut utiliser la division entière pour tronquer le résultat. La division entière s'effectue à l'aide de l'opérateur // :

>>> 6//5
1

>>> 6//2
3

Modulo

L'opérateur modulo (%) renvoie le reste de la division des deux opérandes :

# The result of % is zero here, because dividing 8 by 2 leaves no remainder
>>> 8 % 2
0

# The result of % is 2 here, because 3 only goes into 5 once, with 2 left over
>>> 5 % 3
2

Une autre façon de voir 5 % 3 :

>>> whole_part = int(5/3)
1

>>> decimal_part = 5/3 - whole_part
0.6666666666666667

>>> whole_remainder = decimal_part * 3
2.0

Exponentiation

L'exponentiation s'effectue à l'aide de l'opérateur ** :

>>> 2 ** 3
8

>>> 4 ** 0.5
2

Conversions

On peut convertir les nombres d'int en float et de float en int à l'aide des fonctions intégrées int() et float() :

>>> int(3.45)
3

>>> float(3)
3.0

Arrondi

Python fournit une fonction intégrée round(<number>, <decimal_places>) pour arrondir un nombre à virgule flottante à un nombre donné de décimales. Si aucun nombre de décimales n'est spécifié, le nombre est arrondi à l'entier le plus proche et la fonction renvoie un int :

>>> round(3.1415926535, 2)
3.14

>>> round(3.1415926535)
3

Priorité et parenthèses

Python permet d'utiliser des parenthèses pour regrouper des expressions. C'est utile lorsqu'on veut modifier l'ordre des opérations par défaut.

>>> 2 + 3 * 4
14

>>> (2 + 3) * 4
20

Python suit la règle PEMDAS pour la priorité des opérateurs. Cela signifie que les calculs entre () ont la priorité la plus élevée, suivis de **, puis *, /, //, %, + et - :

>>> 2 + 3 - 4 * 4
-11

>>> (2 + 3 - 4) * 4
4

# In the following example, the `**` operator has the highest priority, then `*`, then `+`
# Meaning we first do 4 ** 4, then 3 * 256, then 2 + 768
>>> 2 + 3 * 4 ** 4
770

Précision et représentation

Les entiers en Python ont une précision arbitraire : le nombre de chiffres n'est limité que par la mémoire disponible du système hôte.

Les nombres à virgule flottante sont généralement implémentés à l'aide d'un double en C (15 décimales de précision), mais leur représentation varie selon le système hôte. Les nombres complexes possèdent une partie real et une partie imaginary, toutes deux représentées par des nombres à virgule flottante.

Pour une discussion plus détaillée des problèmes et des limites de l'arithmétique à virgule flottante dans les différents langages de programmation, jette un œil à 0.30000000000000004.com et à Le tutoriel Python.