Retourner à : Python pour débutants
Dans ce chapitre, nous allons parler de variables. Comme il y a beaucoup de choses à dire on va se focaliser sur les bases et on approfondira ensuite ce sujet dans d’autres chapitres. Pour ce premier chapitre, on va:
- expliquer ce qu’est une variable
- on verra différents types de variables
- on parlera de quelques opérateurs qu’on peut utiliser sur ces variables
Une variable, c’est quoi ?
Vous pouvez vous représenter une variable comme une boîte qui va contenir quelque chose et qu’on va étiqueter afin de savoir ce qui est rangé à l’intérieur.
Cette boîte peut contenir une seule chose à la fois, dans notre illustration, c’est le chiffre 13, mais ça aurait pu être un autre nombre, des lettres, des mots ou bien encore d’autres types de données qu’on verra dans d’autres chapitres. Cette explication est très simpliste, mais si c’est la première fois que vous vous familiarisez avec le concept de variables et que vous avez compris l’illustration ci-dessus, c’est tout ce dont vous aurez besoin pour le moment.
Maintenant, regardons comment créer une telle variable en Python. Je vous laisse le soin d’ouvrir votre IDE préféré et de créer un nouveau dossier et un nouveau fichier main, de la même manière que nous l’avons fait pour le chapitre 1. Tout d’abord réfléchissons à ce que nous voulons stocker. Pour ce premier exemple, j’aimerais qu’on stocke notre âge. La première chose qu’il nous faut est un nom pour notre variable. Appelons-la « my_age » :
my_agePour stocker la valeur 13 dans cette variable « my_age », on va ajouter le symbole « = » (égal) juste après le nom de la variable, et à droite de celui-ci, on va taper la valeur qu’on souhaite stocker dans la variable, donc ici 13.
my_age = 13Et voilà, notre variable « my_age » a maintenant la valeur 13. Pour vous montrer que c’est bien le cas, je propose de l’afficher dans le terminal. Pour cela, on va rajouter un print dans une deuxième ligne de notre programme et, cette fois-ci entre parenthèses, on va lui passer notre variable « my_age » en paramètre :
my_age = 13
print(my_age)Vous pouvez maintenant lancer ce programme et vérifier que le chiffre 13 est bien affiché dans le terminal :
Avant de continuer j’aimerais qu’on prenne un peu de temps pour regarder ce code de plus près, car il y a plusieurs choses à analyser.
Conventions de nommage
La première chose de laquelle j’aimerais parler, c’est le nom qu’on a donné à notre variable. Comme vous l’avez sûrement remarqué, on a choisi un nom très descriptif. La variable représente notre âge, on l’a donc appelée « my_age » et on a séparé les mots « mon » et « age » par un underscore.
Ce choix n’a pas été fait par hazard. Au fait, ici on respecte la convention de nommage Python, et cette convention de nommage, vous pouvez la retrouver sur le site python.org. Cette convention de nommage vient du guide de style PEP 8, qui est le guide de style officiel du langage Python. On y retrouve la section suivante :
Function and Variable Names
Function names should be lowercase, with words separated by underscores as necessary to improve readability.
Variable names follow the same convention as function names.
Traduite en français, cette convention indique que :
Les noms de fonctions et de variables doivent être écrits en minuscules et que les mots doivent être séparés par des underscores.
Notez que vous pouvez nommer vos variables dans n’importe quelle langue, mais je vous conseille d’utiliser des noms anglais. Toutes les variables que vous verrez dans ce cours suivront cette convention !
Il est aussi très important de noter que les variables en Python sont sensibles à la casse. Si vous avez une variable nommée « my_age » et une variable nommée « my_Age », ces deux variables sont considérées comme des variables distinctes. Si on considère l’exemple suivant :
my_age = 13
my_Age = 20
print(my_age)
print(my_Age)En exécutant ce code dans votre terminal, vous voyez que vous avez bien deux variables distinctes qui s’affichent, l’une avec le chiffre 13 et l’autre avec le chiffre 20 :
Ici, on n’a parlé uniquement des conventions de nommage des variables, mais je vous conseille de lire le guide de style PEP 8 au fur et à mesure que vous progressez en Python afin d’adhérer aux bonnes pratiques.
Types de variables
La deuxième chose de laquelle j’aimerais parler ici, c’est la partie de droite de l’assignation de notre variable, le » = 13″.
my_age = 13Assignation
Cette opération s’appelle une assignation. On assigne le nombre 13 à la variable « my_age ». Cette assignation nous montre également une particularité du langage de programmation Python. Comme vous pouvez le constater, on n’a pas dû indiquer préalablement à Python que la variable « my_age » allait contenir un nombre entier. Pourtant, suite à notre assignation, Python a automatiquement déterminé que nos variables sont des variables entières.
Pour vérifier cela, on peut créer une nouvelle variable qu’on va appeler « type_my_age », et à laquelle on va assigner le résultat de l’instruction type à laquelle on va passer en paramètre notre variable « my_age », et on va imprimer cette variable avec l’instruction print :
my_age = 13
my_Age = 20
print(my_age)
print(my_Age)
type_my_age = type(my_age)
print(type_my_age)Comme son nom l’indique, l’instruction type, retourne le type de la variable qu’on lui passe en paramètre. Et si on exécute ce code, on voit la chose suivante :
Le type de la variable « my_age » est « int », qui est le diminutif d' »integer » en anglais, et qui veut dire « entier » en français. Donc le type que Python a inféré pour notre variable « my_age » est le type « int ». Ne vous laissez pas distraire par la partie « <class …> », nous expliquerons ce que sont les classes dans des chapitres plus avancés.
Le langage Python est un langage typé dynamiquement, c’est-à-dire que les types des variables sont déterminés lors de l’exécution du programme, en fonction des valeurs qui leur sont assignées.
Il existe d’autres types de variables qu’on peut utiliser en Python et on va en regarder quelques uns en détail ci-dessous.
Nombres entiers – le type « int »
Le type int représente les nombres entiers positifs et négatifs. Exemples:
age = 18
temperature_celsius = -12
taille_en_cm = 174Les décimales – le type « float »
Le type float, représente des nombres à virgule flottante (« floating point numbers » en anglais), c’est à dire des nombres décimaux. Exemples:
pi = 3.14
number_of_seconds = 4.0
kcal = 125.7Il est important de noter que le fait d’ajouter une décimale à un nombre en fait automatiquement un type float. Donc 4.0 est un float alors que 4 est un int.
Les textes – le type str
Regardons maintenant comment stocker du texte. En Python, les textes doivent être entourés de guillemets simples (‘…’) ou de guillemets doubles (« … »). Le type d’une variable qui contient du texte est le type str, qui vient de string en anglais qui signifie « chaîne de caractères », donc une suite de caractères. Exemples :
my_name = 'Sergio Sousa'
my_presentation = "Je m'appelle Sergio Sousa."On peut aussi définir des strings sur plusieurs lignes. Pour cela, on utilise trois guillemets (doubles ou simples) :
my_long_presentation = """Bonjour,
Je m'appelle Sergio Sousa."""Attention ! Si vous souhaitez utiliser les mêmes guillemets à l’intérieur de votre texte, que ceux utilisés pour définir le texte, vous devrez les faire précéder d’un backslash, sinon vous aurez des erreurs lors de l’execution. Par exemple: ‘Bonjour, je m\’appelle Sergio Sousa.’
Les booléens – le type bool
Le dernier type duquel j’aimerais parler dans ce chapitre, est le type booléen. C’est un type qui peut représenter deux valeurs: vrai ou faux, ce qui donne en anglais True ou False. Pour définir une variable booléenne en Python, on doit donc assigner l’une des valeurs True ou False à celle-ci, et le type associé à ces valeurs booléennes est le type bool. Exemples :
is_adult = True
is_small = FalseAttention ! Il faut faire bien attention à respecter la casse. True et False s’écrivent avec la première lettre en majuscule !
Les opérateurs
Une fois qu’on a compris ce que sont les variables et les différents types, on peut commencer passer à des choses plus intéressantes. En effet, les différents types que nous venons de voir peuvent être combinés en utilisant différents opérateurs. Je vais vous présenter quelques opérateurs ci-dessous, mais notez qu’il en existe d’autres qu’on découvrira au fur et à mesure qu’on avancera dans ce cours.
L’assignation
On a déjà parlé de l’assignation plus haut. L’assignation est le fait d’assigner une valeur à une variable en utilisant le symbole « = ». On peut à tout moment changer la valeur et même le type d’une variable on lui assignant une nouvelle valeur. Exemple :
assignment_test = 12
print(type(assignment_test))
assignment_test = "Bonjour"
print(type(assignment_test))
new_assignment = assignment_test
print(new_assignment)Comme vous pouvez le voir ci-dessus, on peut également assigner la valeur d’une variable à une autre variable.
Les opérations arithmétiques
En plus de l’assignation, on peut aussi exécuter de opérations arithmétiques sur les valeurs que notre programme manipule. Les opérateurs que nous allons couvrir aujourd’hui sont:
- L’addition : +
- La soustraction : –
- La division : /
- La multiplication : *
Regardons en détail comment additionner deux variables en utilisant le symbole « + ». Le résultat de cette addition va dépendre du type de valeurs sur laquelle on va appliquer notre addition. Si vos valeurs sont des nombres (int ou float), alors le résultat de l’addition va vous donner la somme des deux nombres. Si en revanche vos valeurs sont de type string, l’addition vous donnera la concaténation des deux strings :
number_1 = 23
number_2 = 54
number_sum = number_1 + number_2
print(number_sum)
string_1 = "Hello"
string_2 = "World"
string_sum = string_1 + string_2
print(string_sum)Si vous exécutez le code ci-dessus, vous verrez que la somme des nombre donne bien 77, alors que la somme des deux strings retourne « HelloWorld ».
Notez que pour qu’une opération fonctionne, il faut l’utiliser sur des types qui sont compatibles entre eux avec cette opération. Si vous essayez, par exemple, d’additionner une valeur de type int avec une valeur de type string, vous aurez une erreur qui vous indique « TypeError: unsupported operand type(s) for +: ‘int’ and ‘str' ». Ici un exemple qui génère une telle erreur :
number_1 = 23
string_1 = "Hello"
error_sum = number_1 + string_1Et si vous exécutez ce code, vous verrez le résultat suivant :
Ce que nous venons de voir pour l’addition s’applique aussi aux autres opérateurs que nous avons mentionnés (+, -, /, *). La seule différence est que ces opérateurs ne fonctionnent pas sur des valeurs de type string. Ici quelques exemples pour illustrer tout cela :
number_1 = 23
number_2 = 54
number_sum = number_1 + number_2
number_substraction = number_1 - number_2
number_multication = number_1 * number_2
number_division = number_1 / number_2
print(number_sum)
print(number_substraction)
print(number_multication)
print(number_division)En exécutant ce code, vous verrez les résultats des différentes opérations s’afficher à l’écran.
Les opérateurs relationnels / opérateurs de comparaison
En plus des opérateurs arithmétiques, il existe aussi des opérateurs qui nous permettent de comparer des valeurs entre elles. Ces opérateurs sont très importants pour la suite de notre cours. Apportez-y donc une grande importance, et ne sautez pas ce chapitre avant de les avoir maîtrisés. Ces opérateurs sont les suivants:
| Opérateur | Définition |
|---|---|
| == | égal – vérifie si deux valeurs sont égales |
| > | plus grand – vérifie si la valeur de gauche est plus grande que la valeur de droite |
| < | plus petit – vérifie si la valeur de gauche est plus petite que la valeur de droite |
| != | différent – vérifie si les deux valeurs sont différentes |
| >= | plus grand ou égal – vérifie si la valeur de gauche est plus grande ou égale à la valeur de droite |
| <= | plus petit ou égal – vérifie si la valeur de gauche est plus petite ou égale à la valeur de droite |
Ici quelques exemples d’utilisation de ces opérateurs :
number_1 = 23
number_2 = 54
is_number_1_bigger = number_1 > number_2
is_number_1_different = number_1 != number_2
is_number_1_smaller_equal = number_1 <= number_2
print(is_number_1_bigger)
print(is_number_1_different)
print(is_number_1_smaller_equal)En exécutant ce code, vous aurez le résultat suivant:
On voit donc que 13 n’est pas plus grand que 54 (False), que 13 est différent de 54 (True), et que 13 est bien plus petit ou égale à 54 (True). N’hésitez pas à faire des tests par vous-même en remplaçant les opérateurs ou les nombres, afin de bien vous familiariser avec ces opérateurs.
Notez que les opérateurs == et != peuvent aussi être utilisés pour comparer des strings. Exemple :
name_1 = "Jean"
name_2 = "Martin"
same_names = name_1 == name_2
different_names = name_1 != name_2
print(same_names)
print(different_names)Et ici, aussi on a bien le résultat attendu :
Comme les deux noms sont différents, la comparaison == retourne False et la comparaison != retourne True.
Les opérations booléennes
La dernière catégorie d’opérateurs que je veux vous présenter, et qui est, elle aussi, très importante pour la suite, sont les opérations sur les booléens. Les opérateurs en question sont les suivants :
| Opérateur | Déscription |
|---|---|
| and | Vérifie si deux valeurs sont toutes les deux True |
| or | Vérifie si l’une des deux valeurs est True |
| not | Vérifie si une valeur est False |
Ici quelques exemples afin de vous familiariser avec ces opérateurs :
is_adult = True
is_male = False
is_adult_and_male = is_adult and is_male
is_adult_or_male = is_adult or is_male
is_not_male = not is_male
is_adult_and_not_male = is_adult and not is_male
print(is_adult_and_male)
print(is_adult_or_male)
print(is_not_male)
print(is_adult_and_not_male)Le résultat de l’exécution de ce code est le suivant :
Comme is_adult est True et is_male est False, is_admin and is_male retourne False, car les deux valeurs ne sont pas True. Le or retourne True, car l’une des valeurs est bien True (is_admin). is_not_male retourne True, car is_male est False. Et pour finir is_adult_and_not_male retourne True également, car is_adult est True et not is_male est également True.
Ces opérateurs sont très importants. Essayez de modifier les valeurs et de créer vos propres comparaisons afin de bien assimiler ce chapitre avant de continuer le reste du cours !
Précédence des opérateurs
En Python, les opérateurs que nous venons de voir ont la précédence suivante :
| Opérateur(s) | Description |
|---|---|
| (…) | Les parenthèses ont la plus grande précédence et sont donc évaluées en premier |
| *, / | La multiplication et la division sont évaluées en deuxième lieu |
| -, + | Suivi des additions et soustractions |
| ==, !=, <, >, <=, >= | Suivent ensuite les opérateurs de comparaison |
| not | On arrive ensuite aux opérations booléennes avec le not qui évalué en premier |
| and | Le and est évalué après le not |
| or | Et pour finir, c’est au tour du or d’être évalué |
Notez que je ne parle ici que des opérateurs que nous avons vus dans ce cours. Il en existe d’autres et vous trouverez le tableau exact de précédences ici.
Pour des opérations complexes, il est préférable d’utiliser des paranthèses afin d’éviter toute ambiguïté !
Ici un exemple avec et sans parenthèses qui font exactement le même calcul :
number_1 = 2
number_2 = 3
complex_computation = number_1 + number_1 * number_2 + number_2
complex_computation_2 = number_1 + (number_1 * number_2) + number_2
print(complex_computation)
print(complex_computation_2)Le résultat des deux opérations est égal à 11.
Précision du type float
Un dernier point que j’aimerais traiter ici est la précision du type float. Dû à la representation interne des nombres de type float, il peut arriver que certains résultats vous paraissent étranges / faux. Prenons l’exemple suivant :
number_1 = 0.1
number_2 = 0.2
number_3 = 0.3
number_sum = number_1 + number_2
number_sum_equals_number_3 = number_3 == number_sum
print(number_sum)
print(number_sum_equals_number_3)Si vous lancez ce programme, vous verrez que number_sum est égale à 0.30000000000000004 et non pas 0.3, et donc number_sum_equals_number_3 retourne False. Ceci est dû la manière dont les nombres décimaux sont représentés en interne par votre ordinateur. En effet, ces nombres ne sont pas stockés sous une forme exacte mais sous forme d’approximation. En règle générale, ces déviations du résultat attendu sont minimes, et si on arrondit les résultats, on retrouve le résultat souhaité. Mais ces erreurs d’approximations peuvent se cumuler et, dépendant des applications que vous développez, ces erreurs peuvent être inacceptables.
Resources
Vous retrouvez ci-dessous un lien vers le code source utilisé dans ce chapitre. Ce lien est uniquement disponible pour les abonnés Standard et Premium.
Quiz
Répondez au quiz ci-dessous afin de vérifier que vous avez bien compris le contenu de cette leçon. Les quiz sont uniquement disponibles pour les abonnés Standard et Premium.