Cours de Python Introduction à

la programmation Python
TECHNOLOGIE -2AC/A/B
 C’est quoi Python ?
• Le langage de programmation Python a été créé en 1989 par Guido van
Rossum, aux Pays-Bas.
• Le nom Python vient d’un hommage à la série télévisée Monty Python’s Flying
Circus dont G. van Rossum est fan.
• La première version publique de ce langage a été publiée en 1991.
• La dernière version de Python est la version 3. Plus précisément, la version
3.11 a été publiée en octobre 2022.
• La version 2 de Python est obsolète et n’est plus maintenue, évitez de l’utiliser.
• La Python Software Foundation 1 est l’association qui organise le
développement de Python et anime la communauté de développeurs et
d’utilisateurs.
 Variables
• Une variable est une zone de la mémoire de l’ordinateur dans laquelle une
valeur est stockée. Aux yeux du programmeur, cette variable est définie par
un nom, alors que pour l’ordinateur, il s’agit en fait d’une adresse, c’est-à-
dire d’une zone particulière de la mémoire.
• En Python, la déclaration d’une variable et son initialisation (c’est-à-dire la
première valeur que l’on va stocker dedans) se font en même temps.
testez les instructions suivantes après avoir lancé l’interpréteur :
1| >>> x = 2
2| >>> x
3| 2
 Les types de variables
• Le type d’une variable correspond à la nature de celle-ci. Les trois principaux types dont nous
aurons besoin dans un premier temps sont les entiers (int), les nombres décimaux que nous
appellerons floats et les chaînes de caractères (str). Bien sûr, il existe de nombreux autres types
(par exemple, les booléens, les nombres complexes, etc.).
Dans l’exemple précédent, nous avons stocké un nombre entier (int) dans la variable x, mais il est
tout à fait possible de stocker des floats, des chaînes de caractères (str) ou de nombreux autres
types de variable que nous verrons par la suite :
>>> y = 3.14
>>> y
3.14
>>> a = " bonjour "
'bonjour ’
 Remarque

Python reconnaît certains types de variable automatiquement (entier, float). Par

contre, pour une chaîne de caractères, il faut l’entourer de guillemets (doubles,
simples, voire trois guillemets successifs doubles ou simples) afin d’indiquer à
Python le début et la fin de la chaîne de caractères.
Dans l’interpréteur, l’affichage direct du contenu d’une chaîne de caractères se
fait avec des guillemets simples, quel que soit le type de guillemets utilisé pour
définir la chaîne de caractères.
En Python, comme dans la plupart des langages de programmation, c’est le
point qui est utilisé comme séparateur décimal. Ainsi, 3.14 est un nombre
reconnu comme un float en Python alors que ce n’est pas le cas de 3,14
 Nommage

Le nom des variables en Python peut être constitué de

lettres minuscules (a à z), de lettres majuscules (A à Z), de
nombres (0 à 9) ou du caractère souligné (_).
Vous ne pouvez pas utiliser d’espace dans un nom de
variable. Par ailleurs, un nom de variable ne doit pas
débuter par un chiffre et il n’est pas recommandé de le faire
débuter par le caractère .
De plus, il faut absolument éviter d’utiliser un mot « réservé
» par Python comme nom de variable (par exemple : print,
range, for, from, etc.).
 Opérations

Opérations sur les types numériques Les quatre opérations arithmétiques de

base se font de manière simple sur les types numériques (nombres entiers et
floats) :
1| >>> x = 45
2| >>> x + 2
3| 47
4| >>> x - 2
5| 43
Remarquez toutefois que si vous mélangez les types entiers
et floats, le résultat est renvoyé comme un float (car ce type
est plus général).
Par ailleurs, l’utilisation de parenthèses permet de gérer les
priorités.
L’opérateur / effectue une division. Contrairement aux
opérateurs +, - et *, celui-ci renvoie systématiquement un
float :
1| >>> 3 / 4
2 |0.75
3 |>>> 2.5 / 2
4| 1.25
L’opérateur puissance utilise les symboles ** :
1| >>> 2**3
2| 8
3| >>> 2**4
4| 16
Pour obtenir le quotient et le reste d’une division, on utilise
respectivement les symboles // et modulo % :
1| >>> 5 // 4
2| 1
3| >>> 5 % 4
4| 1
5 |>>> 8 // 4
6| 2
7| >>> 8 % 4
8| 0
Les symboles +, -, *, /, **, // et % sont appelés opérateurs, car ils réalisent des
opérations sur les variables. Enfin, il existe des opérateurs « combinés » qui
effectue une opération et une affectation en une seule étape :
1| >>> i = 0
2| >>> i = i + 1
3| >>> i
4| 1
5| >>> i += 1
6|>>> i
7| 2
8|>>> i += 2
9| >>> i
10| 4
L’opérateur += effectue une addition puis affecte le résultat à la même variable.
Cette opération s’appelle une « incrémentation ». Les opérateurs -=, *= et /= se
comportent de manière similaire pour la soustraction, la multiplication et la
division
Opérations sur les chaînes de caractères
Pour les chaînes de caractères, deux opérations sont possibles, l’addition et la
multiplication :
1| >>> chaine = " Salut "
2| >>> chaine
3| 'Salut ‘
4| >>> chaine + " Python "
5| 'Salut Python ‘
6| >>> chaine * 3
7| 'SalutSalutSalut ‘
L’opérateur d’addition + concatène (assemble) deux chaînes de caractères.
L’opérateur de multiplication * entre un nombre entier et une chaîne de
caractères duplique (répète) plusieurs fois une chaîne de caractères.
 La fonction type()
Si vous ne vous souvenez plus du type d’une variable, utilisez la
fonction type() qui vous le rappellera.
1| >>> x = 2
2| >>> type (x)
3| < class 'int ‘>
4| >>> y = 2.0
5| >>> type (y)
6| < class 'float ‘>
7| >>> z = '2’
8| >>> type (z)
9| < class 'str ‘>
Nous verrons plus tard ce que signifie le mot class
 Conversion de types
En programmation, on est souvent amené à convertir les types, c’est-à-dire
passer d’un type numérique à une chaîne de caractères ou vice-versa.
En Python, rien de plus simple avec les fonctions int(), float() et str(). Pour vous
en convaincre, regardez ces exemples :
1| >>> i = 3
2| >>> str (i)
3| '3’
4| >>> i = '456 ‘
5| >>> int (i)
6| 456
7| >>> float (i )
8|456.0
9| >>> i = '3.1416 ‘
10| >>> float (i )
11| 3.1416
 Minimum et maximum
Python propose les fonctions min() et max() qui renvoient
respectivement le minimum et le maximum de plusieurs
entiers et / ou floats :
1| >>> min (1 , -2, 4)
2| -2
3| >>> pi = 3.14
4| >>> e = 2.71
5| >>> max (e , pi )
6| 3.14
7| >>> max (1 , 2.4 , -6)
8| 2.4
 EXERCICES

1-Essayez de prédire le résultat de chacune des instructions

suivantes, puis vérifiez-le dans l’interpréteur Python :
— (1+2)**3
— "Da" * 4
— "Da" + 3
— ("Pa"+"La") * 2
— ("Da"*4) / 2
—5/2
— 5 // 2
—5%2
 EXERCICES

2-Essayez de prédire le résultat de chacune des instructions

suivantes, puis vérifiez-le dans l’interpréteur Python :
— str(4) * int("3")
— int("3") + float("3.2")
— str(3) * float("3.2")
— str(3/4) * 2
 Affichage
La fonction print() Dans le chapitre 1, nous avons rencontré la fonction print() qui affiche
une chaîne de caractères (le fameux "Hello world!"). En fait, la fonction print() affiche
l’argument qu’on lui passe entre parenthèses et un retour à ligne. Ce retour à ligne
supplémentaire est ajouté par défaut. Si toutefois, on ne veut pas afficher ce retour à la
ligne, on peut utiliser l’argument par « mot-clé » end :
1| >>> print (" Hello world !")
2| Hello world !
3| >>> print (" Hello world !" , end ="")
4| Hello world !> >>
Une autre manière de s’en rendre compte est d’utiliser deux fonctions print() à la suite. Dans la portion
de code suivante, le caractère « ; » sert à séparer plusieurs instructions Python sur une même ligne :
1| >>> print (" Hello ") ; print (" Joe ")
2| Hello
3| Joe
4| >>> print (" Hello ", end ="") ; print (" Joe ")
5| HelloJoe
6| >>> print (" Hello ", end =" ") ; print (" Joe ")
7| Hello Joe
La fonction print() peut également afficher le contenu d’une variable quel que soit son type. Par
exemple, pour un entier :
1| >>> var = 3
2| >>> print ( var )
3| 3
Il est également possible d’afficher le contenu de plusieurs variables (quel que soit leur type) en les
séparant par des virgules :
1| >>> x = 32
2| >>> nom = " John "
3| >>> print ( nom , "a", x , " ans ")
4| John a 32 ans
Python a écrit une phrase complète en remplaçant les variables x et nom par leur contenu. Vous
remarquerez que pour afficher plusieurs éléments de texte sur une seule ligne, nous avons utilisé le
séparateur « , » entre les différents éléments. Python a également ajouté un espace à chaque fois que
l’on utilisait le séparateur « , ». On peut modifier ce comportement en passant à la fonction print()
l’argument par mot-clé sep :
1| >>> x = 32
2| >>> nom = " John "
3| >>> print ( nom , "a", x , " ans ", sep ="")
4| Johna32ans
5| >>> print ( nom , "a", x , " ans ", sep =" -")
6| John -a -32 - ans
 Listes
1 Définition
Une liste est une structure de données qui contient une série de valeurs. Ces valeurs n'étant pas forcément
du même type, ceci confère une grande flexibilité à ces listes. Une liste est déclarée par une série de valeurs
(ne pas oublier les guillemets, simples ou doubles, s'il s'agit de chaînes de caractères) séparées par des
virgules, et le tout encadré par des crochets. En voici quelques exemples :

>>> animaux = ['girafe','tigre','singe','souris']

>>> tailles = [5, 2.5, 1.75, 0.15]
>>> mixte = ['girafe', 5, 'souris', 0.15]
>>> animaux
['girafe', 'tigre', 'singe', 'souris']
>>> tailles
[5, 2.5, 1.75, 0.15]
>>> mixte
['girafe', 5, 'souris', 0.15]

Lorsque l’on affiche une liste, Python la restitue telle qu’elle a été saisie.
2.Utilisation
Un des gros avantages d'une liste est que vous pouvez appeler ses éléments par leur position. Ce numéro est
appelé indice (ou index) de la liste.
liste : ['girafe', 'tigre', 'singe', 'souris']
indice : 0 1 2 3
Soyez très attentifs au fait que les indices d'une liste de n éléments commence à 0 et se termine à n-1. Voyez
l'exemple suivant :
>>> animaux = ['girafe', 'tigre', 'singe', 'souris’]
>>> animaux [0]
'girafe’
›>> animaux [1]
'tigre’
>>> animaux [3]
'souris’
Par conséquent, si on appelle l'élément d'indice 4 de notre liste, Python renverra un message d’erreur :
>>> animaux[4]
Traceback (innermost last):
File "<stdin>", line 1, in ?
IndexError: list index out of range

N’oubliez pas ceci ou vous risqueriez d’obtenir des bugs inattendus !

3. Opération sur les listes

Tout comme les chaînes de caractères, les listes supportent l'opérateur + de concaténation, ainsi que
l'opérateur * pour la duplication :

>>> ani1 = ['girafe','tigre']

>>> ani2 = ['singe','souris']
>>> ani1 + ani2
['girafe', 'tigre', 'singe', 'souris']
>>> ani1 * 3
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre’]
Un autre avantage des listes est la possibilité de sélectionner une partie en utilisant un indiçage construit
sur le modèle [m: n+1] pour récupérer tous les éléments, du émième au énième (de l'élément m inclus à
l'élément n+1 exclus). On dit alors qu'on récupère une tranche de la liste, par exemple:
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> animaux[0:2]
['girafe',
'tigre']
>>> animaux[0:3]
['girafe', 'tigre', 'singe']
>>> animaux[0:]
['girafe', 'tigre', 'singe', 'souris']
>>> animaux[:]
['girafe', 'tigre', 'singe', 'souris']
>>> animaux[1:]
['tigre', 'singe', 'souris’]

Remarquez que lorsqu'aucun indice n'est indiqué à gauche ou à droite dis symbole : .Python prend par
défaut tous les éléments depuis le début ou tous les éléments jusqu'à la fin respectivement.
Dans les versions récentes de Python, on peut aussi préciser le pas en ajoutant un : /supplémentaire et
en indiquant le pas par un entier.
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> animaux[0:3:2]
['girafe','singe']
>>> x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[::1]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[::2]
[0, 2, 4, 6, 8]
>>> x[::3]
[0, 3, 6, 9]
>>> x[1:6:3]
[1, 4]

Finalement, on voit que l’accès au contenu d’une liste avec des crochets fonctionne sur le
modèle liste[début:fin:pas]
4. Fonctions range et Len
L’instruction range() vous permet de créer des listes d’entiers (et d’entiers uniquement)
de manière simple et rapide. Voyez plutôt:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0,5)
[0, 1, 2, 3, 4]
>>> range(15,20)
[15, 16, 17, 18,19]
>>> range(0,1000,200)
[0, 200, 400, 600, 800]
>>> range(2,-2,-1)
[2, 1, 0, -1]
L’instruction range() fonctionne sur le modèle range(début,fin,pas). Les arguments entre crochets sont
optionnels.
L’instruction len() vous permet de connaître la longueur d’une liste, ce qui parfois est bien pratique
lorsqu’on lit un fichier par exemple, et que l’on ne connaît pas a priori la longueur des lignes. Voici un
exemple d’utilisation :
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> len(animaux)
4
>>>len(range(10))
10
5. Listes de listes
Pour finir, sachez qu’il est tout-a. Fait possible de construire des listes de listes. Cette fonctionnalité peut
être parfois très pratique. Par exemple :

>>> enclos1 = ['girafe', 4]

>>> enclos2 = ['tigre', 2]
>>> enclos3 = ['singe', 5]
>>> zoo = [enclos1, enclos2, enclos3]
>>> zoo
[['girafe', 4], ['tigre', 2], ['singe', 5]]

Dans cet exemple, chaque sous-liste contient une catégorie d’animal et le nombre d’animaux
pour chaque catégorie. Pour accéder à un élément de la sous-liste, on utilise un double indiçage.
>>> zoo[1]
['tigre', 2]
>>> zoo[1][0]
'tigre'
>>> zoo[1][1]
2
On verra un peu plus loin qu’il existe en Python les dictionnaires qui sont très pratiques pour faire ce
genre de choses.
6.Boucles
Imaginez que vous ayez une liste de quatre éléments dont vous voulez afficher les éléments les uns
après les autres. Dans l’état actuel de vos connaissances, il faudrait taper quelque chose du style :
>>>animaux = ['girafe','tigre','singe','souris’]
>>>Print(animaux[0])
>>>Print(animaux[1])
>>>Print(animaux[2])
>>>Print(animaux[3])
Si votre liste ne contient que quatre éléments, ceci est encore faisable mais imaginez qu’elle en contienne
100 voire 1000 ! Pour remédier à cela, il faut utiliser les boucles.
Regardez l’exemple suivant :
>>> animaux = ['girafe','tigre','singe','souris’]
>>> for i in animaux:
Print(i)
Girafe
tigre
singe
Souri
Notez également que si le corps de votre boucle contient plusieurs instructions, celles-ci doivent être
indentées de la même manière (e.g. si vous avez indenté la première instruction avec deux espaces,
vous devez faire de même avec la deuxième instruction, etc).
Remarquez également un autre aspect de la syntaxe, une instruction for doit absolument se terminer
par le signe deux-points:.
Il est aussi possible d’utiliser une tranche d’une liste :
>>> animaux = ['girafe','tigre','singe','souris’]
>>> for i in animaux[1:3]:
... Print(i)
Tigre
singe
On a vu que les boucles for pouvaient utiliser une liste contenant des chaînes de caractères, mais
elles peuvent tout aussi bien utiliser des listes numériques. En utilisant l’instruction range on peut
facilement accéder à une liste d’entiers.
>>> for i in range(4):
... Print(i)
...
0
1
2
3
Par conséquent, vous pouvez utiliser les boucles comme une itération sur les indices des éléments d’une
liste.

>>> animaux = ['girafe', 'tigre', 'singe', 'souris’]

>>> for i in range(4):
... Print(animaux[i])
...
Girafe
Tigre
Singe
Souris

Cependant, la méthode à utiliser pour parcourir avec une boucle for les éléments d’une liste est celle qui
réalise les itérations directement sur les élements.

>>> animaux = ['girafe','tigre','singe','souris’]

>>> for i in animaux:
... Print(i)
...
Girafe
Tigre
Singe
souris
7.Comparaisons
Avant de passer à une autre sorte de boucles (les boucles while), nous abordons tout de suite les
comparaisons. Celles-ci seront reprises dans le chapitre des tests. Python est capable d’effectuer toute une
série de comparaisons telles que :
syntaxe Python signification
== égal à
!= différent de
> supérieur à
>= supérieur ou égal à
< inférieur à
<= inférieur ou égal à
Observez l’exemple suivant sur des nombres entiers.
>>> x = 5
>>> x == 5
True
>>> x > 10
False
>>> x < 10
True
Python renvoie la valeur True si la comparaison est vraie et False si elle est fausse. True et False sont des
booléens.
Faites bien attention à ne pas confondre l’opérateur d’affectation = qui donne une valeur à une variable et
l’opérateur de comparaison == qui compare les valeurs de deux variables.
Vous pouvez également effectuer des comparaisons sur des chaînes de caractères.
>>> animal = "tigre"
>>> animal == "tig"
False
>>> animal != "tig"
True
>>> animal == 'tigre’
True
Dans le cas des chaînes de caractères, a priori seuls les tests == et != ont un sens. En fait, on peut aussi
utiliser les opérateurs , <= et >=. Dans ce cas l’ordre alphabétique est pris en compte, par exemple :
>>> "a" < "b"
True
8.Boucles while
Une autre alternative à l’instruction for couramment utilisée en informatique est la boucle while.
Le principe est simple. Une série d’instructions est exécutée tant qu’une condition est vraie. Par
exemple :
>>> i = 1
>>> while i <= 4:
... Print(i)
... i = i + 1
...
1
2
3
4
Remarquez qu’il est encore une fois nécessaire d’indenter le bloc d’instructions.
Une boucle while nécessite trois éléments pour fonctionner correctement :
1. l’initialisation de la variable de test avant la boucle ;
2. le test de la variable associé à l’instruction while ;
3. l’incrémentation de la variable de test dans le corps de la boucle.
Faites bien attention aux tests et à l’incrémentation que vous utilisez car une erreur mène souvent à
des boucles infinies qui ne s’arrètent pas. Vous pouvez néanmoins toujours stopper l’exécution d’un
script Python à l’aide de la combinaison de touches Ctrl-C.