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 :py:obj:`int` >>> type(85) 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 :py:obj:`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 :py:obj:`#`, 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 :py:obj:`+=` : >>> 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 :py:obj:`float` : >>> type(25.3148) 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). .. math:: x = s*m*2^e 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 :py:obj:`int`, soit avec la fonction :py:obj:`round` : >>> round(2.5) 2 >>> round(-2.5) -2 Complexes --------- Le type :py:obj:`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) Le nombre imaginaire j s'introduit avec la syntaxe :py:obj:`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 :py:obj:`cmath` ou bien la bibliothèque :py:obj:`numpy`. Booléens -------- Un booléen contient seulement deux états logiques : :py:obj:`True` et :py:obj:`False`. >>> type(True) Les opérateurs de comparaison donnent un résultat booléen : >>> a=1 >>> b=2 >>> a>> 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') 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 :py:obj:`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