Tutoriel Python : manipuler les types de variables
Table des matières
Initiation aux variables sur Python
Règles d’écriture du nom d’une variable
Création de plusieurs variables
Redéfinir la valeur d’une variable
Déterminer le type de la valeur d’une variable
Les types numériques sur Python
- Les nombres entiers « int »
- Les nombres flottants « float »
- Les nombres complexes « complex »
- Le type booléen « True » et « False »
- Les chaines de caractères « str »
Quelques notions utiles sur les chaines de caractères
Quelques opérations sur les chaines de caractères
Introduction :
Afin de pouvoir réaliser un projet ou un programme sur Python, il faut commencer par définir la structure qui correspond le mieux au problème que vous essayez de résoudre, tout en précisant là où vous aurez à stocker vos données tout au long de votre programme : les variables.
Ce tutoriel enrichi par des explications et des exemples présentera les structures de données de base du langage de programmation Python.
En premier temps, on introduira les variables et comment les définir sur Python, par la suite, on déterminera les types de base des valeurs des variables : les types numériques, les types booléens, et les chaines de caractères.
Initiation aux variables sur Python
Règles d’écriture du nom d’une variable
Une variable est caractérisée par un nom (ou identificateur) et un type. Le nom identifie de manière unique chaque variable, en attribuant une valeur à la variable et en récupérant la valeur stockée, ainsi ces identificateurs ont des règles d’écriture sur Python :
- Le nom d’une variable doit contenir uniquement des caractères alphanumériques (lettres et chiffres) ou le caractère underscore « _ ».
- Le nom d’une variable doit commencer par une lettre ou le caractère underscore « _ ».
- Le nom d’une variable ne peut pas commencer par un chiffre.
- Les noms des variables sur Python sont sensibles à la casse, c’est-à-dire, que les variables « nom », « Nom », « NOM », et « nOm » sont des variables différentes.
- L’utilisation d’espace entre les caractères du nom d’une variable n’est pas autorisée, néanmoins, utilisez une lettre en majuscule pour différenciez les mots ou bien le caractère underscore « _ » si vous avez besoin de d’espace.
- Evitez d’utiliser les mots réservés sur Python tels que : False, True, class, finally, is, return, None, continue, for, lambda, try, def, from, non, local, while, and, del, global, not, with, as, if, else, elif, or, yield, assert, import, pass, break, except, in, raise.
Création d’une variable :
On peut définir une variable en lui attribuant un identificateur suivi du signe égal =, et puis en lui affectant une valeur, cet identificateur peut être utilisé pour faire référence à la valeur plus tard dans le programme.
Remarque : Si une variable n’est pas définie, l’erreur suivante se produira :
Exemple :
Syntaxe :
a = 123
Création de plusieurs variables :
Pour définir plusieurs variables, on peut réutiliser la méthode mentionnée précédemment en la répétant pour chaque variable.
D’une autre manière, on peut définir les identificateurs séparés par une virgule, suivi du signe égal =, et puis de la même manière (en respectant l’ordre) attribuer leurs valeurs séparées par une virgule.
Exemple méthode 1 :
Syntaxe :
a = 123
b = 12.5
_prénom = "Ismail"
test_b12 = 4 < 6
Exemple méthode 2 :
Syntaxe :
a, b, c, d = 123, 12.5, "Ismail", 4 < 6
Redéfinir la valeur d’une variable :
Après avoir défini une variable dans notre programme, on peut toujours lui affecter une nouvelle valeur autant de fois qu’on le souhaite, en suivant le même procédé qu’on a utilisé lors de la création.
Remarque : Sur Python, une variable n’est pas associée à son type, ainsi, il est possible de redéfinir une variable en lui affectant une valeur de type différent, mais ça reste une mauvaise pratique. Donc, essayez de ne pas redéfinir une variable avec différents types de valeurs afin d’éviter des erreurs dans votre programme.
Exemple :
Syntaxe :
# création d'une variable :a = 5print(a) # Redéfinir la valeur de cette variable :a='ABC'print(a)
Résultat d’exécution :
Déterminer le type de la valeur d’une variable :
Les variables permettent de stocker des données de différents types pour le traitement, par exemple : un nom, ou une liste de notes ou même un dictionnaire de produits avec leur prix….
Afin de définir le type de la valeur stockée dans une variable, on peut utiliser la fonction intégrée sur Python : type()
Exemple :
Syntaxe :
# Création de variables :
a = 123
b = 12.5
_prénom = "Ismail"
test_b12 = 4 < 6
# Définir les types de valeurs stockées dans ces variables :
print("a = ", a)
print("type de la valeur stockée en a est : ", type(a))
print("b = ", b)
print("type de la valeur stockée en b est : ", type(b))
print("_prénom = ", a)
print("type de la valeur stockée en _prénom est : ", type(_prénom))
print("test_b12 = ", test_b12)
print("type de la valeur stockée en test_b12 est : ", type(test_b12))
Résultat d’exécution :
Les types numériques sur Python :
Il existe trois types numériques à découvrir sous Python :
- Les nombres entiers.
- Les nombres flottants représentant les nombres réels.
- Les nombres complexes.
Les nombres entiers « int » :
Les nombres entiers ou « integers » en anglais, sont exprimés sous Python en tant que des valeurs de type « int ».
D’une autre part, la fonction intégrée « int() » peut être utilisée pour produire ou pour convertir un nombre en un nombre entier (ou de type « int »), ou bien pour préciser une valeur que l’utilisateur doit entrer en l’utilisant sous forme : int(input()).
Exemple :
Syntaxe :
# Affecter une valeur de type "int" à une variable :
a = 20
# Affichage le la valeur de la variable créée :
print(a)
# Affichage du type de la valeur stockée dans la variable créée :
print(type(a))
Résultat d’exécution :
Exemple de la fonction intégrée « int() » :
Syntaxe :
# exemples d'utilisation de la fonction intégrée int() :
a = int(1.25)
print("a = ", a)
b = int(input("entrez un nombre : "))
print("b = ", b)
Résultat d’exécution :
Les nombres flottants « float » :
Les nombres flottants ou « floating point numbers » en anglais, sont exprimés sous Python en tant que des valeurs de type « float », ils représentent les nombres à virgule flottante, c’est-à-dire, des nombres contenant une virgule.
D’une autre part, la fonction intégrée « float() » peut être utilisée pour produire ou pour convertir un nombre en un nombre flottant (ou de type « float »), ou bien pour préciser une valeur de type « float » que l’utilisateur doit entrer en l’utilisant sous forme : float(input()).
Exemple :
Syntaxe :
# Affecter une valeur de type "float" à une variable :
a = 20.0
b = 2.8956
# Affichage le la valeur de la variable créée :
print("a = ", a)
print("b = ", b)
# Affichage du type de la valeur stockée dans la variable créée :
print("type de la valeur stockée en a est : ", type(a))
print("type de la valeur stockée en b est : ", type(a))
Résultat d’exécution :
Exemple de la fonction intégrée « float() » :
Syntaxe :
# exemples d'utilisation de la fonction intégrée float() :
a = float(1)
print("a = ", a)
print("type de la valeur stockée en a est : ", type(a))
b = float(input("entrez un nombre : "))
print("b = ", b)
print("type de la valeur stockée en b est : ", type(a))
c = float(input("entrez un nombre : "))
print("c = ", c)
print("type de la valeur stockée en c est : ", type(a))
Résultat d’exécution :
Les nombres complexes « complex » :
Les nombres complexes ou « complex numbers » en anglais, sont exprimés sous Python en tant que des valeurs de type « complex », ils sont représentés sous forme de a+bj ou a+bJ, avec a est la partie réelle et b la partie imaginaire.
D’une autre part, la fonction intégrée « complex(a, b) » peut être utilisée pour produire ou pour convertir un nombre en un nombre complexe (ou de type « complex »), avec a est la partie réelle, et b la partie imaginaire.
Remarque : la partie imaginaire b est définie par défaut par la valeur 0.
Exemple :
Syntaxe :
# Affecter une valeur de type "complex" à une variable :
a = 11 + 10j
b = 2.8956 + 2J
# Affichage le la valeur de la variable créée :
print("a = ", a)
print("b = ", b)
# Affichage du type de la valeur stockée dans la variable créée :
print("type de la valeur stockée en a est : ", type(a))
print("type de la valeur stockée en b est : ", type(a))
Résultat d’exécution :
Exemple de la fonction intégrée « complex() » :
Syntaxe :
# exemples d'utilisation de la fonction intégrée complex() :
a = complex(1)
print("a = ", a)
print("type de la valeur stockée en a est : ", type(a))
b = complex(0, 1)
print("b = ", b)
print("type de la valeur stockée en b est : ", type(b))
c = complex(12, 156.356)
print("c = ", c)
print("type de la valeur stockée en c est : ", type(c))
Résultat d’exécution :
Le type booléen « True » et « False » :
Étant un sous-type des entiers, les types booléens sont représentés pas les valeurs True ‘1’ (vrai) et False ‘0’ (faux), ils résultent d’une évaluation d’une instruction telle que la comparaison entre deux valeurs.
Exemple :
Syntaxe :
# Quelques exemples de types booléens :
a = 4 < 5
b = 5 == 6
c = a is b
d = b is not a
e = c and d
f = c or d
# Affichage des valeurs des variables créées :
print("a = ", a)
print("b = ", b)
print("c = ", c)
print("d = ", d)
print("e = ", e)
print("f = ", f)
# Affichage du type de valeur stockée dans les variables créées :
print("type de la valeur stockée en a est : ", type(a))
print("type de la valeur stockée en b est : ", type(b))
print("type de la valeur stockée en c est : ", type(c))
print("type de la valeur stockée en d est : ", type(d))
print("type de la valeur stockée en e est : ", type(e))
print("type de la valeur stockée en f est : ", type(f))
Résultat d’exécution :
Les chaines de caractères « str » :
Les chaine de caractères ou « strings » en anglais, permettent d’utiliser un texte dans votre programmation, ils sont représentés par des guillemets ‘ ou " sous forme "texte" ou bien ‘texte’.
Remarque En représentant des opérations ou des nombres entres guillemets, ils seront considérés comme chaines de caractères : ‘92’ et 92 sont de types différents.
Exemples :
Syntaxe :
# exemples de chaines de caractères :
a = "exemple de texte"
print("a = ", a)
print("type de la valeur stockée en a est : ", type(a))
b = 'exemple de texte'
print("b = ", b)
print("type de la valeur stockée en b est : ", type(b))
# Remarque :
c = "92"
print("c = ", c)
print("type de la valeur stockée en c est : ", type(c))
d = 92
print("d = ", d)
print("type de la valeur stockée en d est : ", type(d))
e = '4 < 5'
print("e = ", e)
print("type de la valeur stockée en e est : ", type(e))
f = 4 < 5
print("f = ", f)
print("type de la valeur stockée en f est : ", type(f))
Résultat d’exécution :
Quelques notions utiles sur les chaines de caractères :
Afin de pouvoir utiliser des guillemets dans votre texte, il est possible d’utiliser les deux types de guillemets, ou bien utiliser le caractères \ pour échapper le guillemet utilisé dans le texte.
Si on souhaite employer des tabulations, on utilise l’instruction \t , et pour effectuer un saut de ligne, on utilise l’instruction \n .
Exemples :
Syntaxe :
# exemples d'utilisation de guillemets dans le texte :
a = "exemple de 'texte'"
print("a = ", a)
print("type de la valeur stockée en a est : ", type(a))
b = 'exemple de "texte"'
print("b = ", b)
print("type de la valeur stockée en b est : ", type(b))
c = "exemple de \"texte\""
print("c = ", c)
print("type de la valeur stockée en c est : ", type(c))
# exemple de tabulation :
d = "\texemple de texte"
print("d = ", d)
print("type de la valeur stockée en d est : ", type(d))
# exemple de saut de ligne :
e = "\nexemple \nde \ntexte"
print("e = ", e)
print("type de la valeur stockée en e est : ", type(e))
Résultat d’exécution :
Quelques opérations sur les chaines de caractères :
Concaténation :
L’opérateur d’addition ou la virgule sont utilisés pour concaténer ou réunir deux chaines de caractères (en utilisant une virgule, Python rajoute un espace).
Remarque Il n’est pas possible d’utiliser l’opérateur + pour réunir une chaine de caractères avec une valeur d’un autre type, d’autre part, on peut afficher une jointure entre une chaine de caractères et une valeur d’un autre type en les séparant par une virgule.
Exemple :
Syntaxe :
# exemple d'utilisation de concaténation entre les chaines de caractères :
print("ABC"+"32")
print("ABC","32")
# exemple de jointure entre une chaine de caractères et un nombre :
print("ABC",32)
Résultat d’exécution :
Répétition :
Il est possible de répéter une chaine de caractère par l’opérateur de multiplication *, suivi du nombre de fois qu’on veut effectuer la répétition.
Exemple :
Syntaxe :
# exemple de répétion d'une chaine de caractères :
print("test"*10)
Résultat d’exécution :
Conclusion
Les variables sont des structures importantes en programmation, en espérant que ce guide vous a aidé à les concevoir et que vous êtes prêts à les utiliser dans votre programme. Dans une deuxième partie de ce tutoriel, on va dépasser ces bases et explorer comment on peut utiliser les structures de données intégrées à Python permettant de stocker plusieurs valeurs telles que les ensembles, les listes, les dictionnaires, et les tuples pour effectuer une analyse de données de plus en plus complexe.
Merci pour votre attention et bonne chance à vous !
