Facture d'électricité

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

Les nombres entiers, y compris sous forme hexadécimale (hex()), octale (oct()) et binaire (bin()), sans point décimal, 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 prend entièrement en charge l'arithmétique entre ces différents types de nombres et convertit les nombres plus étroits pour les aligner sur leurs équivalents plus larges lorsqu'on utilise les opérateurs arithmétiques binaires (+, -, *, /, // et %).

Addition et soustraction

Les opérateurs d'addition et de soustraction se comportent comme en mathématiques habituelles. Si l'un des opérandes au moins est un float, les int restants sont 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 plus étroits pour les aligner sur leurs équivalents 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 tu as besoin d'un résultat de type int, tu peux utiliser la division entière pour tronquer le résultat. La division entière s'effectue avec 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 leftover
>>> 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

Arrondis

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 précisé, le nombre est arrondi à l'entier le plus proche et un int est renvoyé :

>>> 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 lorsque tu veux 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 * 64, then 2 + 192
>>> 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 ont 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 selon les langages de programmation, jette un œil à 0.30000000000000004.com et au tutoriel Python.