En programmation, les données qu’on va pouvoir manipuler avec un langage sont généralement classées par “type”.
Un “type” de données pour un langage est défini par les manipulations qu’on va pouvoir faire sur ces données : on va pouvoir effectuer les mêmes opérations sur chaque donnée d’un même type et des opérations différentes sur différents types de données.
Prenons un nombre entier par exemple. Il semble tout à fait logique de pouvoir effectuer des opérations mathématiques de base avec ce nombre : addition, soustraction, multiplication, etc. En revanche, on ne va pas pouvoir effectuer les mêmes opérations / manipulations sur un texte, puisque multiplier un texte par quelque chose par exemple n’a aucun sens.
Python définit de nombreux types de données qu’on va pouvoir stocker dans nos variables et manipuler à loisir ensuite : nombres entiers, décimaux, complexes, chaines de caractères, booléens, listes, tuples, dictionnaires, etc.
Dans cette leçon, nous allons nous contenter de passer en revue les types de données les plus simples à se représenter (nombres, chaines et booléens). Les autres types de données feront l’objet de leçons séparées.
Python définit trois types de valeurs numériques supportées :
Pour effectuer des opérations arithmétiques entre différentes valeurs numérique, nous allons devoir utiliser des opérateurs arithmétique (+ pour l’addition, - pour la soustraction, etc.).
On va pouvoir effectuer ces opérations directement entre nombres et se servir de Python comme d’une calculatrice ou affecter ces nombres à des variables et utiliser nos variables pour effectuer nos opérations :
Ici, on commence par effectuer des opérations entre nombres : addition, soustraction, multiplication, division et élévation à la puissance. Notez que pour réaliser une division entière, on utilise l’opérateur //. On peut également utiliser l’opérateur / pour réaliser une division “classique” mais dans ce cas le résultat sera toujours considéré comme étant de type float (nombre décimal). Finalement, on utilise l’opérateur ** pour élever un nombre à la puissance.
On peut également stocker des nombres dans des variables et utiliser ces variables pour effectuer nos calculs. Ici, on commence par définir une variable x et on lui attribue la valeur 5. On effectue ensuite différentes opérations. Notez que durant tous ces calculs x continue de stocker 5 puisqu’on n’affecte jamais de nouvelles valeurs à x. Finalement, on définit une deuxième variable y = 10 et on demande à Python de calculer x + y, c’est-à-dire de nous donner le résultat de l’addition des deux valeurs contenues dans x et dans y.
Le type de données “nombre décimal” ou float couvre tous les nombres décimaux (c’est-à-dire les nombres à virgule) ainsi que certaines expressions scientifiques comme le e qui désigne une exponentielle.
Attention ici : dans le monde de la programmation, les notations anglo-saxonnes sont la norme. Il faudra donc bien faire attention à utiliser un . et non pas une , pour les décimaux.
Nous allons grosso-modo pouvoir réaliser les mêmes opérations avec des données de type float qu’avec des données de type int (même si le traitement en arrière plan va être différent).
Il y a différentes choses à noter par rapport au type float en Python :
Toute opération arithmétique entre nombres de type float donne un résultat de type float; toute opération arithmétique entre nombres de types int et float donne un résultat de type float; la division classique donne toujours un résultat de type float.
On effectue plusieurs opérations arithmétiques d’un coup sur nos dernières lignes dans l’exemple ci-dessus. Dans ce cas là, il faudra faire attention à l’ordre des opérations. L’ordre des opérations va être le même qu’en mathématiques : les calculs de puissance seront effectués en priorité, puis la multiplication et la division, puis enfin l’addition et la soustraction.
On va également pouvoir utiliser des parenthèses pour imposer un ordre de priorité de calculs différents. Dans ce cas là, ce qui se trouve entre parenthèses sera calculé en premier.
Finalement, le type de données “nombre complexe” ou complex représente les nombres complexes. On va utiliser la lettre j ou J pour représenter la partie complexe d’un nombre. Comme la plupart d’entre vous n’auront que rarement affaire aux nombres complexes et que ce cours n’est pas un cours de mathématiques, je n’entrerai pas dans le détail ici.
Les chaines de caractères sont ce qu’on appelle communément du texte. Pour définir une chaine de caractères ou pour stocker une chaine de caractères dans une variable, il faudra l’entourer de guillemets simples ou doubles droits.
Si notre chaine de caractères contient elle même des guillemets simples (apostrophes) ou doubles, il faudra les échapper les uns ou les autres en fonction du délimiteur choisi pour qu’ils soient correctement interprétés car sinon Python pensera qu’ils servent à indiquer la fin de la chaine. Le caractère d’échappement en Python est l’antislash \.
Dans l’exemple ci-dessus, on veut afficher et stocker la chaine Je m’appelle “Pierre Giraud” qui contient à la fois des guillemets simples ou apostrophes et des guillemets doubles. Il va donc falloir qu’on échappe les uns ou les autres en fonction du caractère de délimitation de chaine choisi afin d’indiquer au Python que les guillemets simples ou doubles à l’intérieur de notre chaine ne représentent pas la fin de la chaine, c’est-à-dire pour lui indiquer qu’ils ne possèdent pas ce sens spécial de délimiteurs.
Notez qu’on peut également utiliser une syntaxe alternative utilisant des triples guillemets simples ou doubles pour entourer notre chaine et qui nous dispense ainsi d’avoir à échapper les apostrophes et les guillemets dans notre chaine :
Lorsqu’on utilise l’interpréteur en mode interactif, comme on le fait dans ce cours, l’interpréteur affiche les chaines entre guillemets simples. On peut utiliser la fonction print() pour afficher les chaînes de manière plus lisible, en retirant notamment les guillemets simples et doubles :
J’ai dit plus haut que pour définir une chaine de caractères il fallait l’entourer de guillemets simples ou doubles droits. Réciproquement, toute valeur entourée par des guillemets simples ou doubles sera considéré par Python comme une valeur de type str (“str” = “string” = chaine de caractères).
Ainsi, si on stocke un ou plusieurs caractères représentant des chiffres comme “1”, “2”, “123”, etc. en les entourant de guillemets simples ou doubles ceux-ci seront considérés comme des valeurs de type str et non comme des valeurs de type int, code>float ou complexe et on ne pourra pas effectuer les mêmes opérations.
Comme vous pouvez le voir, on n’obtient pas du tout les mêmes résultats lorsqu’on additionne deux nombres ou lorsqu’on additionne (ou plus exactement concatène) deux chaines.
Lorsqu’il est utilisé avec deux chaines, l’opérateur + est un opérateur de concaténation et pas d’addition. “Concaténer” signifie “mettre bout à bout”. Nous reparlerons de ce concept dans la prochaine leçon.
Finalement, vous pouvez également remarquer que Python nous renvoie une erreur lorsqu’on tente d’additionner / de concaténer un entier avec une chaine.
Le dernier type de valeurs simple Python que je tenais à vous présenter est le type bool (pour “booléen”).
Le type de valeur booléen est un type qui ne contient que deux valeurs qui servent à représenter deux états. Les deux valeurs sont True (vrai) et False (faux). Attention en Python à bien indiquer des majuscules car dans le cas contraire Python ne reconnaitra pas ces booléens.
Pour stocker un booléen dans une variable, il ne faut pas utiliser de guillemets : si on les utilise, ce seront les chaines de caractères “True” et “False” qui seront stockés et on ne va pas pouvoir effectuer les mêmes opérations.
Les valeurs booléennes sont très utilisées en informatique. Elles sont notamment très utiles pour valider ou invalider un test et sont au coeur des différentes structures de contrôle en général.
On voudra souvent s’assurer qu’une variable contient bien une valeur d’un certain type, notamment pour pouvoir effectuer différentes manipulations avec cette variable.
Pour connaitre le type de valeur stockée dans une variable, on peut utiliser la fonction Python type(). On va passer la variable à tester en argument de cette fonction (c’est-à-dire écrire le nom de la variable entre les parenthèses de la fonction). La fonction type() va alors tester la valeur contenue dans la variable et renvoyer le type de cette valeur.
