2. Déclarer une variable et lui affecter une valeur (langage Python)

Sommaire

  1. Qu’est-ce qu’une variable?
  2. Les différents types de variables
  3. Déclarer une variable et lui affecter une valeur
  4. Les variables de type int et float
  5. L’incrémentation
  6. Les variables de type str
  7. Modifier le type d’une variable
  8. Le formatage des chaînes de caractères
  9. Échapper des guillemets

1. Qu’est-cequ’une variable

Le travail d’un ordinateur, c’est de manipuler des données qui sont stockées dans sa mémoire. Or, cela nécessite un minimum d’organisation. C’est la raison pour laquelle les ordinateurs utilisent des variables, lesquelles correspondent à des adresses mémoire bien précises. Une variable, c’est donc avant tout une adresse mémoire mais c’est également un endroit que l’on réserve dans la mémoire de l’ordinateur. Lorsqu’on déclare une variable, on créé un petit tiroir sur lequel on colle une étiquette (qui correspond au nom de la variable) et dans lequel on stocke une valeur.

2. Les différents types de variables

Les variables peuvent stocker des données de différents types:

  • des nombres entiers qui correspondent au type int (integer en anglais)
  • des nombres décimaux qui correspondent au type float.
  • des strings (c’est-à dire des chaînes de caractères) qui correspondent au type str.
  • des booléens qui correspondent au type bool.
  • des listes qui correspondent au type list.
  • des tuples qui correspondent au type tuple.
  • des dictionnaires qui correspondent au type dict.

Dans un premier temps, découvrons ensemble les trois premiers types, c’est-à dire les nombres entiers, les nombres décimaux et les chaînes de caractères. Python est un langage dont le typage est dynamique. Cela signifie que c’est l’ordinateur, et non pas le programmeur, qui se charge de «typer» les variables. Le typage d’une variable consiste à associer à cette dernière un type de donnée, permettant à l’ordinateur de savoir si celle-ci est un nombre entier, un nombre décimal ou une chaîne de caractères. Le typage permet d’allouer des zones de mémoire de dimension suffisante pour stocker cette donnée, et éventuellement de vérifier que les manipulations programmées sur cette variable (opérations mathématiques, traitement de texte, etc.) sont cohérentes avec son type. En effet, il n’est pas possible d’additionner un nombre entier avec une chaîne de caractères. Dans certains langages, comme le langage C, le programmeur doit typer lui-même la variable au moment de sa déclaration :

int number = 13

En Python, nul besoin de se préoccuper du typage au moment de déclarer une variable. Cependant, pour la bonne exécution du programme, il est parfois nécessaire de modifier en cours de route le type d’une variable. C’est ce que nous allons voir un peu plus loin dans ce chapitre.

3. Déclarer une variable et lui affecter une valeur

Pour la suite de ce chapitre, nous allons travailler avec le terminal interactif Python 3.

benoit@computer:~$ python3
Python 3.8.10 (default, Nov 26 2021, 20:14:08) 
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Pour déclarer une variable, rien de plus simple, il suffit de lui donner un nom et de lui affecter une valeur. Par exemple, je déclare la variable n et je lui affecte le nombre entier 13 :

>>> n = 13

En Python, Vous ne pouvez pas déclarer une variable sans lui affecter de valeur.

>>> var
NameError: name 'var' is not defined

Donc, nous avons affecté le nombre entier 13 à la variable n. Dans les entrailles de votre ordinateur, un lutin numérique a collé une étiquette portant la lettre n sur la façade d’un tiroir. Puis, il a ouvert ce dernier et il y a glissé le nombre entier 13. Maintenant, à chaque fois que j’appelle la variable n, le nombre entier 13 apparaît. Notez bien que le signe = n’est pas un symbole d’égalité arithmétique mais un signe d’affectation, c’est-à dire que si j’ai envie d’affecter une autre valeur à la variable n, je peux le faire comme bon me semble. Tiens, d’ailleurs je le fais.

>>> n = 7

Le langage Python est sensible à la casse, c’est-à dire que n est différent de N. Une variable que vous avez baptisée nombre_7, est différente de la variable Nombre_7. Dans vos noms de variables, vous pouvez utiliser toutes les lettres combinées à tous les chiffres mais vous ne pouvez pas utiliser d’accents ni de caractères spéciaux à l’exception du tiret bas «underscore»: _
Bon… En fait, on peut utiliser des accents dans les noms de variable (comme par exemple ê è é) mais cette pratique est fortement déconseillée. En outre, vous ne pouvez pas commencer par un chiffre. Par exemple, 7nombre va vous lever une exception, c’est à dire une erreur, et le programme ne s’exécutera pas.

>>> 7Nombre = 7
  File "<stdin>", line 1
    7nombre = 7
     ^
SyntaxError: invalid syntax

4. Les variables de type int et float

Il est tout à fait possible d’effectuer des opérations arithmétiques entre des variables de type int et des variables de type float. Dans ce cas, le résultat obtenu est un nombre décimal. Je déclare deux variables et je leur affecte deux valeurs différentes :

>>> a = 5
>>> b = 8.7

Notez que pour les nombres décimaux, c’est la notation anglo-saxonne qui s’applique, c’est-à dire que le point remplace la virgule. En programmation, il n’existe pas de nombres à virgule! Je peux tout aussi bien les déclarer sur la même ligne en les séparant par des virgules :

>>> a, b = 5, 8.7

Je peux également inverser les valeurs de ces deux variables de cette manière :

>>> a, b = b, a

Maintenant, si j’entre ces trois commandes, qu’est-ce qui s’affiche ?

>>> print(a)
8.7
>>> print(b)
5
>>> print(a + b)
13.7

print() est la fonction qui permet d’afficher le contenu d’une variable ou le résultat d’une expression. Dans un terminal interactif Python 3, je peux aussi afficher une variable sans l’aide de print(). Cela dit, je vous invite à utiliser systématiquement print() car dans des programmes plus élaborés, cette fonction est nécessaire pour afficher un résultat en console et dénicher une erreur. Croyez-moi, print() va devenir votre meilleur ami!

>>> c = a * 2
>>> c
17.4

Explication

Au départ, la variable a stockait le nombre entier 5. Mais en cours de route, nous avons inversé les valeurs de a et b. a ne stockait plus 5 mais le nombre décimal 8.7. Multiplié par 2, cela nous donne la valeur affectée à c.

5. L’incrémentation

Il vous sera aussi très utile d’incrémenter une variable. L’incrémentation est l’opération qui consiste à ajouter 1 (ou une autre valeur entière) à un compteur. Elle est utilisée dans les boucles d’itération, un concept que nous découvrirons dans un chapitre ultérieur.

>>> c = c + 1
>>> c
18.4

Mais nous pouvons utiliser une autre syntaxe plus concise qui revient exactement au même :

>>> c += 1
>>> c
19.4

La décrémentation est l’opération inverse :

>>> c -= 1
>>> c
18.4

6. Les variables de type str

On peut affecter une chaîne de caractères (string) à une variable. Pour ce faire, il faut que cette dernière soit entourée de guillemets ou d’apostrophes :

>>> prenom = "Jérôme"
>>> sport = 'rugby'   
>>> prenom
Jérôme
>>> sport
rugby

Si vous oubliez les guillemets ou les apostrophes, Python va penser que Jérôme est une variable et il va partir à la recherche de cette dernière avant d’afficher cette erreur parce qu’il ne la trouvera pas:

>>> prenom = Jérôme
>>> prenom
NameError: name 'Jérôme' is not defined

Donc, veillez à ne pas oublier les guillemets ou les apostrophes. Comme on le voit dans cet exemple, il ne faut pas utiliser de lettres accentuées dans le nom de la variable (prenom) mais la chaîne de caractères peut contenir n’importe quelle lettre accentuée (‘Jérôme’) pourvu que l’encodage soit en utf-8. Il est possible d’additionner des chaînes de caractères. Cette opération s’appelle la concaténation. Exemple :

>>> phrase = prenom + " aime le " + sport
>>> print(phrase)
Jérôme aime le rugby

Il est possible de multiplier une chaîne de caractères.


 >>> print(prenom * 4)
 JérômeJérômeJérômeJérôme

7. Modifier le type d’une variable

prenom est une variable qui stocke une chaîne de caractères (‘Jérôme’) tandis que b est une variable qui stocke un nombre entier (5). Pour s’en assurer, il suffit d’utiliser la fonction type() :

>>> print(type(prenom))
class 'str'
>>> print(type(b))
class 'int'

Je déclare une nouvelle variable et je lui affecte la chaîne de caractères « 9 ».

>>> var = "9"

Il ne s’agit pas d’un nombre entier mais bien d’une chaîne de caractères puisque je l’ai entourée de guillemets! Maintenant, essayons d’additionner b et var et voyons ce que cela donne :

>>> print(b + var)
TypeError: unsupported operand type(s) for +:  'int' and 'str'

En clair, cela signifie : « Vous ne pouvez pas additionner un nombre entier avec une chaîne de caractères! » Il est également impossible d’additionner un nombre décimal avec une chaîne de caractères. Pour lever cette incompatibilité, la solution est fort simple. Il suffit de changer le type de la variable grâce à la fonction idoine. Dans notre exemple, il nous faut utiliser int().


 >>> var = int(var)
 >>> print(b + var)
 14

Maintenant, ça fonctionne, car les deux variables contiennent des nombres entiers qui peuvent s’additionner.

8. Le formatage des chaînes de caractères

Continuons avec les chaînes de caractère, et découvrons les méthodes format() et f-string qui sont très pratiques. Leur mission principale est d’appliquer la méthode str() sur des variables d’un autre type avant de les inclure dans une chaîne de caractères. Déclarons deux variables de type str() et une variable de type int().

>>> miss, mister, age = "Marie", "Christian", 46

Vous noterez que j’ai déclaré les trois variables sur la même ligne et que leurs noms n’ont pas d’accents. Pour manipuler ces variables, nous allons tout d’abord utiliser la méthode que je qualifierais d’usine à gaz.

>>> phrase = miss + " a " + str(age) + " ans." 
>>> print(phrase)
Marie a 46 ans

OK, le code fonctionne mais c’est laborieux et il ne faut rien oublier : ni les + pour concaténer, ni les guillemets autour des chaînes de caractères ( » a «  et  » ans . »), ni les espaces autour de a et avant le ans ( » a « ,  » ans. »). Enfin, il ne faut pas oublier de convertir le type de la variable age qui contient un nombre entier, en chaîne de caractères grâce à str() ! Sinon, vous allez avoir droit à une belle erreur. Je vous rappelle qu’il n’est pas possible d’additionner ou de concaténer une variable de type str() avec une variable de type int() ou float(). Bref, bon courage! Eh bien Mesdames, Messieurs, les méthodes format() et f-string vont se charger de simplifier tout ça!

8.1. La méthode format()

Reprenons notre exemple précédent et formatons la chaîne :

>>> phrase = "{} a {} ans.".format(miss, age) 
>>> print(phrase)
Marie a 46 ans

Alors comment est-ce que ça fonctionne? J’écris ma chaîne de caractères tout à fait normalement sauf que je remplace les variables que je veux insérer, par des accolades. Ensuite, j’applique la méthode format() sur la chaîne de caractères « {} a {} ans. ». La liaison entre la méthode format() et la chaîne de caractères est symbolisé par un simple point (en rouge, dans l’exemple ci-dessus).

Cette méthode prend en paramètres le même nombre d’arguments qu’il y a d’accolades. Il y en a deux, donc je lui passe deux arguments qui sont en l’occurrence deux variables. Or, il se trouve que l’une des deux variables est un nombre entier. Eh bien, ce n’est pas bien grave puisque format() va se charger de faire la conversion. La variable miss va s’insérer dans les premières accolades tandis que la variable age va s’insérer dans la deuxième paire d’accolades. Croyez-moi. Après un petit temps d’adaptation, cette méthode est beaucoup plus simple. Par exemple, je vais remplacer miss par mister.

>>> phrase = "{} a {} ans.".format(mister, age) 
>>> print(phrase)
Christian a 46 ans

Vous pouvez même appliquer cette méthode non pas sur une variable mais directement sur une chaîne de caractères. Cela vous évite de créer une variable :

>>> print("{} a {} ans.".format(mister, age)) 
Christian a 46 ans

Il est possible également de donner un indice aux accolades et ainsi de manipuler cette méthode avec encore plus de souplesse. Je m’explique. Créons deux variables :

>>> nom1, nom2 = "Raoul", "Finegoule"
>>> phrase = "Mon chien se nommme {0} et mon chat {1}.".format(nom1, nom2)
Mon chien se nomme Raoul et mon chat Finegoule 

Maintenant, je vais inverser les prénoms en inversant les indices dans les accolades :

>>> nom1, nom2 = "Raoul", "Finegoule"
>>> phrase = "Mon chien se nommme {1} et mon chat {0}.".format(nom1, nom2)
Mon chien se nomme Finegoule et mon chat Raoul 

Merveilleux, n’est-ce-pas? Je suis sûr que vous avez remarqué quelque chose… Eh oui! En informatique, on commence à compter à partir de 0 et non pas de 1! Si mes indices avaient été {1} et {2}, Python aurait levé une exception.

>>> nom1, nom2 = "Raoul", "Finegoule"
>>> phrase = "Mon chien se nommme {1} et mon chat {2}.".format(nom1, nom2)
IndexError: Replacement index 2 out of range for positional args tuple 

Il trouve l’indice 1 qui correspond à la variable nom_deux, mais il ne trouve pas l’indice 2 qui correspond à une troisième variable que je n’ai pas déclarée. L’indice 2 est out of range, c’est-à-dire en dehors de la plage.

8.2. La méthode f-string

f-string est la méthode de formatage la plus récente et la plus aboutie. C’est celle que j’utilise systématiquement. Voici comment on la met en œuvre. Il suffit de placer un f juste avant la chaîne de caractères et d’insérer directement les variables à l’intérieur d’accolades.

>>> miss, mister, age, taille = "Marie", "Christian", 46, 1.72
>>> f'{mister} a {age} ans.'
Christian a 46 ans 
>>> f'{miss} mesure {taille} m.'
Marie mesure 1.72 m.

On peut même insérer des bouts de code comme dans l’exemple ci-dessous! Je liste et j’affiche le contenu de mon répertoire ~/Documents/Informatique. Ne vous inquiétez pas si certaines instructions sont obscures. Nous verrons cela dans un chapitre ultérieur.

>>> import os
>>> f'Mon répertoire \"Informatique\" contient : {", ".join(os.listdir("/home/benoit/Documents/Informatique"))}'
Mon répertoire "Informatique" contient : Miamondo.org, Lilo, Python, Configuration_PC_Boudaud, Bash, Linux

9. Échapper des guillemets

Dernier point, si vous voulez insérer des guillemets doubles dans une chaîne de caractères, vous avez deux possibilités :

  • Utiliser des guillemets simples pour entourer la chaîne de caractères.
>>> print('Mon répertoire "Informatique" contient six sous-répertoires.')
  • Échapper les guillemets avec des barres obliques inversées.
>>> print("Mon répertoire \"Informatique\" contient six sous-répertoires.")

2 commentaires sur « 2. Déclarer une variable et lui affecter une valeur (langage Python) »

Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s