Types de données élémentaires¶
Cette page présente les types de données élémentaires du langage Python. Chaque type de données est représenté par un objet d’une classe particulière.
Nombres entiers¶
Les nombres entiers sont représentés par des objets de la classe int
>>> type(85)
<class 'int'>
Voici comment réaliser les opérations d’addition, de multiplication et de division euclidienne
>>> 200*4+10
1010
>>> 11//2
5
Le reste de la division euclidienne est obtenu avec l’opérateur modulo :
>>> 11%2
1
Voici comment calculer une puissance :
>>> 2**8
256
Lorsqu’un nombre entier est créé, un objet de la classe int est créé en mémoire.
Pour utiliser cet objet ultérieurement, on utilise une variable. Une variable
est simplement un nom qui permet d’accéder à un objet. La variable comporte un nom et une référence à l’objet (en pratique son adresse en mémoire). Dans la plupart des situations, on peut considérer que la variable contient l’objet même si en réalité elle contient une référence à l’objet.
Voici une variable nommée N contenant un nombre entier (plus précisément une référence à un nombre entier) :
>>> N = 10 # nombre de points
On remarque la présence d’un commentaire, introduit par le caractère #, qui permet de préciser le
sens de cette variable. Il est cependant conseillé de définir des noms de variables explicites, par exemple :
>>> N_points = 10
Cette instruction a pour effet de créer en mémoire un entier (de valeur 10), une variable de nom N_points qui fait référence à l’emplacement en mémoire de l’entier. On peut ainsi utiliser ce nombre dans une expression :
>>> N_points * 2
20
Il est possible d’utiliser le même nom de variable pour mémoriser le résultat de l’évaluation d’une expression :
>>> N_points = N_points * 2
Lorsque cette instruction est exécutée, l’expression à droite du signe = est évaluée, ce qui donne un nouveau nombre entier, puis la variable nommée N_points est utilisée pour faire référence à ce nombre.
Pour l’utilisateur, tout se passe comme si le nombre entier contenu dans N_points était modifié. En réalité, les entiers sont non mutables, c’est-à-dire qu’il est impossible de modifier un entier. Dans l’exemple ci-dessus, le premier entier créé (de valeur 10) n’est pas modifié par la seconde affectation de la variable N_points. Il existe toujours en mémoire et un nouvel entier est créé contenant le résultat de l’opération, puis la variable N_points se voit affectée ce nouvel entier.
La même opération peut être réalisée avec l’opérateur += :
>>> N_points += N_points
Remarquons que le nombre de bits utilisés pour stocker en mémoire le nombre entier s’adapte automatiquement au résultat du calcul. Il est ainsi possible faire des calculs avec des nombres très grands :
>>> 2**150
1427247692705959881058285969449495136382746624
Nombres à virgule flottante¶
Les nombres réels sont représentés par des objets de la classe float :
>>> type(25.3148)
<class 'float'>
Il s’agit d’un nombre à virgule flottante (ou flottant) de double précision (64 bits), conforme à la norme IEEE-754 (https://fr.wikipedia.org/wiki/IEEE_754). Il est en fait constitué de deux nombres entiers définissant la mantisse (52 bits) et l’exposant (11 bits) et d’un bit définissant le signe (1 bit).
La mantisse est un nombre entier, considéré comme un nombre réel inférieur à 1 (la virgule est placée juste avant le premier chiffre). Voici un exemple avec une mantisse égale à 1531 et un exposant égal à 7.
>>> m = 0.1531 # mantisse = 1531
>>> e = 7 # exposant
>>> m*2**e # valeur du nombre en notation décimale
19.5968
L’exposant permet de déplacer la virgule associée à la mantisse, d’où le nom donné à cette représentation (par opposition à une représentation à virgule fixe). Certains nombres réels, en particulier les nombres irrationnels, ne peuvent être représentés que de manière approximative. Par exemple :
>>> 1/3
0.3333333333333333
La précision est limitée par le nombre de bits de la mantisse (52 bits). Comme on le voit sur cet exemple, cela se traduit par un nombre de chiffres significatifs égal à 16.
Pour les nombres très grands ou très petits, on utilise la notation E, qui permet de définir un exposant de 10 :
>>> 1.15E9 # 1.15 * 10**9
1150000000.0
Le nombre de bits de l’exposant (11 bits) impose une valeur maximale à l’exposant de 10, égale à 308. Voici ce qu’il se passe si on tente de dépasser cette valeur :
>>> 1.5E309
inf
Un flottant peut être converti en entier, soit avec la fonction int, soit avec la fonction round :
>>> round(2.5)
2
>>> round(-2.5)
-2
Complexes¶
Le type complex permet de représenter un nombre complexe, c’est-à-dire l’association de deux nombres à virgule flottante constituant sa partie réelle et sa partie imaginaire.
>>> type(1+2*1j)
<class 'complex'>
Le nombre imaginaire j s’introduit avec la syntaxe 1j (le 1 est indispensable).
On peut bien sûr faire des opérations avec des nombres complexes :
>>> z1 = 1+1j
>>> z2 = 2-1j
>>> z1*z2
(3+1j)
Voici comment obtenir les parties réelle et imaginaire d’un nombre complexe ainsi que son module :
>>> z1.real
1.0
>>> z1.imag
1.0
>>> abs(z1)
1.4142135623730951
Pour aller plus loin dans les calculs avec des nombres complexes, il faut utiliser le module cmath ou bien la bibliothèque numpy.
Booléens¶
Un booléen contient seulement deux états logiques : True et False.
>>> type(True)
<class 'bool'>
Les opérateurs de comparaison donnent un résultat booléen :
>>> a=1
>>> b=2
>>> a<b
True
>>> a>b
False
>>> a==1
True
>>> a!=1
False
Notons qu’il est possible de faire une double comparaison :
>>> a < 1.5 < b
True
Les opérateurs logiques agissent sur des booléens :
>>> True or False
True
>>> True and False
False
>>> not True
False
Chaînes de caractères¶
Les chaînes de caractères sont définies à l’aide de guillemets anglais, simples ou doubles :
>>> type('chaîne de caractère')
<class 'str'>
Les guillemets doubles sont nécessaires lorsque la chaîne contient une apostrophe :
>>> phrase = "Python, c'est facile !"
L’opérateur + permet de concaténer deux chaînes de caractères, et un nombre (entier ou flottant) peut être converti en chaîne au moyen de la fonction str. Il est ainsi possible de présenter le résultat d’un calcul numérique, avec éventuellement son unité :
>>> x = 2.34e-3*86.5/8.2
>>> 'x = '+str(x)+' m'
'x = 0.024684146341463417 m'
Si l’on souhaite contrôler le format d’affichage du nombre, et le nombre de chiffres significatifs affichés, on utilise le caractère % suivi du format choisi :
>>> '%0.3f'%x
'0.025'
>>> '%0.3e'%x
'2.468e-02'
Les différents formats sont documentés dans https://docs.python.org/3/library/string.html