N OTES DE COURS

Initiation à l’algorithmique et à la
programmation en Python

Dr Ing Mahugnon Géraud AZEHOUN PAZOU

Université Nationale des Sciences, Technologies, Ingénierie et Mathématiques

(UNSTIM)

Dernière mise à jour : 10 mars 2025

 Table des matières

1 Introduction générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1 Introduction à l’informatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1.1 Quelques disciplines de l’informatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1.2 L’ordinateur : la machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1.3 Le langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.2 Concepts de base en algorithmique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.2.1 Le programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.2.2 Le problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.2.3 L’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.3 Mise en œuvre et exécution d’un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.3.1 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.3.2 Exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.4 Méthode de résolution d’un problème algorithmique . . . . . . . . . . . . . . . . . . . . . 15

1.4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.4.2 Étapes de résolution d’un problème algorithmique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2 Notion de variable et structure d’un programme . . . . . . . . . . . . . . . . . . . . 17

2.1 Notion de variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.1.2 Règles de déclaration d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.1.3 Exemple de déclaration de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.2 Les instructions élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1 L’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.2.2 L’écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.2.3 La lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.2.4 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.3 Structure générale d’un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.4 Opérateurs sur les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.4.1 Opérateurs arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.4.2 Opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3 Les structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.2 Les structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.2.1 La structure if (Si) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.2.2 La structure if-else (Si-Sinon) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.2.3 La structure if-elif-else (Si-Sinon Si-Sinon) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.3 Les structures itératives ou répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.3.1 La boucle while (Tant Que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.3.2 La boucle for (Pour) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4 Les séquences en Python : chaînes de caractères et listes . . . . . . . . . . . . . . 31

4.1 Introduction aux séquences en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.2 Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.2.1 Création de chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.2.2 Caractères d’échappement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2.3 Chaînes multilignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2.4 Accéder aux caractères d’une chaîne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2.5 Slicing (découpage de chaînes) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.2.6 Concaténation et répétition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.2.7 Méthodes utiles pour les chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.2.8 Les f-strings (chaînes de caractères formatées) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.3 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.3.1 Création de Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
 5

4.3.2 Accéder aux éléments d’une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.3.3 Slicing (découpage de listes) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3.4 Concaténation et répétition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3.5 Modifier une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

4.3.6 Méthodes utiles pour les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

4.3.7 Parcourir une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.3.8 Listes imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3.9 Copie de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5 Fonctions et programmation impérative procédurale . . . . . . . . . . . . . . . . . 39

5.1 Introduction aux fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5.2 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.2.1 Définir une fonction en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

5.2.2 Paramètres et arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

5.2.3 Valeur de retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.2.4 Portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

5.3 Programmation impérative procédurale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

 1. Introduction générale

1.1 Introduction à l’informatique

L’informatique est une science qui permet de traiter l’information de façon automatique.
• Science : donc des théories et des modèles,
• Information : texte, image ou son (et mêmes odeurs, saveurs et toucher), représentés sous
une forme manipulable par la machine en fonction de sa technologie.

1.1.1 Quelques disciplines de l’informatique

Quel sont les différentes branches de l’informatique ?

• Réseaux, logiciels de télécommunications, sécurité des échanges d’information.
• Systèmes embarqués, robotique.
• Images, son, multimédia, interfaces homme/machine, infographie . . .
• Calcul scientifique, optimisation, intelligence artificielle, bio-informatique, traitement des
langues . . .
On distingue quatre (04) concepts importants en informatique à savoir :
• algorithme ;
• machine ;
• langage ;
• information.
Les relations entre ces différents concepts donnent les différents domaines d’application précédem-
ment évoqués et permet de constituer la structure profonde de l’informatique.

1.1.2 L’ordinateur : la machine

L’ordinateur est un appareil très puissant permettant de traiter les informations (données) sous
forme binaire avec une très grande vitesse, une précision élevée et a la faculté de stocker toutes
ces informations. Il est divisé en deux (02) parties : la partie matérielle (hardware) et la partie
logicielle (software).
La partie matérielle de l’ordinateur est composée de circuit électronique (processeur, interface,
 8 Chapitre 1. Introduction générale

support de stockage, périphérique, etc. . .) permettant de stocker des données sous forme binaire ;
c’est-à-diresous forme de bits.
La partie logicielle est celle à laquelle les instructions sont données pour exécuter des actions bien
précises : on parle de programme informatique.
Les programmes interagissent avec l’environnement ou les utilisateurs grâce aux périphériques
d’entrée et de sortie. Leur mise en œuvre est assurée par la partie matérielle au cœur de laquelle se
trouve le processeur.

1.1.2.1 Les types d’ordinateur

Ordinateur de bureau Un ordinateur de bureau est conçu pour être toujours au même endroit,
généralement sur un bureau. Il se compose :

F IGURE 1.1 – Ordinateur de bureau

1. d’une unité centrale : qui contient les principaux composants de l’ordinateur. C’est également
sur celle-ci que vous trouverez le bouton pour allumer l’ordinateur ;

2. d’un écran : qui permet d’afficher le contenu de l’ordinateur ;

3. d’un clavier : qui permet de communiquer avec l’ordinateur en tapant du texte ;

4. d’une souris : qui permet de déplacer le curseur à l’écran.

D’autres éléments peuvent être ajoutés, on les appelle des périphériques.

Ordinateurs all in one Il existe également des ordinateurs sur lesquels tous les composants sont
regroupés derrière l’écran, on les appelle ordinateurs all in one ou tout-en-un en français.
1.1 Introduction à l’informatique 9

F IGURE 1.2 – Ordinateurs all in one

À ces ordinateurs, il faut ajouter un clavier et une souris pour pouvoir les utiliser.
Ordinateurs portables Les ordinateurs portables sont conçus pour être compacts et mobiles.
Ainsi, ils ne disposent pas d’une unité centrale, tous les composants se situent sous le clavier.

F IGURE 1.3 – Ordinateurs portables

Sur ce type d’ordinateur, brancher une souris n’est pas obligatoire, car il y a un touchpad : une
surface sensible au toucher qui permet de déplacer le pointeur à l’écran.
Comme pour les ordinateurs de bureau, d’autres périphériques peuvent être ajoutés.
Tablettes Il existe aussi des tablettes, ce sont des ordinateurs mobiles à la taille réduite. Les écrans
sont tactiles et affichent un clavier virtuel. Tous les composants sont situés derrière l’écran. Ainsi,
les tablettes n’ont pas besoin d’unité centrale, ni de clavier ou de souris. Sur certains modèles, il est
toutefois possible d’y connecter un clavier et/ou une souris.
 10 Chapitre 1. Introduction générale

F IGURE 1.4 – Tablette

1.1.2.2 Les composants d’un ordinateur

Découvrons à présent les principaux composants d’un ordinateur :

Le processeur C’est le cerveau de l’ordinateur. Il réalise tous les calculs nécessaires au fonc-
tionnement de l’ordinateur. C’est notamment la fréquence du processeur, c’est-à-dire la vitesse à
laquelle il travaille, qui détermine la rapidité de l’ordinateur. Cette fréquence s’exprime en Giga
Hertz (GHz). Les ordinateurs sont devenus multicoeurs c’est-à-dire qu’ils possèdent plusieurs
processeurs pour effectuer plus rapidement les tâches demandées. Ainsi :

• Dual Core = 2 cœurs

• Quad Core = 4 cœurs
• Hexa Core = 6 cœurs
• Octa Core = 8 cœurs

Il existe différents modèles de processeurs et cette technologie évolue rapidement. Les processeurs
des marques AMD et Intel sont les plus fréquemment rencontrés.

La marque Intel propose par exemple les modèles :

• Intel Core i3 qui correspond à l’entrée de gamme des processeurs Intel Core,
• Intel Core i5 qui constitue le milieu de gamme,
• Intel Core i7 et Intel Core i9 qui sont de la gamme supérieure.
La mémoire vive ou RAM (Random Access Memory) C’est la mémoire temporaire de l’ordina-
teur, c’est là où sont stockés tous les fichiers sur lesquels l’utilisateur est en train de travailler. Cette
mémoire est temporaire, car les informations sont supprimées lors de l’arrêt de l’ordinateur.
1.1 Introduction à l’informatique 11

Plus cette mémoire est importante, plus l’ordinateur travaille facilement et rapidement et plus il
peut gérer des tâches différentes.
La capacité de cette mémoire s’exprime en Gigaoctets (Go). La mémoire vive se présente sous
forme de petites barrettes que l’on insère dans la carte mère. Un ordinateur peut ainsi comporter
plusieurs barrettes pour avoir au total (cela dépend des ordinateurs) 4 - 8 - 16 ou 32 Go de RAM.
Le disque dur (mémoire morte) C’est le support sur lequel on peut stocker des informations. Les
capacités de stockage ne cessent d’augmenter et permettent donc d’enregistrer un grand nombre de
données : documents, photos, films...

Il y a actuellement deux types de disques durs : SSD et HDD. Les SSD ont l’avantage d’être
extrêmement rapides, mais ils sont plus chers et de capacité limitée.
La carte graphique ou vidéo Elle permet de produire une image affichable sur un écran d’or-
dinateur. La carte graphique peut être intégrée à la carte mère ou dédiée, c’est-à-dire qu’elle est
séparée et qu’elle dispose de sa propre mémoire vive. Une carte graphique dédiée est plus puissante,
mais coûte plus cher. Elle permet de faire fonctionner correctement des jeux en 3D, des logiciels de
retouche vidéo/photo par exemple.
12 Chapitre 1. Introduction générale

F IGURE 1.5 – Carte graphique ou vidéo

AMD et NVIDIA sont les marques de cartes graphiques les plus courantes
Le ventilateur Le ventilateur est utilisé pour réduire la température souvent élevée du processeur
et réduire les risques de surchauffe.

F IGURE 1.6 – Ventilateur

La carte mère (motherboard) Elle se trouve au centre de l’ordinateur et connecte tous les
composants de l’ordinateur. La carte mère contient les connexions pour le processeur, la mémoire,
les unités de stockage. . .Elle intègre une carte son et une carte graphique.
1.1 Introduction à l’informatique 13

F IGURE 1.7 – Carte mère

Voici un exemple de carte mère et ses principaux composants :

F IGURE 1.8 – Carte mère avec ses composants

R Pour un ordinateur de bureau, ces différents composants se retrouvent dans l’unité centrale.
Pour les ordinateurs all in one, ils se retrouvent derrière l’écran et pour les ordinateurs
 14 Chapitre 1. Introduction générale

portables, ils se retrouvent sous le clavier.

1.1.3 Le langage

Le langage informatique est un langage dans lequel il est aisé de communiquer avec l’ordinateur.
Il est composé de mots clés, de fonctions prédéfinies qui sont utilisées dans le but de donner des
instructions à une machine. On distingue deux (02) types de langages en informatique : le langage
machine et le langage évolué.
Le langage machine est un langage plus proche de celui de la machine.
■ Exemple 1.1 Langage assembleur. ■

Le langage évolué ou langage haut niveau est un langage qui utilise les mots-clés du langage
naturel. Leur utilisation est plus facile pour les programmeurs. Parmi ces langages, on distingue les
langages compilés et les langages interprétés.

1.2 Concepts de base en algorithmique

Si l’on tient compte des multiples applications qui nécessitent l’utilisation des ordinateurs, on
s’aperçoit qu’il peut traiter autant de problèmes différents grâce à des actions de base qu’il sait
réaliser. Pour ce faire, il suffit de lui indiquer l’ordre dans lequel il faut qu’il effectue ces actions et
les données à utiliser. Ces ordres élémentaires sont appelés instructions et sont rassemblés au sein
d’un ensemble appelé programme.

1.2.1 Le programme

Un programme représente un assemblage et un enchaînement d’instructions élémentaires écrites

dans un langage de programmation et exécutées par un ordinateur afin de traiter les données
d’un problème et retourner les résultats. Le langage de programmation est donc un langage de
communication par le biais duquel on est en mesure de communiquer avec l’ordinateur.

1.2.2 Le problème

Un problème est un ensemble de données et de traitements décrivant une situation que l’on cherche
à résoudre. Le but visé à travers la résolution du problème peut être :

• automatiser une tâche ;

• satisfaire un besoin ;
• informatiser un système.
■ Exemple 1.2 Supposons qu’un enseignant dispose d’un ordinateur et veut un programme de calcul
des moyennes. Le problème ici est : Mettre en place des moyens et des procédures afin que si l’on
fournit des notes, on obtienne en retour les moyennes.
Dans ce problème, les données sont les différentes notes. Les traitements consisteront à faire la
somme de toutes les notes que l’on divise par la somme des coefficients. Le résultat à la fin de ce
problème est la moyenne.
Si dans le programme, il est prévu de fournir d’autres résultats, ils pourront être fournis.
Un moyen de décrire la procédure de résolution d’un problème est d’écrire un algorithme. ■
 1.3 Mise en œuvre et exécution d’un programme 15

1.2.3 L’algorithme

Un algorithme est l’enchaînement des actions ou instructions élémentaires nécessaires pour faire
exécuter une tâche à un ordinateur ; c’est-à-dire pour résoudre un problème.
L’algorithme est écrit dans un pseudo-langage de programmation appelé langage algorithmique.
Il a l’avantage d’être facilement traductible dans tous les langages de programmation.
L’algorithmique est donc l’art d’écrire des algorithmes. Il permet de se focaliser sur la procédure
de résolution du problème sans avoir à se soucier des spécificités d’un langage particulier.

1.3 Mise en œuvre et exécution d’un programme

1.3.1 Mise en œuvre

Réflexion Codes
P ROBLÈME A LGORITHME P ROGRAMME
Lang. de Prog.

F IGURE 1.9 – Schéma de mise en œuvre d’un algorithme

La mise en œuvre d’un programme commence par la réflexion sur le problème posé. Ensuite, la
procédure identifiée pour la résolution est décrite dans un algorithme. Ce dernier peut alors être
traduit en programme dans un langage de programmation.

1.3.2 Exécution

Après que le programme est édité, il est enregistré sous la bonne extension dans un emplacement
précis sur l’ordinateur. Ensuite, il est traduit en code binaire (0 et 1) grâce à un compilateur. La
compilation produit donc un exécutable (.exe) que le processeur exécute en respectant l’ordre des
instructions.

1.4 Méthode de résolution d’un problème algorithmique

1.4.1 Introduction

Compte tenu de la multiplicité des applications et des situations qui incluent l’utilisation d’un
ordinateur ou d’un automate, on est en droit de se poser la question sur la meilleure manière
d’aborder leur résolution. À ce propos, une démarche générale de résolution des problèmes algorith-
miques peut être suivie. Elle inclut un certain nombre d’étapes qui, si elles sont suivies, aboutissent
irrémédiablement à un résultat, fût-il différent de la solution voulue.

1.4.2 Étapes de résolution d’un problème algorithmique

1.4.2.1 Redéfinition du problème

A cette étape, on pense à reformuler le problème en utilisant des termes et des concepts complète-
ment différents de ceux utilisés dans le domaine d’application. Il s’agit ici de penser aux données
du problème qui peuvent être utilisées par l’ordinateur ou l’automate pour résoudre ledit problème.
 16 Chapitre 1. Introduction générale

1.4.2.2 Analyse du problème

Cette étape fait suite à l’étape précédente. Ainsi, après avoir essayé de se focaliser sur les données
probables du problème, on cherche à identifier les variables d’entrée, les variables intermédiaires
et les variables de sortie.
Le second volet de cette étape inclut les différentes opérations ou les différents traitements que l’on
doit opérer sur ou avec les variables.

1.4.2.3 Conception de la solution

A cette étape, il est question de concevoir un enchaînement séquentiel censé aboutir au résultat
souhaité. Cette étape n’inclut pas encore l’écriture de l’algorithme lui-même. On pourra toutefois
écrire au brouillon, les étapes suivant lesquelles le programme pourra se dérouler.

1.4.2.4 Écriture de l’algorithme

Il s’agit ici d’écrire la solution en respectant la syntaxe et en faisant usage des structures et outils
prévus par la science algorithmique.

1.4.2.5 Tests de vérification

On simule le déroulement du programme en choisissant des cas pratiques ou des exemples avec des
données réelles. Ce faisant, on vérifie l’exactitude de la solution proposée.

R La dernière étape peut amener à se rendre compte que l’on a mal traité le problème ou que
l’on n’a pas tenu compte de tous les cas de figure possibles. Cela peut donc amener à redéfinir
le problème.

R L’étape écriture de l’algorithme peut être remplacée selon le cas par dessin d’un algori-
gramme ou ordinogramme ou diagramme algorithmique.
 2. Notion de variable et structure d’un
programme

2.1 Notion de variable

2.1.1 Définition

Une variable est un symbole qui associe un nom (l’identificateur) à une valeur. Elle est représentée
par (ou correspond à) une case-mémoire qui contient la valeur de la variable et à laquelle on fait
appel lorsqu’on veut manipuler la valeur.
On attribue un nom unique appelé identificateur à la variable. C’est à travers cet identificateur
qu’on peut recueillir ou modifier la valeur de la variable. Les valeurs que peut prendre une variable
sont également précisées à travers les types.
Pour qu’un programme puisse utiliser une variable, il faut au préalable réserver la case-mémoire à
laquelle elle doit correspondre. Pour ce faire, il faut procéder à la déclaration des variables qui est
une instruction spécifique.

2.1.2 Règles de déclaration d’une variable

La déclaration d’une variable consiste à indiquer deux choses : son identificateur et son type.

2.1.2.1 Identificateur

L’identificateur peut être composé de lettres et de chiffres. Il ne peut pas commencer par un chiffre
et ne peut comporter d’espace. Il doit être suffisamment significatif pour qu’on y reconnaisse la
chose représentée.

2.1.2.2 Type

En algorithmique, on distingue cinq (05) types principaux :

• Les entiers (int) : Ce sont les nombres sans virgule signés ou non (tout nombre appartenant
à Z).
• Les réels (float) : Les nombres à virgule.
 18 Chapitre 2. Notion de variable et structure d’un programme

• Les caractères (str) : Lettres, chiffres, ponctuations, code des opérateurs, espace ; plus
généralement toutes les touches du clavier.
• Les chaînes de caractères (str) : C’est une suite de caractères.
• Les booléens (bool) : Type logique avec deux (02) valeurs possibles : Vrai ou Faux. En
Python, ces types de variables sont représentés par True ou False, ou encore 1 (True)
ou 0 (False).

2.1.2.3 Noms de variables

Le nom des variables en 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 _ (sauf cas très particuliers). Il est conseillé de
mettre des noms de variables explicites, de manière à exprimer clairement ce que la variable est
censée contenir.
En Python, la casse est significative, c’est-à-dire que les caractères majuscules et minuscules sont
distingués. Cela signifie que les variables TesT, test et TEST sont différentes.

2.1.3 Exemple de déclaration de variables

■ Syntaxe 2.1 — Déclaration de variables.

1 VARIABLE : <identificateur> : <type>

OU
1 VARIABLE : <identificateur1>, ... , <identificateurm> : <type1>
2 <identificateur1>, ... , <identificateurn> : <type2>
3 ...
4 <identificateur1>, ... , <identificateurp> : <typeN>

■ Exemple 2.1 — Déclaration de variables.

1 VARIABLE : a, b : REEL
2 Ent1, Ent2, Ent3 : ENTIER
3 lettre : CHAR // ou lettre : CARACTERE
4 prenom : CHAINE // ou prenom : VARCHAR
■

R En algorithmique, les mots clés s’écrivent toujours en majuscule.

R En Python, les variables ne sont pas explicitement déclarées. Et le type d’une variable est
automatiquement détecté par Python lors de l’affectation (voir section 2.2.1). On dit que
Python est typé dynamiquement ou est un langage au typage dynamique.

2.2 Les instructions élémentaires

2.2.1 L’affectation

L’affectation consiste à donner à une variable déclarée une valeur appartenant à son type. Elle
permet de donner une première valeur à la variable ou de changer sa valeur courante.
 2.2 Les instructions élémentaires 19

■ Syntaxe 2.2

1 <identificateur> ←− <expression> ;

■ Exemple 2.2 — Affectation.

1 a ←− 12 ;
2 a ←− 4 * 2.5 ;
3 a ←− 0.0 ;
4 b ←− 5 * a + 2.5 ;
5 a ←− b ;
■

La syntaxe Python d’une affectation est la suivante :

1 a = 12
2 a = 4 * 2.5
3 a = 0.0
4 b = 5 * a + 2.5
5 a = b

R On remarque que les instructions en Python ne se terminent pas par un point-virgule, ce qui
n’est pas le cas en algorithmique.

R L’opérateur d’affectation écrase systématiquement la valeur de la variable située à sa gauche

si celle-ci existe déjà, en la remplaçant par la nouvelle valeur affectée. Ainsi, à la fin de la
suite d’instructions précédente, la dernière valeur de la variable a sera 2.5.

2.2.2 L’écriture

C’est une instruction qui permet au programme de fournir des informations ou de retourner
des résultats sous forme compréhensible pour l’utilisateur à travers l’écran. Plus simplement,
l’instruction d’écriture permet d’afficher du contenu à l’écran.
■ Syntaxe 2.3

1 ECRIRE(<expression1>, <expression2>, ...) ;

OU

1 AFFICHER(<expression1>, <expression2>, ...) ;

■ Exemple 2.3 — Écriture.

1 ECRIRE("Bonjour M. Justin.") ;
2 age ←− 18 ;
3 ECRIRE("M. Justin, vous avez : ", age, "ans.") ;
■

En Python, on utilise le mot-clé print pour afficher une information à l’écran :

1 print("Bonjour M. Justin")
2 age = 18
3 print("M. Justin, vous avez : ", age, "ans.")
 20 Chapitre 2. Notion de variable et structure d’un programme

2.2.3 La lecture

C’est une instruction qui permet de récupérer des données à partir du périphérique d’entrée
(généralement le clavier). La valeur récupérée est rangée dans une variable.
■ Syntaxe 2.4
1 LIRE(<variable1>, <variable2>, ...) ;

OU
1 SAISIR(<variable1>, <variable2>, ...) ;

■ Exemple 2.4 — Lecture.

1 ECRIRE("Bonjour Mr Justin. Quel est votre âge ?") ;
2 LIRE(Justin) ; // Lire l'âge à l'écran
3 ECRIRE("Mr Justin, vous avez ", Justin, " ans.") ;
■

En Python, on utilise le mot-clé input pour récupérer des données entrées par l’utilisateur :
1 print("Bonjour M. Justin. Quel est votre âge ?")
2 age = input() # Lire l'âge à l'écran
3 print("Mr Justin, vous avez", Justin, "ans.")

R En Python, le contenu récupéré avec la fonction input() est une chaîne de caractères. Ainsi,
l’âge qui est lu à l’écran est de type str et non un nombre entier (int). Pour obtenir la
variable sous forme d’entier, il faut la convertir. Cette opération de conversion est appelée
casting.
On souhaite, par exemple, récupérer un nombre, lui ajouter 1 puis afficher le résultat.

1 nombre = input("Entrez un nombre : ")

2 nombre = int(nombre) # float(nombre) pour obtenir un nombre réel.
3 resultat = nombre + 1
4 print("Le résultat est", resultat)

2.2.4 Commentaires

Les commentaires permettent d’expliquer le code dans un langage humain. Ils fournissent des
explications sur l’utilité du code et permettent de comprendre son fonctionnement. En Python,
les commentaires débutent toujours par le symbole #. Tout ce qui suit ce caractère est ignoré par
Python jusqu’à la fin de la ligne. Voici un exemple :
1 # Ceci est un commentaire.
2 print("Bonjour !") # Je salue l'utilisateur.
3 # Un autre commentaire.

R Seul Bonjour ! sera affiché à l’écran lors de l’exécution de ce programme.

2.3 Structure générale d’un programme

De façon générale, la structure d’un programme algorithmique est la suivante. Toutes les instructions
sont écrites entre les mots-clés DEBUT et FIN.
 2.4 Opérateurs sur les variables 21

1 PROGRAMME <NomProgramme>
2 VARIABLE : <var11>, <var12>, \dots\ , <var1n> : <type1>
3 <var21>, <var22>, \dots\ , <var2m> : <type2>
4 ...
5 <varN1>, <varN2>, \dots\ , <varNp> : <typeN>
6 DEBUT
7 <instruction1> ;
8 <instruction2> ;
9 ...
10 <instructionn> ;
11 FIN

2.4 Opérateurs sur les variables

Les opérateurs permettent de faire un certain nombre de manipulations sur les variables.

2.4.1 Opérateurs arithmétiques

Addition Elle permet d’additionner deux variables de type entier ou réel. Son symbole est (+).
Soustraction Elle permet de calculer la différence entre deux variables de type entier ou réel. Son
symbole est (-).
Multiplication Elle permet de faire le produit de deux variables de type entier ou réel. Son symbole
est (*).
Division Elle permet de faire le quotient de deux variables de type entier ou réel. Son symbole est
(/).
Division entière Cet opérateur permet d’obtenir la partie entière du quotient de deux variables de
type entier ou réel. Son symbole est DIV.
Partie entière Cet opérateur retourne la partie entière d’une variable réelle. Son symbole est ENT.
Exposant Cet opérateur permet d’élever un nombre à une puissance donnée. Son symbole est (ˆ).
Reste de la division entière Il retourne le reste de la division de deux variables de type entier. Son
symbole est MOD. Il ne s’applique pas aux nombres réels.

R Les opérateurs arithmétiques en Python sont les suivants :

• + : Addition
• - : Soustraction
• * : Multiplication
• / : Division
• // : Division entière
• ** : Exposant
• % : Reste de la division entière

1 a = 7
2 b = 3
3 somme = a + b # 10
4 difference = a - b # 4
5 produit = a * b # 21
6 divsion = a / b # 2.3333333333333335
7 puissance = a ** b # 343
8 div_entiere = a // b # 2
9 modulo = a % b # 1
 22 Chapitre 2. Notion de variable et structure d’un programme

2.4.2 Opérateurs logiques

Comparaison Les opérateurs de cette catégorie permettent de comparer les contenus de deux
variables ou de deux expressions. Les symboles ci-après sont utilisés :
1. < : infériorité ;
2. > : supériorité ;
3. ≤ : infériorité ou égalité ;
4. ≥ : supériorité ou égalité ;
5. = : égalité ;
6. ̸= : différence ;
La négation Elle permet de faire un NON logique sur une expression. Son symbole est NON.
La conjonction Elle permet de faire un ET logique sur deux expressions. Son symbole est ET.
La disjonction Elle permet de faire un OU logique sur deux expressions. Son symbole est OU.

Tous ces opérateurs retournent des résultats de type booléen.

R Les opérateurs logiques en Python sont les suivants :

• < : inférieur à
• > : supérieur à
• <= : inférieur ou égal à
• >= : supérieur ou égal à
• == : égal à
• != : différent de
• and : ET logique
• or : OU logique
• not : NON logique
 3. Les structures de contrôle

3.1 Introduction
La résolution d’un problème par un algorithme peut faire ressortir un certain nombre de cas ou
de situations qui nécessitent que l’on dise à l’ordinateur comment réagir. Il peut s’agir de choix
à opérer ou de comportement récurrent à gérer. En algorithmique, les structures de contrôle sont
prévues pour faire face à ce genre de situation.
On distingue deux grandes familles de structures de contrôle :
— Les structures conditionnelles.
— Les structures répétitives ou itératives.

3.2 Les structures conditionnelles

Les structures conditionnelles sont des éléments fondamentaux en programmation. Elles permettent
à un programme de prendre des décisions en fonction de certaines conditions. En d’autres termes,
elles permettent d’exécuter un bloc de code uniquement si une condition spécifique est remplie.
Sans ces structures, un programme exécuterait toutes les instructions de manière linéaire, sans
aucune forme de logique ou d’adaptation aux situations.
En Python, comme dans la plupart des langages de programmation, les structures conditionnelles
reposent sur des expressions booléennes, c’est-à-dire des expressions qui peuvent être évaluées à
True (vrai) ou False (faux). Les structures conditionnelles les plus courantes sont :

1. La structure if (si)
2. La structure if-else (si-sinon)
3. La structure if-elif-else (si-sinon si-sinon)

3.2.1 La structure if (Si)

La structure if est la plus simple des structures conditionnelles. Elle permet d’exécuter un bloc de
code uniquement si une condition est vraie. Si la condition est fausse, le bloc de code est ignoré.
 24 Chapitre 3. Les structures de contrôle

Syntaxe en algorithmique

1 SI (<condition>) ALORS
2 {
3 <instruction1> ;
4 <instruction2> ;
5 ...
6 <instructionn> ;
7 }
8 FINSI

Syntaxe en Python

1 if condition:
2 # Bloc de code à exécuter si la condition est vraie.
3 <instruction1>
4 <instruction2>
5 ...
6 <instructionn>

■ Exemple 3.1

1 age = 18
2 if age >= 18:
3 print("Vous êtes majeur.")

Dans cet exemple, la condition age >= 18 est évaluée. Si elle est vraie (c’est-à-dire si age est
supérieur ou égal à 18), le message "Vous êtes majeur." est affiché. Sinon, rien ne se passe.
■

3.2.2 La structure if-else (Si-Sinon)

La structure if-else permet d’exécuter un bloc de code si une condition est vraie et un autre
bloc de code si la condition est fausse. C’est utile lorsqu’on veut gérer deux scénarios possibles.

Syntaxe en algorithmique

1 SI (<condition>) ALORS
2 {
3 <instruction1> ;
4 <instruction2> ;
5 ...
6 <instructionn> ;
7 }
8 SINON
9 {
10 <instruction1> ;
11 <instruction2> ;
12 ...
13 <instructionn> ;
14 }
15 FINSI
 3.2 Les structures conditionnelles 25

Syntaxe en Python

1 if condition:
2 # Bloc de code à exécuter si la condition est vraie.
3 <instruction1>
4 <instruction2>
5 ...
6 <instructionn>
7 else:
8 # Bloc de code à exécuter si la condition est fausse.
9 <instruction1>
10 <instruction2>
11 ...
12 <instructionn>

■ Exemple 3.2

1 age = 16
2 if age >= 18:
3 print("Vous êtes majeur.")
4 else:
5 print("Vous êtes mineur.")

Ici, si age est supérieur ou égal à 18, le programme affiche "Vous êtes majeur.". Sinon, il
affiche "Vous êtes mineur.".
■

3.2.3 La structure if-elif-else (Si-Sinon Si-Sinon)

La structure if-elif-else est utilisée lorsqu’il y a plusieurs conditions à vérifier. Elle permet
de tester plusieurs cas et d’exécuter le bloc de code correspondant à la première condition vraie. Si
aucune condition n’est vraie, le bloc else est exécuté (s’il est présent).

Syntaxe en Python

1 if condition1:
2 # Bloc de code à exécuter si condition1 est vraie.
3 <instruction1>
4 <instruction2>
5 ...
6 <instructionn>
7 elif condition2:
8 # Bloc de code à exécuter si condition2 est vraie.
9 <instruction1>
10 <instruction2>
11 ...
12 <instructionn>
13 elif condition3:
14 # Bloc de code à exécuter si condition3 est vraie.
15 <instruction1>
16 <instruction2>
17 ...
18 <instructionn>
19 else:
 26 Chapitre 3. Les structures de contrôle

20 # Bloc de code à exécuter si aucune des conditions n'est vraie.

21 <instruction1>
22 <instruction2>
23 ...
24 <instructionn>

■ Exemple 3.3 On suppose qu’on veut créer un programme qui détermine le jour de la semaine en
fonction d’un nombre entier (1 pour lundi, 2 pour mardi, etc.). Avec la structure if-elif-else,
on peut procéder comme suit :

1 jour = int(input("Entrez un nombre (1-7) : ")) # Convertir l'entrée en un

entier.
2
3 if jour == 1:
4 print("Lundi")
5 elif jour == 2:
6 print("Mardi")
7 elif jour == 3:
8 print("Mercredi")
9 elif jour == 4:
10 print("Jeudi")
11 elif jour == 5:
12 print("Vendredi")
13 elif jour == 6:
14 print("Samedi")
15 elif jour == 7:
16 print("Dimanche")
17 else:
18 print("Numéro de jour invalide")

R On peut mettre autant de elif que l’on veut après une condition en if. Tout comme le
else, ce bloc d’instructions est facultatif. Par ailleurs, le bloc else, lorsqu’il est présent,
ne peut figurer qu’une seule fois après le dernier elif, clôturant le bloc de la condition.

3.3 Les structures itératives ou répétitives

Les structures répétitives, également appelées boucles, sont essentielles en programmation pour
automatiser des tâches répétitives. Elles permettent d’exécuter un bloc de code plusieurs fois, tant
qu’une condition est vraie ou jusqu’à ce qu’une condition devienne vraie.
Les structures répétitives, également appelées boucles, sont essentielles en programmation pour
automatiser des tâches répétitives ou traiter des ensembles de données en exécutant un bloc de code
plusieurs fois. En algorithmique et en programmation Python, il existe plusieurs types de boucles,
chacune adaptée à des situations spécifiques.

3.3.1 La boucle while (Tant Que)

La boucle while est utilisée lorsqu’on ne connaît pas à l’avance le nombre d’itérations, mais
qu’on souhaite répéter un bloc de code tant qu’une condition est vraie. La boucle s’arrête dès que
la condition devient fausse.
 3.3 Les structures itératives ou répétitives 27

Syntaxe en algorithmique

1 TANTQUE (<condition>) FAIRE

2 {
3 <instruction1> ;
4 <instruction2> ;
5 ...
6 <instructionn> ;
7 }
8 FINTANTQUE

Syntaxe en Python

1 while condition:
2 # Bloc de code à répéter.
3 <instruction1>
4 <instruction2>
5 ...
6 <instructionn>

■ Exemple 3.4

1 # Afficher les nombres de 1 à 5.

2 i = 1
3 while i <= 5:
4 print(i)
5 i = i + 1 # On incrémente i.

La variable i est initialisée à 1. La boucle while continue tant que i est inférieur ou égal à 5. À
chaque itération, la valeur de i est affichée et incrémentée de 1.
Incrémenter i signifie ajouter 1 à la valeur de i, on parle d’incrémentation. L’opération inverse est
la décrémentation, enlever 1 de la valeur de i (i = i - 1). ■

Boucle infinie

Une boucle infinie est une boucle qui ne se termine jamais, car sa condition de sortie n’est jamais
remplie, ce qui entraîne l’exécution répétée du bloc de code de la boucle sans fin. Cela peut entraîner
le blocage du programme ou l’utilisation excessive de ressources.
Dans l’exemple précédent, si l’on oublie par exemple d’incrémenter la variable i, on obtiendra une
boucle infinie.
■ Exemple 3.5

1 # Afficher les nombres de 1 à 5.

2 i = 1
3 while i <= 5:
4 print(i)
5 # On oublie d'incrémenter i.

La condition i <= 5 sera toujours vraie (car i est toujours égal à 1) et la boucle ne s’arrête jamais.
■
 28 Chapitre 3. Les structures de contrôle

R Pour éviter les boucles infinies, il faut s’assurer que la condition de sortie deviendra fausse
à un moment donné. Il faut donc vérifier que les variables utilisées dans la condition sont
modifiées correctement à l’intérieur de la boucle.

3.3.2 La boucle for (Pour)

Il est fréquent que l’on connaisse à l’avance le nombre de fois qu’on veut répéter un bloc d’instruc-
tions. Dans ce cas, il apparaît plus simple d’utiliser une structure itérative qui permet de répéter
exactement le nombre de fois que l’on désire. Cette structure est la boucle for. Cette boucle
permet de parcourir un intervalle en répétant un bloc d’instructions pour chacune des valeurs de cet
intervalle en respectant un pas donné. En Python, la boucle for est souvent utilisée avec la fonction
range() qui génère une séquence de nombres.

Syntaxe en algorithmique

Syntaxe en algorithmique

1 POUR <variable> ALLANT DE <début> A <fin> PAS DE <incrément>

2 {
3 <instruction1> ;
4 <instruction2> ;
5 ...
6 <instructionn> ;
7 }
8 FINPOUR

Syntaxe en Python

1 for variable in range(début, fin, pas):

2 # Bloc de code à répéter.
3 <instruction1>
4 <instruction2>
5 ...
6 <instructionn>

■ Exemple 3.6

1 # Afficher les nombres de 1 à 5.

2 for i in range(1, 6, 1):
3 print(i)

La fonction range(1, 6) génère une séquence de nombres entiers, en commençant par 1 et en

s’arrêtant avant 6. Ainsi, elle génère les nombres 1, 2, 3, 4 et 5. ■

Points importants

— On peut utiliser range() sans spécifier le pas. Dans ce cas, le pas par défaut est 1.
— range(début, fin) génère une séquence de nombres allant de début (inclus) à fin
(exclu). Ainsi, range(0, 5) génère 0, 1, 2, 3, 4.
— range(1, 10, 2) génère 1, 3, 5, 7, 9, puisqu’on a précisé que le pas est égal à 2.
— début, fin et pas sont des entiers ou des variables de type entier.
3.3 Les structures itératives ou répétitives 29

Exercices d’application

1. Écrivez un programme qui demande deux nombres et un opérateur (+, -, *, /) et affiche le

résultat de l’opération.
2. Écrivez un programme qui demande à l’utilisateur un nombre. Si le nombre est pair, affichez
"Pair", sinon affichez "Impair".
(Un nombre pair est un nombre dont le reste de sa division par 2 est nul).
3. Écrivez un programme qui affiche les nombres pairs de 0 à 20 en utilisant une boucle for.
(La fonction range peut être utile).
4. Écrivez un programme qui affiche les nombres de 1 à 10 en utilisant une boucle while.
 4. Les séquences en Python : chaînes de caractères
et listes

4.1 Introduction aux séquences en Python

En Python, les séquences sont des collections ordonnées d’éléments. Cela signifie que chaque
élément a une position spécifique dans la séquence, appelée indice. Les chaînes de caractères et les
listes sont deux types de séquences fondamentaux en Python.

• Chaînes de caractères (strings) : Ce sont des séquences de caractères (lettres, chiffres,

symboles) utilisées pour représenter du texte.
• Listes : Ce sont des séquences d’éléments de n’importe quel type (nombres, chaînes de
caractères, autres listes, etc.).

Il existe d’autres types de séquences comme les tuples et les ranges (qu’on a déjà vues précédem-
ment).
Les séquences partagent des opérations communes.

• Indexation : Chaque élément d’une séquence a un indice (position) qui commence à 0.

• Slicing (découpage) : On peut extraire une sous-séquence (slice) en spécifiant un intervalle
d’indices.
• Parcours : On peut parcourir une séquence élément par élément à l’aide d’une boucle for.

Cependant, ces deux types de séquences diffèrent également par leur mutabilité : les chaînes de
caractères sont immuables (on ne peut pas les modifier après leur création), tandis que les listes
sont mutables (on peut les modifier).

4.2 Les chaînes de caractères

4.2.1 Création de chaînes de caractères

Les chaînes de caractères sont créées en entourant du texte de guillemets simples (' ') ou doubles
(" "). Les deux formes sont équivalentes.
1 chaine1 = 'Bonjour le monde !'
 32 Chapitre 4. Les séquences en Python : chaînes de caractères et listes

2 chaine2 = "Python est génial."

3 chaine3 = "J'aime Python."
4 chaine4 = 'Il a dit : "Bonjour !"'

4.2.2 Caractères d’échappement

Pour inclure des caractères spéciaux dans une chaîne (comme un guillemet ou une nouvelle ligne),
on utilise des caractères d’échappement qui commencent par un antislash (\).
Les caractères d’échappement courants sont :
— \' : Guillemet simple
— \" : Guillemet double
— \\ : Antislash
— \n : Nouvelle ligne
— \t : Tabulation
1 chaine = "Il a dit : \"Bonjour !\""
2 print(chaine) # Affiche : Il a dit : "Bonjour !"
3
4 chaine = "Ligne 1\nLigne 2"
5 print(chaine)
6 # Affiche :
7 # Ligne 1
8 # Ligne 2

4.2.3 Chaînes multilignes

Pour créer des chaînes qui s’étendent sur plusieurs lignes, on utilise des triples guillemets (''' '''
ou """ """).
1 chaine = """Ceci est une chaîne
2 qui s'étend sur
3 plusieurs lignes."""
4 print(chaine)

4.2.4 Accéder aux caractères d’une chaîne

Les chaînes de caractères sont des séquences, ce qui signifie que vous pouvez accéder à chaque
caractère individuellement en utilisant son indice. Les indices commencent à 0 pour le premier
caractère.
1 chaine = "Python"
2 print(chaine[0]) # Affiche : P
3 print(chaine[3]) # Affiche : h

On peut également utiliser des indices négatifs pour accéder aux caractères en partant de la fin de la
chaîne :
1 print(chaine[-1]) # Affiche : n
2 print(chaine[-2]) # Affiche : o
 4.2 Les chaînes de caractères 33

4.2.5 Slicing (découpage de chaînes)

Le slicing permet d’extraire une sous-chaîne à partir d’une chaîne, c’est-à-dire une partie d’une
chaîne de caractères. Pour le faire, on a les différentes syntaxes suivantes :
• chaine[début:fin] : Extrait les caractères de l’indice début (inclus) à l’indice fin
(exclu).
• chaine[:fin] : Extrait les caractères du début jusqu’à l’indice fin (exclu).
• chaine[début:] : Extrait les caractères de l’indice début (inclus) jusqu’à la fin.
• chaine[début:fin:pas] : Extrait les caractères de l’indice début à l’indice fin avec
un pas spécifié.
1 chaine = "Programmation"
2 print(chaine[0:7]) # Affiche : Program
3 print(chaine[7:]) # Affiche : mation
4 print(chaine[:7]) # Affiche : Program
5 print(chaine[::2]) # Affiche : Pormain
6 print(chaine[::-1]) # Affiche : noitammargorP # Ici, la chaîne est inversée.

4.2.6 Concaténation et répétition

— Concaténation : Combiner des chaînes avec l’opérateur +.

— Répétition : Répéter une chaîne avec l’opérateur *.

1 chaine1 = "Bonjour"
2 chaine2 = "à tous"
3 print(chaine1 + " " + chaine2) # Affiche : Bonjour à tous
4
5 chaine = "Python"
6 print(chaine * 3) # Affiche : PythonPythonPython

4.2.7 Méthodes utiles pour les chaînes

Python propose de nombreuses méthodes pour manipuler les chaînes de caractères. Voici quelques-
unes des plus courantes :

• len() : Longueur d’une chaîne.

• upper() et lower() : Conversion en majuscules/minuscules.
• strip() : Supprimer les espaces en début et fin de chaîne.
• replace(ancienne_sous_chaine, nouvelle_sous_chaine) : Remplacer une
sous-chaîne.
• split(séparateur) : Diviser une chaîne en une liste de sous-chaînes.
• join(liste) : Combiner des chaînes à partir d’une liste.

1 chaine1 = "Programmation"
2 chaine2 = " Python "
3 chaine3 = "Je suis John"
4 chaine4 = "Je-suis-en-retard"
5 print(len(chaine1)) # Affiche : 13
6 print(chaine1.lower()) # Affiche : programmation
7 print(chaine1.upper()) # Affiche : PROGRAMMATION
 34 Chapitre 4. Les séquences en Python : chaînes de caractères et listes

8 print(chaine2.strip()) # Affiche : Python

9 print(chaine3.replace("John", "Toto")) # Affiche : Je suis Toto
10 print(chaine4.split("-")) # Affiche : ['Je', 'suis', 'en', 'retard']
11 print("-".join(["18", "11", "1985"])) # Affiche : 18-11-1985

4.2.8 Les f-strings (chaînes de caractères formatées)

Les f-strings (formatted strings) permettent d’insérer directement des expressions ou des variables
dans une chaîne en utilisant la syntaxe "...".

1 nom = "Alice"
2 age = 25
3 print(f"Bonjour, je m'appelle {nom} et j'ai {age} ans.")
4 # Affiche : Bonjour, je m'appelle Alice et j'ai 25 ans.
5
6 # Calcul dans une f-string
7 print(f"Dans 5 ans, j'aurai {age + 5} ans.")
8 # Affiche : Dans 5 ans, j'aurai 30 ans.

Les f-strings sont très pratiques pour formater des chaînes de caractères de manière lisible et
concise.

4.3 Les listes

4.3.1 Création de Listes

Une liste est créée en entourant une séquence d’éléments de crochets [] séparés par des virgules.

1 liste1 = [1, 2, 3, 4] # Liste de nombres

2 liste2 = ["pomme", "banane", "orange"] # Liste de chaînes de caractères
3 liste3 = [1, "Python", 3.14, True] # Liste mixte
4 liste_listes = [[1, 2], [3, 4]] # Liste de listes
5 liste4 = [] # Liste vide

Une liste peut contenir des éléments de différents types, y compris d’autres listes.

4.3.2 Accéder aux éléments d’une liste

Comme pour les chaînes de caractères, les éléments d’une liste sont accessibles par leur indice. Les
indices commencent à 0 pour le premier élément.

1 liste = ["pomme", "banane", "orange"]

2 print(liste[0]) # Affiche : pomme
3 print(liste[2]) # Affiche : orange

Les indices négatifs permettent d’accéder aux éléments en partant de la fin de la liste :

1 print(liste[-1]) # Affiche : orange

2 print(liste[-2]) # Affiche : banane
 4.3 Les listes 35

4.3.3 Slicing (découpage de listes)

Le slicing permet d’extraire une sous-liste à partir d’une liste. Cela fonctionne de la même manière
que le slicing des chaînes de caractères, en utilisant les mêmes syntaxes.
1 liste = [1, 2, 3, 4, 5]
2 print(liste[1:4]) # Affiche : [2, 3, 4]
3 print(liste[2:]) # Affiche : [3, 4, 5]
4 print(liste[:3]) # Affiche : [1, 2, 3]
5 print(liste[::2]) # Affiche : [1, 3, 5]
6 print(liste[::-1]) # Affiche : [5, 4, 3, 2, 1]

4.3.4 Concaténation et répétition

À l’instar des chaînes de caractères, on peut effectuer les opérations de concaténation et de répétition
sur les listes.
1 liste1 = [1, 2, 3]
2 liste2 = [4, 5, 6]
3 print(liste1 + liste2) # Affiche [1, 2, 3, 4, 5, 6]
4
5 liste4 = [1, 2]
6 print(liste4 * 3) # Affiche [1, 2, 1, 2, 1, 2]

4.3.5 Modifier une liste

Les listes sont mutables, ce qui signifie que leurs éléments peuvent être modifiés, ajoutés ou
supprimés.
Modifier un élément :
1 liste = ["pomme", "banane", "orange"]
2 liste[1] = "mangue"
3 print(liste) # Affiche : ['pomme', 'mangue', 'orange']

Ajouter des éléments :

• append(élément) : Ajoute un élément à la fin de la liste.
• insert(indice, élément) : Insère un élément à une position spécifique.
1 liste = [1, 2, 3]
2 liste.append(4)
3 print(liste) # Affiche : [1, 2, 3, 4]
4
5 liste.insert(1, 1.5)
6 print(liste) # Affiche : [1, 1.5, 2, 3, 4]

Supprimer des éléments :

• remove(élément) : Supprime la première occurrence d’un élément.
• pop(indice) : Supprime et renvoie l’élément à un indice spécifique (ou le dernier élément
si aucun indice n’est fourni).
• del : Supprime un élément ou une tranche d’éléments.
1 liste = ["pomme", "banane", "orange"]
 36 Chapitre 4. Les séquences en Python : chaînes de caractères et listes

2 liste.remove("banane")
3 print(liste) # Affiche : ['pomme', 'orange']
4
5 element = liste.pop(1)
6 print(element) # Affiche : orange
7 print(liste) # Affiche : ['pomme']
8
9 del liste[0]
10 print(liste) # Affiche : []

4.3.6 Méthodes utiles pour les listes

Python propose de nombreuses méthodes pour manipuler les listes. Voici quelques-unes des plus
courantes :

• len() : Retourne la longueur de la liste.

• sort() : Trie la liste (par défaut en ordre croissant).
• reverse() : Inverse l’ordre des éléments dans la liste.
• count(élément) : Compte le nombre d’occurrences d’un élément.
• index(élément) : Retourne l’indice de la première occurrence d’un élément.
• clear() : Supprime tous les éléments de la liste.

1 liste = [3, 1, 4, 1, 5, 9]
2 print(len(liste)) # Affiche : 6
3
4 liste.sort()
5 print(liste) # Affiche : [1, 1, 3, 4, 5, 9]
6
7 liste.reverse()
8 print(liste) # Affiche : [9, 5, 4, 3, 1, 1]
9
10 print(liste.count(1)) # Affiche : 2
11 print(liste.index(4)) # Affiche : 2
12
13 liste.clear()
14 print(liste) # Affiche : []

4.3.7 Parcourir une liste

Les listes peuvent être parcourues à l’aide d’une boucle for.

1 liste = ["pomme", "banane", "orange"]
2 for fruit in liste:
3 print(fruit)
4 # Affiche :
5 # pomme
6 # banane
7 # orange

Il en est de même pour les chaînes de caractères. Elles peuvent être parcourues à l’aide d’une boucle
for.
 4.3 Les listes 37

1 chaine = "Python"
2 for lettre in chaine:
3 print(lettre)
4 # Affiche :
5 # P
6 # y
7 # t
8 # h
9 # o
10 # n

4.3.8 Listes imbriquées

Les listes peuvent contenir d’autres listes, ce qui permet de créer des structures de données
complexes, comme des matrices.
1 matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
2 print(matrice[0]) # Affiche : [1, 2, 3]
3 print(matrice[0][1]) # Affiche : 2

4.3.9 Copie de listes

Il est important de noter que l’affectation d’une liste à une nouvelle variable ne crée pas une copie
indépendante, mais une référence vers la même liste. Pour créer une copie indépendante, on utilise
la méthode copy() ou le slicing [:].
1 liste1 = [1, 2, 3]
2 liste2 = liste1 # Référence vers la même liste
3 liste2[0] = 99
4 print(liste1) # Affiche : [99, 2, 3]
5 print(liste2) # Affiche : [99, 2, 3]
6
7 liste3 = liste1.copy() # Copie indépendante
8 liste3[0] = 100
9 print(liste1) # Affiche : [99, 2, 3]
10 print(liste3) # Affiche : [100, 2, 3]

Exercices d’application
1. Manipulation de chaînes.
(a) Créez une chaîne de caractères contenant votre prénom.
(b) Affichez la longueur de la chaîne.
(c) Affichez la première lettre de la chaîne.
(d) Affichez la chaîne en majuscules.
(e) Remplacez la deuxième lettre par le caractère "h" et affichez le résultat.
2. Manipulation de listes.
(a) Créez une liste contenant les nombres de 1 à 5.
(b) Ajoutez le nombre 6 à la fin de la liste.
38 Chapitre 4. Les séquences en Python : chaînes de caractères et listes

(c) Supprimez le deuxième élément de la liste.

(d) Affichez la liste triée en ordre décroissant.
3. Listes et chaînes de caractères.
Soit la phrase suivante : "Mon chien a disparu".
(a) Divisez la phrase en une liste de mots.
(b) Affichez le nombre de mots dans la liste.
(c) À partir de la liste de mots, construisez la chaîne suivante "Mon/chien/a/disparu".
4. Listes imbriquées.
Soit la liste suivante : [[1, 2, 3], [4, 5, 6]].
(a) Affichez le deuxième élément de la première sous-liste.
(b) Ajoutez un nombre à la deuxième sous-liste.
(c) Affichez la liste complète.
 5. Fonctions et programmation impérative
procédurale

5.1 Introduction aux fonctions

En programmation, il arrive souvent de devoir répéter une série d’instructions plusieurs fois dans
un programme. Par exemple, imaginez un programme qui doit saluer chaque étudiant d’une classe
par son nom. Écrire la même ligne de code pour chaque étudiant serait long et peu pratique. C’est là
qu’interviennent les fonctions. Une fonction est un bloc de code réutilisable conçu pour accomplir
une tâche spécifique. Elle permet de décomposer un programme complexe en tâches plus petites et
plus gérables. Une fois définie, elle peut être utilisée autant de fois que nécessaire, en modifiant
simplement les données qu’elle traite.
Les fonctions apportent plusieurs avantages. Elles rendent le code plus lisible, car elles divisent
un programme en petites parties logiques avec des noms explicites. Elles permettent aussi la
réutilisabilité : une même fonction peut être appelée à différents endroits sans réécrire le code.
Enfin, elles favorisent la modularité, c’est-à-dire la possibilité de construire un programme comme
un assemblage de briques indépendantes.
Pour mieux comprendre, comparons deux façons de faire. Sans fonction, un programme pourrait
ressembler à ceci :

1 print("Bonjour Alice.")
2 print("Bonjour Bob.")
3 print("Bonjour Charlie.")

Chaque ligne répète la même idée, ce qui devient vite répétitif et difficile à modifier. Avec une
fonction, le même résultat s’obtient ainsi :

1 def saluer(nom):
2 print(f"Bonjour {nom}.")
3
4 saluer("Alice")
5 saluer("Bob")
6 saluer("Charlie")

Ici, une seule fonction, appelée saluer, est définie pour afficher un message personnalisé. Elle est
 40 Chapitre 5. Fonctions et programmation impérative procédurale

ensuite utilisée avec différents noms. Le code est plus court, plus clair et plus facile à adapter. Par
exemple, si le message de salutation devait changer pour devenir "Bonjour {nom}. Comment
allez-vous ?", on appliquera la modification une seule fois, à la fonction, alors que sans
l’utilisation d’une fonction, on sera obligé de modifier chaque ligne.
Dans la suite, nous aborderons comment créer et utiliser des fonctions en Python, avant de mon-
trer comment elles s’intègrent dans une approche de programmation appelée programmation
impérative procédurale.

5.2 Fonctions
Une fois l’idée générale des fonctions comprise, il est temps d’explorer comment elles fonctionnent
en Python. Cette section détaille les étapes pour définir une fonction, lui passer des données,
récupérer ses résultats et gérer les variables qu’elle utilise.

5.2.1 Définir une fonction en Python

En Python, une fonction se crée avec le mot-clé def, suivi du nom de la fonction et de parenthèses.
Ces parenthèses peuvent rester vides si la fonction n’a pas besoin de données spécifiques pour
fonctionner. Après les parenthèses, un deux-points (:) indique le début du bloc de code de la
fonction. Ce bloc doit être indenté (comme les structures de contrôle), c’est-à-dire décalé vers la
droite (généralement de 4 espaces ou une tabulation), pour montrer qu’il appartient à la fonction.
Voici un exemple simple :
1 def dire_bonjour():
2 print("Bonjour à tous !")
3
4 dire_bonjour()

Dans cet exemple, la fonction dire_bonjour est définie pour afficher un message. Elle est
ensuite appelée en écrivant son nom suivi de parenthèses : dire_bonjour(). Sans cet appel, la
fonction reste inutilisée.
Une fonction peut aussi contenir plusieurs lignes de code. Par exemple :
1 def presenter():
2 print("Ce cours est sur Python.")
3 print("Il est conçu pour les débutants.")
4
5 presenter()

L’indentation est essentielle : toutes les lignes qui doivent être exécutées par la fonction doivent
être alignées sous le def. Si une ligne n’est pas indentée, elle est considérée comme extérieure à la
fonction.

5.2.2 Paramètres et arguments

Les fonctions deviennent encore plus puissantes lorsqu’elles peuvent travailler avec des données
différentes à chaque appel. Ces données sont transmises via des paramètres qui sont des variables
définies dans les parenthèses de la fonction. Lors de l’appel, les valeurs fournies sont appelées
arguments.
 5.2 Fonctions 41

Voici un exemple :

1 def multiplier(nombre1, nombre2):

2 resultat = nombre1 * nombre2
3 print(f"Le produit de {nombre1} et {nombre2} est {resultat}")
4
5 multiplier(4, 5) # Affiche : Le produit de 4 et 5 est 20
6 multiplier(2, 10) # Affiche : Le produit de 2 et 10 est 20

Dans ce code, nombre1 et nombre2 sont les paramètres. Quand la fonction est appelée avec
multiplier(4, 5), les arguments 4 et 5 sont assignés à ces paramètres et le calcul s’effectue.
La fonction peut ainsi multiplier n’importe quelle paire de nombres.
Il est aussi possible de définir des paramètres avec des valeurs par défaut. Si un argument n’est
pas fourni lors de l’appel, la valeur par défaut est utilisée :

1 def saluer_personne(nom, message="Bonjour"):

2 print(f"{message} {nom} !")
3
4 saluer_personne("Alice") # Affiche : Bonjour Alice !
5 saluer_personne("Bob", "Salut") # Affiche : Salut Bob !

Ici, message a une valeur par défaut de "Bonjour". Si aucun second argument n’est donné,
cette valeur est utilisée. Sinon, elle est remplacée par l’argument fourni.

5.2.3 Valeur de retour

Jusqu’à présent, les fonctions présentées affichent des messages avec print. Mais une fonction
peut aussi renvoyer une valeur pour que le programme puisse l’utiliser ensuite. Cela se fait avec le
mot-clé return.
Prenons un exemple :

1 def addition(a, b):

2 s = a + b
3 return s
4
5 somme = addition(3, 7)
6 print(somme) # Affiche : 10

Ici, return s renvoie le résultat de l’addition. Ce résultat est stocké dans la variable somme, qui
peut ensuite être utilisé. Sans return, la fonction ne produirait rien d’utilisable :

1 def addition_sans_retour(a, b):

2 s = a + b # Le calcul est fait, mais rien n'est renvoyé
3
4 resultat = addition_sans_retour(3, 7)
5 print(resultat) # Affiche : None

Une fonction sans return renvoie automatiquement None, une valeur spéciale en Python qui
signifie "rien". Il est donc important de distinguer print (qui affiche quelque chose à l’écran) de
return (qui transmet une valeur au programme).
 42 Chapitre 5. Fonctions et programmation impérative procédurale

5.2.4 Portée des variables

Quand une fonction utilise des variables, il faut comprendre où elles "vivent". Une variable définie à
l’intérieur d’une fonction est locale, c’est-à-dire qu’elle n’existe que dans cette fonction. À l’inverse,
une variable définie en dehors est globale et accessible partout dans le programme.
Voici une illustration :

1 nombre_global = 100
2
3 def doubler():
4 nombre_local = 5
5 print(f"Dans la fonction : {nombre_local * 2}")
6 print(f"Nombre global : {nombre_global}")
7
8 doubler()
9 print(f"En dehors : {nombre_global}")
10 # Affiche :
11 # Dans la fonction : 10
12 # Nombre global : 100
13 # En dehors : 100

Dans cet exemple, nombre_local n’existe qu’à l’intérieur de doubler(). Si on essayait d’y
accéder en dehors, Python signalerait une erreur. De son côté, nombre_global reste accessible
partout, même à l’intérieur de la fonction.
Mais que se passe-t-il si une fonction veut modifier une variable globale ? Par défaut, une fonction
ne peut pas changer une variable globale sans une instruction spéciale. Observons cela :

1 compteur = 0
2
3 def incrementer():
4 compteur = compteur + 1 # Erreur, car Python ne sait pas qu'il s'agit de
la variable globale.
5
6 incrementer()

Ce code provoque une erreur, car Python traite compteur comme une nouvelle variable locale.
Pour modifier une variable globale, il faut utiliser le mot-clé global :

1 compteur = 0
2
3 def incrementer():
4 global compteur
5 compteur = compteur + 1
6
7 incrementer()
8 print(compteur) # Affiche : 1

Cependant, modifier des variables globales est rarement une bonne idée, car cela rend le programme
plus difficile à suivre. Il est souvent préférable de passer les données nécessaires en paramètres et
de renvoyer les résultats avec return.
 5.3 Programmation impérative procédurale 43

5.3 Programmation impérative procédurale

Maintenant que les fonctions sont bien maîtrisées, il est temps de voir comment elles s’intègrent
dans une manière spécifique d’écrire des programmes : la programmation impérative procédurale.
Cette approche repose sur une idée simple : un programme est une suite d’instructions exécutées
étape par étape, organisée en procédures, c’est-à-dire des fonctions qui réalisent des tâches précises.
Chaque fonction joue un rôle clair, comme une équipe où chaque membre a une mission définie.
Dans la programmation impérative, le programme indique exactement comment faire quelque
chose, en donnant des ordres successifs : "fais ceci, puis fais cela". En ajoutant l’aspect procédural,
ces ordres sont regroupés dans des fonctions appelées au bon moment. Cela diffère d’un code non
structuré, où toutes les instructions seraient écrites dans un seul bloc sans séparation logique.
Pour illustrer cette différence, prenons un exemple. Voici un programme simple qui calcule et
affiche le prix total de deux articles, sans utiliser de fonctions :

1 prix1 = 10
2 prix2 = 15
3 total = prix1 + prix2
4 print("Le prix total est :", total)

Ce code fonctionne, mais si plusieurs calculs de ce type étaient nécessaires, il faudrait répéter ces
lignes à chaque fois. Le code manquera donc de clarté et de flexibilité. Voici maintenant une version
procédurale avec des fonctions :

1 def calculer_total(prix1, prix2):

2 return prix1 + prix2
3
4 def afficher_resultat(total):
5 print("Le prix total est :", total)
6
7 prix_article1 = 10
8 prix_article2 = 15
9 somme = calculer_total(prix_article1, prix_article2)
10 afficher_resultat(somme)

Dans cette version, le programme est divisé en deux fonctions : une pour calculer le total
(calculer_total) et une pour afficher le résultat (afficher_resultat). Chaque fonction
a une tâche unique, ce qui rend le code plus facile à lire et à modifier. Par exemple, si la manière
d’afficher le résultat devait changer, il suffirait de modifier afficher_resultat sans toucher
au reste.
Un autre avantage apparaît quand les tâches deviennent plus complexes. Imaginons une calculatrice
basique qui peut additionner ou soustraire selon une opération choisie :

1 def addition(a, b):

2 return a + b
3
4 def soustraction(a, b):
5 return a - b
6
7 def calculer(operation, x, y):
8 if operation == "+":
9 return addition(x, y)
10 elif operation == "-":
 44 Chapitre 5. Fonctions et programmation impérative procédurale

11 return soustraction(x, y)
12
13 resultat1 = calculer("+", 5, 3)
14 resultat2 = calculer("-", 10, 4)
15 print(resultat1) # Affiche : 8
16 print(resultat2) # Affiche : 6

Ici, trois fonctions collaborent : addition et soustraction réalisent des calculs spécifiques,
tandis que calculer décide quelle opération appliquer en fonction d’un paramètre. Cette structure
montre comment la programmation procédurale organise le travail en étapes logiques, rendant le
programme plus clair et réutilisable.
Prenons un autre exemple d’un programme qui calcule la moyenne des notes d’un étudiant et
détermine si l’étudiant a réussi ou échoué.

1 # Fonction pour calculer la moyenne

2 def calculer_moyenne(notes):
3 somme = 0
4 total_notes = len(notes)
5 for n in notes:
6 somme = somme + n
7 moyenne = somme / total_notes
8 return moyenne
9
10 # Fonction pour déterminer si l'étudiant a réussi
11 def a_reussi(moyenne):
12 if moyenne >= 10:
13 return "Réussi"
14 else:
15 return "Échoué"
16
17 # Programme principal
18 notes = [12, 15, 8, 14]
19 moyenne = calculer_moyenne(notes)
20 resultat = a_reussi(moyenne)
21
22 print(f"Moyenne : {moyenne}")
23 print(f"Résultat : {resultat}")
24
25 # Affiche :
26 # Moyenne : 12.25
27 # Résultat : Réussi

Dans ce programme, la fonction calculer_moyenne prend une liste de notes en entrée et

retourne la moyenne. La fonction a_reussi prend ensuite la moyenne en entrée et retourne
"Réussi" si la moyenne est supérieure ou égale à 10, sinon "Échoué". Le programme principal
utilise ces fonctions pour calculer la moyenne et afficher le résultat.
En résumé, la programmation impérative procédurale utilise les fonctions pour diviser un problème
en petites parties gérables. Chaque fonction agit comme une procédure, exécutant une série d’ins-
tructions dans un ordre précis. Cette approche est idéale pour structurer des programmes simples
ou intermédiaires.
5.3 Programmation impérative procédurale 45

Exercices d’application

1. Écrivez une fonction appelée calculer_carre qui prend un nombre en paramètre et

retourne son carré. Testez cette fonction avec le nombre 5.
2. Écrivez une fonction appelée calculer_moyenne qui prend trois nombres en paramètres
et retourne leur moyenne. Testez cette fonction avec les nombres 10, 20 et 30.
3. Écrivez une fonction appelée est_pair qui prend un nombre en paramètre et retourne
True si le nombre est pair, sinon False. Testez cette fonction avec les nombres 4 et 7.
4. Écrivez une fonction appelée saluer qui prend un nom en paramètre et affiche "Bonjour,
{nom} !". Si aucun nom n’est fourni, la fonction doit afficher "Bonjour, Utilisateur
!".
5. Écrivez une fonction appelée somme qui prend une liste de nombres et retourne leur somme.
Testez cette fonction avec la liste [3, 7, 2, 9, 4].
6. Écrivez un programme procédural avec les fonctions suivantes :
• addition(a, b) : renvoie la somme de deux nombres.
• soustraction(a, b) : renvoie la différence entre deux nombres.
• multiplication(a, b) : renvoie le produit de deux nombres.
• division(a, b) : renvoie le quotient de a par b.
• puissance(a, b) : renvoie a puissance b.
• calculer(operation, x, y) : appelle la bonne fonction selon l’opération
demandée ("+", "-", "*", "/", "**").
Tester avec les opérations : 5 + 3, 10 - 4, 6 * 2, 15 / 5, 2 ** 8
7. Analysez le code suivant et prédisez ce qu’il affiche, puis corrigez-le pour qu’il incrémente
une variable globale compteur à chaque appel :
1 compteur = 0
2 def incrementer():
3 compteur = compteur + 1
4 incrementer()
5 incrementer()
6 print(compteur)