Chapitre 2 Les Variables

March 7, 2021

1 Qu’est-ce qu’une variable ?

La notion de variable constitue l’un des éléments les plus fondamentals de la programmation. Dans
la programmation, on ne peut pas faire grand-chose sans variables. Vous connaissez probablement
les variables de vos jours d’apprentissage de l’algèbre. Les variables ne sont pas vraiment différentes
des variables déjà rencontrées dans vos cours de mathématique. Une variable est un nom qui
contient une valeur. Le nom reste le même tandis que la valeur peut changer. En algèbre, cette
variable était souvent x. Pour utiliser cette variable, vous lui donnez une valeur. L’équation ferait
alors les calcules nécessaires, et vous obtiendriez un résultat pour y.
En outre, le couple (variable, valeur) est analogue au couple (question, réponse). La question est
toujours la même, mais la réponse à cette question peut changer. Par exemples:
-. Combient d’étudiant dans la salle? la variable, ici, est le nombre d’étudiant et la valeur est, par
exemple, 15. Le lendemain ceci pourra changer, par exemple 20.
-. Quelle heure est-il? la variable est l’heure actuelle et la valeur est, par exemple, 15:30. Une
minute après, la réponse à cette même question sera 15:31.
En Python, la création d’une variable se fait en lui attribuant une valeur. Par exemple, pour
résoudre l’équation “y = 2x + 1”, on a besoin de l’une des valeurs, de x ou de y. De même, pour
utiliser une variable en Python, elle doit avoir une valeur. La valeur peut changer plus tard, mais
elle a besoin d’une valeur pour commencer.
Exemple:
[1]: #Création d'une variable nommée x ayant comme valeur 3
x=3
#Affichage de la valeur de la variable x
print(x, type(x))
x=1.2
y=0
print(x, type(x))
print(y,type(y))

3 <class 'int'>
1.2 <class 'float'>
0 <class 'int'>
Dans l’exemple précédant, il s’agit de créer une variable nommée x ayant comme valeur 3. Cette
opération s’appelle une instruction d’affection. Elle affecte la valeur 3 à la variable x.

1
 Règles et conventions
Règles
Lorsque nous choisissons des noms de variables, nous devons garder à l’esprit deux choses: un
ensemble de règles et certaines conventions.
Les règles qui couvrent les noms de variables, d’une manière générale les identificateurs sont: 1.
Les noms de variable ne peuvent contenir que des lettres, des chiffres et des traits de soulignement
(underscores). Ils ne contiennent pas des espaces ou des caractères spéciaux. 2. Les noms de
variable doivent commencer par des lettres ou des traits de soulignement. Ces derniers sont utilisés
généralement que dans certaines situations. 3. Les noms de variables ne doivent pas coincider avec
des mots réservés.
Lorsque l’une de ces règles est violée, une erreur de syntaxe est générée.
Attention :
• On affecte des valeurs aux variables et non pas des variables aux valeurs.
• On doit attribuer une valeur à la variable avant de l’utiliser.
Exemples
[2]: mavariable1=5
print(mavariable1)

[3]: for=10

File "<ipython-input-3-c66d639d3bbe>", line 1

for=10
^
SyntaxError: invalid syntax

[4]: mavariable=5

[5]: 3=4

File "<ipython-input-5-b3c2d8e4d06b>", line 1

3=4
^
SyntaxError: cannot assign to literal

[6]: x='bonjour'
y=x+1
print(x,y)

2
 ---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-6-dffd00f50d5f> in <module>
1 x='bonjour'
----> 2 y=x+1
3 print(x,y)

TypeError: can only concatenate str (not "int") to str

Par ailleurs, il est possible de définir une variable sans valeur. C’est tout à fait différent qu’une
variable non initialisée.
Exemples
[7]: maVariable=None
print(maVariable)
print(maVariableNonDeclare)

None

---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-7-1e19235e02c1> in <module>
1 maVariable=None
2 print(maVariable)
----> 3 print(maVariableNonDeclare)

NameError: name 'maVariableNonDeclare' is not defined

Comme vous voyez dans l’exemple précédent, une erreur de type NameError est produite. Cette
erreur est générée suite à la variable maVariableNonDeclare qui est non initialisée. Par contre, il
n’y a pas de problème relatif la variable maVariable.
Conventions
La violation des conventions n’engendre aucune erreur. La raison des convention est d’avoir un
code lisible ou bien auto-documenté. Cela veut dire que le nom d’une variable doit être significatif.
Il doit informer du contenu de la variable.
Exemple
[8]: a=5
tt=20
age=40
nom="Salem"

Dans l’exemple précédant, il est claire que 40 vaut l’age et Salem vaut un nom. Par contre, pour
20 et 5 on ne peut pas deviner de quoi s’agit-il.

3
 2 Les différents types de variables.
Le type d’une variable est une notion très important. Premièrement, la comparaison de variables de
types différents est, généralement, impossible. Deuxièmement, il peut y avoir certaines opérations
qu’on ne peut pas faire que sur certains types de données. Par exemple, il est possible de multiplier
des nombres entiers, par contre, il est impossible de multiplier des chaînes de caractères. D’une
manière générale, les opérations n’ont pas de sens que dans le contexte de certains types de données.
Troisièmement, le type de variable est util pour l’allocation de la mémoire.
Les types de base reconnus dans la plupart des langages de programmation sont :
• Entiers ou nombres entiers.
• Des nombres réels ou des nombres qui peuvent avoir des décimales.
• Des caractères, comme des lettres et des chiffres individuels.
• Les chaînes, qui sont des collections de caractères dans une ligne.
• Les valeurs booléennes, qui tiennent simplement vrai ou faux.
Par ailleurs, les variables peuvent contenir presque tous les types d’informations qu’on peut imag-
iner.

2.1 Les types élémentaires en Python

En Python, l’attribution de type est dynamique. Une variable obtient son type à partir de la valeur
qui lui est affectée. Si on affecte un entier à une variable, la variable prend le type entier. Si on lui
attribue, ensuite, une chaîne de caractères, la variable prend, alors, ce nouveau type.
Les types éléméntaires en Python, sont :
• int, abréviation de integer. Un entier peut être n’importe quel nombre non décimal positif ou
négatif.
• float, abréviation de floating point number. Un flottant est un nombre réel.
• str, abréviation de string of characters. Tout message textuel est une chaîne.
• bool, abréviation de boolean. Un booléen prend True ou False, rien d’autre.
• complex, abréviation de complex numbers. Un nombre complexe est nombre qui contient une
partie rééle et une autre imaginaire.
Exemples
Pour réaliser ces exemples, on utilsera la fonction type(). Cette fonction prédéfinie renvoie le type
de la variable donnée comme paramètre.
[9]: #Affecter la valeur 5 on aura un entier
varEntier=5
print('varEntier',type(varEntier))
#Ajouter .0 à 5 on aura un float
varReel=5.0
print('varReel',type(varReel))
#Mettre 5.0 entre deux guillemets on aura une chaine de caractères
varChaineDeCarac="bonjour"
print('varChaineDeCarac',type(varChaineDeCarac))
#Le type booléen n'accepte que True ou False
varBool=True

4
 print('varBool',type(varBool))
#Le type complexe est composé de deux parties
#réele et imaginaire caractérisée par j
varComplexe=2+3j
print('varComplexe',type(varComplexe))

varEntier <class 'int'>

varReel <class 'float'>
varChaineDeCarac <class 'str'>
varBool <class 'bool'>
varComplexe <class 'complex'>

2.2 Conversions de type

Parfois le développeur aura besoin de convertir des valeurs ou des variables d’un type vers un
autre. Par exemple, pour un programme qui lit du texte à partir d’un fichier. Il rencontre le
texte «5554321.» Doit-il être stocké sous forme de chaîne de caractère «5554321» ou sous la forme
numérique 5554321? Tout dépendra de l’objectif du code. Anisi, on a besoin d’un moyen de
convertir entre les différents types.
La conversion vers une chaine de caractères
Python fournit la fonction str() pour convertir presque n’importe quel type de variable en une
chaîne de caractère.
Exemples
[10]: varInt=5
varIntToStr=str(varInt)
print("le type de varIntToStr est :",type(varIntToStr),varIntToStr)
varFloat=5.0
varFloatToStr=str(varFloat)
print("le type de varReelToStr est :",type(varFloatToStr),varFloatToStr)
varBool=True
varBoolToStr=str(varBool)
print("le type de varBoolToStr est :",type(varBoolToStr),varBoolToStr)
varComplex=2+3j
varComplexToStr=str(varComplex)
print("le type de varComplexeToStr est :",type(varComplexToStr),varComplexToStr)

le type de varIntToStr est : <class 'str'> 5

le type de varReelToStr est : <class 'str'> 5.0
le type de varBoolToStr est : <class 'str'> True
le type de varComplexeToStr est : <class 'str'> (2+3j)
Conversion à partir de chaînes de caractères
De la même manière, il existe les fonctions int(), bool(), float() et complex() pour la conversion des
données vers, respectivement, les types entier, réel, booléen et complexe. Chacune des fonctions
int(), float() et complex() renvoie le résultat dans son type en cas de succès ou génére une erreur

5
 de type ValueError en cas d’échec. Par contre, la fonction bool() renvoie, partiquement toujour,
un résultat True ou False.
Exemples
[11]: #Exemple1
varStrInt="5"
varStrIntToInt=int(varStrInt)
print("le type de varStrIntToInt est :",type(varStrIntToInt))
varStrFloat="5.0"
varStrFloatToFloat=float(varStrFloat)
print("le type de varStrFloatToFloat est :",type(varStrFloatToFloat))
varStrBool="True"
varStrBoolToBool=bool(varStrBool)
print("le type de varStrBoolToBool est :",type(varStrBoolToBool))
varStrComplex="2+3j"
varStrComplexToComplex=complex(varStrComplex)
print("le type de varStrComplexToComplex est :",type(varStrComplexToComplex))

le type de varStrIntToInt est : <class 'int'>

le type de varStrFloatToFloat est : <class 'float'>
le type de varStrBoolToBool est : <class 'bool'>
le type de varStrComplexToComplex est : <class 'complex'>

[12]: #Exemple2
varStrInt='-6.6'
varStrIntToInt=int(varStrInt)
print("le type de varStrIntToInt est :",type(varStrIntToInt))
varStrInt

---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-12-be40f8416d0c> in <module>
1 #Exemple2
2 varStrInt='-6.6'
----> 3 varStrIntToInt=int(varStrInt)
4 print("le type de varStrIntToInt est :",type(varStrIntToInt))
5 varStrInt

ValueError: invalid literal for int() with base 10: '-6.6'

[13]: #Exemple3
varStrBool='0'
varStrBoolToBool=bool(varStrBool)
print("le type de varStrBoolToBool est :",type(varStrBoolToBool))
print(varStrBoolToBool)

le type de varStrBoolToBool est : <class 'bool'>

6
True

3 Instructions de base sur les variables

Lorsqu’on parle de variable, on parle généralement de deux catégories d’opération : La modification
et la consultation. Pour la consultation, nous expliquerons l’impression du contenu d’une variable
à l’aide de la fonction print(). Quant à la modification, nous nous intéresserons essentiellement de
la modification à partir du clavier, à l’aide de la fonction input(), et l’affectation.

3.1 Le fonction print()

A l’aide de la fonction print(), le développeur peut afficher des messages ou le contenu de variable,
essentiellement, sur écran.
A l’intérieur des parenthèses, la fonction print() accept toutes les combinaisons possibles de chaines
de caractères, variables et expressions séparées par des virgules. Non seulement, la fonction print()
offre le moyen de modifier le séparateur, la position du curseur à la fin de son exécution et la
destination vers laquelle print() envoie les données.

Syntaxe de la fonction print()

À l’intérieur d’une chaîne, le caractère antislash (\) permet de donner une signification spéciale à
certaines séquences de caractères (voir Tab1).

7
 Tab1 : Séquences spéciales

Exemples
[14]: maVar1=5
maVar2=6
print("La somme de",maVar1,"et",maVar2,"\nest égale",maVar1+maVar2)

La somme de 5 et 6
est égale 11

3.2 L’affectation
La syntaxe générale de l’instruction d’affectation est : V = expression où v est une variable.
L’opérateur d’affectation en Python est “=”.
Exemple
[15]: x=1+2
print(x)

3
Le déroulement de l’exécution de l’exemple précédant est dans l’ordre le suivant :
1. Evaluation de l’expression 1+2 (qui vaut 3)
2. affectation du résultat (3) à la variable x
Outre, Python permet l’affectation multiple.
Exemple :

8
[16]: a,b,c=5,"a","2.3"
print('contenu de a',a)
print('contenu de b',b)
print('contenu de c',c)

contenu de a 5
contenu de b a
contenu de c 2.3

4 La fonction input()
La fonction input() admet entre les parenthèses, comme paramètre, une chaine de caractères. Cette
dernière invitera l’utilisateur à saisir une valeur. Le programme attend alors que l’utilisateur tape
quelque chose dans la console et appuie sur Entrée. Le flux de données venant du clavier sera affecter
à la variable qui est à gauche du symbole d’affectation. Par ailleurs, tout ce qui est saisi par le
clavier est considére comme une chaine de caractère. De plus, Python attribue dynamiquement
les types aux variables. Nous pouvons conclure que notre variable aura le type str. Ainsi, il faut
réfléchir à une conversion de type en cas où la valeur demandée est de type autre que chaine de
caractère.

Syntaxe de la fonction input()

Exemple
[17]: varNom=input("Saisir votre nom : ")
print(type(varNom))
varAge=input("Saisir votre Age : ")
print(type(varAge))
print("Votre années de naissance est :", 2020-varAge)

Saisir votre nom : Salem

<class 'str'>
Saisir votre Age : 20
<class 'str'>

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)

9
 <ipython-input-17-198382678565> in <module>
3 varAge=input("Saisir votre Age : ")
4 print(type(varAge))
----> 5 print("Votre années de naissance est :", 2020-varAge)

TypeError: unsupported operand type(s) for -: 'int' and 'str'

[18]: #Corrigé de l'exemple

varNom=input("Saisir votre nom : ")
print(type(varNom))
varAge=int(input("Saisir votre Age : "))
print(type(varAge))
print("Votre années de naissance est :", 2020-varAge)

Saisir votre nom : Salem

<class 'str'>
Saisir votre Age : 20
<class 'int'>
Votre années de naissance est : 2000

10