Apprendre

à coder en Python
 Dans la série « Apprendre à… »

André Giordan, Jérôme Saltet,

Apprendre à apprendre, Librio no 831
André Giordan, Jérôme Saltet,
Apprendre à prendre des notes, Librio no 999
André Giordan, Jérôme Saltet,
Apprendre à réussir, Librio no 1003
André Giordan, Jérôme Saltet,
Apprendre à réviser, Librio no 1004
Pascale Matteï, Apprendre à rédiger, Librio no 1012

Dans la même collection

Conjugaison française, Librio no 470

David Alfroy, Cécile Sauvan,
Je déchire au lycée, Librio no 1119
Nathalie Baccus, Grammaire française, Librio no 534
Nathalie Baccus, Orthographe française, Librio no 596
Axelle Beth, Elsa Marpeau, Figures de style, Librio no 710
Alexandre Bourjala,
Maths pratiques, maths magiques, Librio no 763
Pierre-Alain Caltot, Français : mémo lycée, Librio no 1203
Jean-Pierre Colignon,
Difficultés du français, Librio no 642
Alain Gastineau,
Formulaire de mathématiques. Lycée, Librio no 756
Pierre Jaskarzec,
Les mots qui se ressemblent, Librio no 772
Mathilde Morinet, Réussir le bac de français.
La question de grammaire, Librio no 1278
Carole Narteau, Irène Nouailhac, Littérature française.
Les grands mouvements littéraires, Librio no 993
Damien Panerai, Dictionnaire de rimes
et petit traité de versification, Librio no 671
Charles Pépin, Comment réussir son bac philo ?,
Librio no 1006
Mathieu Scavennec, Le Calcul.
Précis d’algèbre et d’arithmétique, Librio no 595
 Daniel Ichbiah

Apprendre
à coder en Python
 © E.J.L., 2024
EAN 9782290405277
 Sommaire

Introduction......................................................................... 9
La programmation, c’est quoi au juste ?......................... 9
Quelles sont les spécificités de Python ?.......................... 10
Qui a créé Python ?........................................................... 11
Pourquoi est-il bon d’apprendre à coder en Python ?..... 12
Comment fonctionne Python ?........................................ 13
Qu’est-ce qu’un environnement de développement ?...... 15
Quel IDE choisir ?............................................................. 16
Comment accéder à Colab ?............................................. 16
À vos marques…............................................................... 21

1. Les bases de Python...................................................... 23

Les variables...................................................................... 23
Les chaînes de caractères................................................. 26
Les nombres...................................................................... 29
Les collections d’éléments................................................ 31
Les opérateurs................................................................... 37
Les commentaires............................................................. 39
Vous avez toutes les bases !.............................................. 40

2. Les structures essentielles d’un programme............. 41

Les fonctions..................................................................... 41
Les fonctions prédéfinies................................................. 45
Les conditions................................................................... 51
Les boucles........................................................................ 55
Paré pour écrire des programmes !................................. 60

3. La gestion des erreurs................................................... 61

Les erreurs les plus fréquentes
dans un programme Python........................................ 61
Les messages d’erreurs de l’IDE....................................... 63
L’aide des IA génératives.................................................. 64

4. Quelques programmes de base.................................... 66

Les années bissextiles....................................................... 66

7
sommaire

Le générateur de phrases aléatoires................................ 68

La suite de Fibonacci........................................................ 69
Le jeu du pendu................................................................ 70
Les outils du programmeur.............................................. 75

5. Les bibliothèques Python............................................. 76

Le site PyPi........................................................................ 77
La bibliothèque « Pandas ».............................................. 77
La représentation d’informations sous forme graphique
avec Matplotib et Seaborn........................................... 82
Les bibliothèques, une mine de possibilités.................... 85

6. La distribution des programmes................................. 86

La compilation.................................................................. 86
PyInstaller......................................................................... 87
À vos marques…............................................................... 91
 Introduction

La programmation, c’est quoi au juste ?

La programmation (ou « développement d’applica-

tions ») consiste à donner des instructions à un ordina-
teur afin qu’il accomplisse des tâches précises. On parle
aussi de « codage ». Il existe en fait trois appellations
pour une même activité : programmeur, développeur
d’applications et codeur.
Mais en quoi consiste précisément cette activité à
laquelle nous recourrons tous quotidiennement ? En
effet, si vous aimez les jeux vidéo, vous avez peut-être
consacré de nombreuses heures à évoluer dans les mondes
de Fortnite ou sur les circuits de Formula One. Peut-
être aussi vous êtes-vous démené tant bien que mal avec
les figures de Tetris, qu’il fallait faire pivoter au plus vite,
avant qu’elles ne s’entassent au bas de l’écran et annoncent
le « Game Over » redouté. Si vous aimez écrire, il est pro-
bable que vous utilisiez Word, Google Docs ou Open Office
pour noter vos idées. Sur votre téléphone mobile, vous
vous servez peut-être d’Uber, d’Airbnb ou de Blablacar…
Tous ces usages recourent à des applications. Pour
les concevoir, un programmeur tel qu’Alexey Pajitnov (le
créateur de l’un des jeux les plus populaires au monde,
Tetris) a donné des instructions à un ordinateur. En
d’autres termes : il a utilisé un langage de program-
mation. En effet, de la même manière que nous appre-
nons et parlons différentes langues comme le français ou
l’anglais, les ordinateurs utilisent des langages qui leur
sont propres : Python, JavaScript, PHP… Pour instruire
un ordinateur, il nous faut donc apprendre l’un de ces
langages. Ils nous permettront de faire accomplir par un

9
introduction

ordinateur des tâches précises et variées : déplacer

un personnage à l’écran, additionner une colonne de
chiffres, énoncer une phrase que nous avons tapée avec
un accent canadien…

L’auteur de ce livre (à gauche),

en compagnie d’Alexey Pajitnov, le créateur de Tetris.

Quelles sont les spécificités de Python ?

Les premiers micro-ordinateurs intégraient presque

toujours un langage de programmation à la portée de
tous, le BASIC. Les lecteurs plus âgés se souviendront
peut-être que, durant les années quatre-vingt, lorsqu’ils
achetaient un micro-ordinateur Thomson TO7, un
Amstrad, ou un Alice par exemple, celui-ci intégrait tou-
jours le langage BASIC. De nombreux programmeurs
émérites ont fait leurs premiers pas en codant leur
propre version de Pong ou de Space Invaders.
Python, par sa simplicité d’usage, a pris la relève et
s’est progressivement imposé comme le langage de pro-
grammation vedette. Une analyse effectuée sur le site de
référence Github a montré que, au troisième trimestre
de 2022, Python était devenu le langage le plus utilisé
au monde, toutes applications confondues.

10
 qui a créé python ?

La raison de ce succès tient à la simplicité des règles

d’usage du langage Python : il est ainsi devenu, peu à
peu, l’outil de prédilection des développeurs. Sa grande
force est d’avoir offert une syntaxe (l’équivalent d’une
grammaire) aussi facile à manipuler que le BASIC
d’antan. Comme nous le verrons, il est possible de maî-
triser les bases de Python et de créer des programmes
utiles en quelques dizaines de minutes seulement, par-
fois moins.
Mais si Python a détrôné le BASIC, c’est que son
rayon d’action est sans commune mesure avec celui
de son ancêtre : s’il est aisé de débuter avec Python, il
est également possible de l’utiliser pour des projets de
très grande envergure. De fait, ce langage est mis à
contribution par des sociétés telles que Google, Netflix,
Facebook-Instagram, Uber, Spotify et bien d’autres géants
de la technologie.
Comme vous le découvrirez dans le chapitre 5, il
existe de nombreuses « bibliothèques » qui enrichissent
le langage Python. Ces bibliothèques proposent des
fonctions prédéfinies comme la représentation de décors
de jeu vidéo, l’affichage de s­ tatistiques, l’analyse de sites
Web, le calcul de haut niveau…

Qui a créé Python ?

Python a été créé en décembre 1989 par le Hollandais

Guido van Rossum, à l’Institut de recherches en infor-
matique d’Amsterdam. Si van Rossum l’a baptisé ainsi,
c’est parce qu’il était un grand admirateur de la série bri-
tannique des Monty Python, célèbre pour son humour
irrévérencieux.
Python a été délibérément conçu de façon à être facile
à aborder par un débutant, mais également « open
source ». Ce terme désigne un type de logiciel dont le
code est rendu public et disponible gratuitement à qui-
conque souhaite le consulter, l’utiliser ou même le
modifier et le distribuer. Ce modèle encourage la colla-
boration active d’une communauté de développeurs. La
présentation de Python a eu lieu en février 1991, mais sa
naissance officielle remonte à janvier 1994. Il a depuis

11
introduction

connu plusieurs mises à jour, telles que Python 2.0

(octobre 2000) et Python 3.0 (décembre 2008).
L’institut où est né Python continue d’en assurer
la maintenance et, régulièrement, de nouvelles ver-
sions apparaissent avec des modifications mineures ou
majeures, ce qui occasionne des numérotations appro-
priées : 3.1, 3.2, 3.3… La version en cours en 2024
est la 3.14 mais vous pouvez tout à fait utiliser une ver-
sion antérieure.

Pourquoi est-il bon d’apprendre

à coder en Python ?

En premier lieu, pour le plaisir : coder en Python

s’avère très « fun ». Mais il s’agit également d’une com-
pétence prisée : le métier de développeur d’applications
(ou programmeur) est très porteur, notamment dans le
domaine de la création d’applications pour le Web ou
les téléphones mobiles. La demande est considérable et
dépasse largement l’offre.
En d’autres termes, un grand nombre d’entreprises
sont à la recherche de développeurs et ont souvent du
mal à en trouver. Selon les chiffres de la Grande École
du numérique parus en janvier 2023, le métier de déve-
loppeur se classe à la première place des métiers les
plus recherchés dans le numérique. Il en résulte des
salaires élevés pour les intéressés, qu’ils opèrent au sein
d’une entreprise ou en free-lance.
De plus, Python n’est de loin pas le seul langage de
programmation recherché et plusieurs autres ont le vent
en poupe : JavaScript, Typescript, Rust, Swift, C#… Or,
les concepts restent les mêmes d’un langage à l’autre : si
vous savez programmer en Python, il vous sera possible
d’apprendre d’autres langages ! Il constitue donc une
entrée en matière idéale. Ce que vous apprendrez au fil
de ces pages vous permettra donc d’évoluer dans l’uni-
vers très large de Python, mais pas seulement.

12
 comment fonctionne python ?

Comment fonctionne Python ?

Le notebook ou carnet
Chaque programme Python doit être placé dans ce que
l’on appelle un « notebook » (en français « carnet »). Les
notebooks sont des fichiers dotés d’une extension pré-
cise, habituellement :
– .py (abréviation de Python) ;
– .ipynb (i pour interactif, py pour Python, nb pour
notebook).

Voici quelques exemples de notebooks contenant

chacun un programme rédigé en Python. Ils portent l’ex-
tension « .ipynb ».

13
introduction

14
 qu’est-ce qu’un environnement de développement ?

Qu’est-ce qu’un environnement

de développement ?

Si l’usage de Python est aisé, c’est parce qu’il fonc-

tionne dans des « environnements de développement »
(en anglais « IDE » pour « Integrated Development
Environment »). Un IDE désigne l’ensemble des outils
qui facilitent le travail de programmation, notam-
ment en permettant de tester le code que l’on écrit.
Dans un IDE, le code Python tapé s’affiche dans un
éditeur de texte situé en haut. L’exécution du code
apparaît quant à elle dans le panneau situé au-dessous.
Pour lancer le programme, il faut cliquer sur une
icône (habituellement, le symbole « play »). Le résultat
apparaît alors dans le panneau ­inférieur.
Voici une illustration avec l’IDE Thonny : le code,
rédigé dans le panneau supérieur est exécuté dans le
panneau inférieur lorsque le bouton « play » est cliqué
(il affiche la mention « Bonjour » suivie du prénom tapé).

15
introduction

Il existe de nombreux IDE pour Python dont voici

quelques exemples :
– sur ordinateur (Windows, Mac, Linux) : Thonny,
Mu Editor, Jupyter, Google Colab (accessible en ligne) ;
– sur iPad : Programming Notebook Lite, Carnets
(Jupyter, Pythonista) ;
– sur Android : Pydroid 3, QPython.

Quel IDE choisir ?

Vous pouvez installer l’IDE de votre choix. Nous vous

suggérons néanmoins, pour faciliter le premier contact,
d’utiliser le service Colab de Google. Grâce à celui-ci,
vous n’aurez pas à installer d’application. Cet outil est
disponible depuis un navigateur Web sur n’importe quel
ordinateur ou téléphone mobile, sur n’importe quelle
tablette. Attention cependant, il vous faudra disposer
d’une connexion Internet chaque fois que vous utili-
serez Colab.
Si vous souhaitez ne pas dépendre de la connexion,
vous pouvez installer Thonny, simple d’utilisation et
gratuit également.

Comment accéder à Colab ?

Disposer d’un compte Google

Avant toute chose, il faut que vous faut disposiez
d’un compte Google. Celui-ci vous donnera accès à de
nombreux avantages, notamment – c’est ce qui nous
intéresse ici – 15 Go de stockage gratuit sur le Cloud de
Google, appelé Drive. Or, c’est dans Google Drive que
vous stockerez les notebooks réalisés avec Colab.
Une adresse Gmail est le sésame d’un compte
Google. Si vous n’en disposez pas encore, voici la
marche à suivre :

16
 comment accéder à colab ?

1. Tapez : [Link] puis cliquez sur « Créer

un compte » dans la partie supérieure droite et précisez
que celui-ci sera à usage personnel.

2. Indiquez un prénom et un nom, puis cliquez sur

« Suivant ».

3. Choisissez un mot de passe complexe et

confirmez-le. Cliquez sur « Suivant ».

4. Indiquez un numéro de téléphone qui aidera à sécu-

riser votre compte Google.

5. Fournissez les autres informations demandées, puis

cliquez sur « Suivant ».

6. Google vous adressera alors un SMS avec un code de

validation. Saisissez ce code, puis cliquez sur « Valider ».

Sur [Link], vous pourrez vérifier que la nouvelle

adresse électronique est active en envoyant un courriel.

Se connecter à Colab
Le service est accessible à cette adresse : [Link]
[Link]/
La première fois que vous l’utiliserez, il sera probable-
ment nécessaire de cliquer sur « Connexion » (en haut à
droite). Renseignez votre adresse Gmail puis, si néces-
saire, votre mot de passe.
Sur la page d’accueil de Colab, vous verrez appa-
raître un panneau « Ouvrir le notebook ». Lors de
vos prochaines connexions, celui-ci fera apparaître
les notebooks que vous aurez créés précédemment.
Pour votre première connexion, Google vous pro-
posera l’accès à une page de bienvenue, mais vous
pouvez l’ignorer.
Choisissez plutôt l’option « Nouveau notebook » qui
apparaît en bas à gauche sur fond bleu. Vous pouvez
désormais créer des programmes en Python !

17
introduction

18
 comment accéder à colab ?

Comprendre l’environnement de travail

Une fois l’option « Nouveau notebook » choisie, une
nouvelle page s’affichera : c’est notre environnement
de travail.
Examinons-la de plus près : la partie essentielle est
la zone grise qui permettra de taper le programme.
L’exécution du programme est située dans la zone du
dessous. Dans l’exemple suivant, nous demandons à un
utilisateur de taper un mot. Le programme envoie en
réponse le nombre de lettres contenues dans ce mot.

En haut à gauche de l’écran, le signe « ∞ » – qui repré-

sente l’infini – c’est le logo de Colab.
À droite de ce logo, vous trouverez le nom du note-
book avec l’extension .ipynb évoquée plus haut. Au
début, le fichier s’intitule « [Link] » (note-
book sans titre). La première action à effectuer lors de
la création d’un nouveau notebook sera de lui donner
un nom.
Sur la ligne au-dessous, vous pouvez voir un menu tra-
ditionnel avec des options comme « Fichier », « Modifier »,
« Affichage »… À l’exception de l’option « Fichier » (qui
servira à stocker nos notebooks et à les retrouver), nous
utiliserons peu ce menu.

19
introduction

Sur la ligne au-dessous encore, deux options sont pro-

posées : « +Code » et « +Texte ». Nous utiliserons avant
tout l’option « +Code » afin de produire un nouveau bloc
de code Python.
La fenêtre principale comporte une zone grise avec
l’icône « play » mentionnée plus tôt. C’est dans cette
zone que vous taperez le code. Chaque fois que vous
ajouterez une ligne, un nouveau numéro apparaîtra
dans cette fenêtre.
Sur la colonne de gauche, vous pouvez voir une série
d’icônes. Elles donnent accès à certaines fonctions qui
pourront s’avérer utiles – comme charger un fichier
dans l’espace associé au notebook. Néanmoins, nous uti-
liserons peu ces outils au cours de notre apprentissage.

Utiliser Colab sur iPad ou iPhone

Pour iPad et iPhone, il existe une application
nommée Programming Notebook Lite qui donne accès
à Colab depuis une interface adaptée à de tels appareils
mobiles. Vous pourrez ainsi accéder aux notebooks que
vous aurez créés avec Colab depuis votre téléphone ou
votre tablette.

20
 à vos marques…

À vos marques…

Nous avons désormais tout ce dont nous aurons

besoin pour apprendre à coder en Python. Au cours de
cette aventure, nous ferons abondamment appel à votre
IDE, car rien ne vaut la pratique ! Chaque fois que nous
aborderons de nouvelles notions, nous vous inviterons
à taper les instructions proposées dans Colab ou tout
autre environnement que vous auriez pu choisir.
Êtes-vous prêt pour apprendre à coder ? C’est parti !
 1.

Les bases de Python

Toute activité requiert des outils spécifiques. Un pho-

tographe manipulera des trépieds, des é­quipements
d’éclairage, mais aussi, depuis plusieurs années, des
drones ! Un horloger emploiera des tournevis de précision,
des loupes et d’autres instruments servant à assembler et
régler des montres. Un technicien en énergies renouve-
lables gérera des appareils de mesure liés à l’énergie…
Les programmes rédigés en Python n’échappent pas à la
règle : ils requièrent certains éléments particuliers, appelés
des variables.

Les variables

La manipulation de variables est l’un des points essen-

tiels des langages de programmation. Une variable est
analogue à une boîte. Si nous considérons deux boîtes,
l’une en bois et l’autre en métal, elles seront toujours ce
qu’elles sont :
– la boîte en bois sera toujours une boîte en bois ;
– la boîte en métal sera toujours une boîte en métal.
Leur contenu, en revanche, pourra changer au fil du
temps. Par exemple, la boîte en bois contiendra d’abord
des stylos. Plus tard, elle logera des écouteurs sans fil,
puis des pailles en bambou. La boîte en métal contiendra
des dragées, puis des bijoux, puis des tasses à café…
En Python – comme dans tous les langages de pro-
grammation – l’approche est la même : il faut distinguer
le contenant et le contenu.

23
les bases de python

Les noms de variable et les contenus

Chaque variable possède un identifiant (nom) et un
contenu qui est appelé une valeur. Ce contenu est indiqué
par le symbole « = ».
Voici un exemple :
Prénom = "Samantha". Ici, nous définissons une variable dont
l’identifiant est « Prénom ». En utilisant le signe « = »,
nous lui attribuons la valeur « Samantha ».
Nous pouvons changer la valeur de « Prénom » et lui
donner la valeur « Louis » :
Prénom = "Louis".
Le contenu peut changer à volonté pour la plupart des
variables – il existe certaines exceptions que nous abor-
derons plus tard.

Un exemple de variable et de son contenu

Pour mettre en pratique cette idée, créez un nou-
veau notebook sous Colab. Donnez-lui un nom tel que
« [Link] », puis tapez le code suivant (sans les
chiffres numérotant les lignes, qui sont placés automati-
quement par Colab lorsque vous en demandez l’affichage) :

1. Prénom = input("Entrez votre prénom : ")

2. Nom = input("Entrez votre nom : ")
3. print("Votre nom complet est :", Prénom, Nom)

Aux lignes 1 et 2, nous définissons deux variables,

« Prénom » et « Nom ». Toutefois, au lieu de leur assi-
gner des valeurs, nous invitons l’utilisateur à les taper.
Pour cela, nous utilisons une fonction de Python appelée
« input() ». Celle-ci invite l’utilisateur à taper une valeur
(ici un nom, puis un prénom). Les valeurs seront alors
stockées dans la variable correspondante (« Prénom »
ou « Nom »).
À la ligne 3, la fonction « print() » affiche à l’écran le
nom complet.
Une fois le code rédigé, exécutez-le en cliquant
sur l’icône « play ». Si Colab indique qu’il existe une
erreur, vérifiez que vous avez bien tapé le code exac-
tement comme dans l’exemple. Chaque fois que vous
exécuterez ce programme, il vous demandera d’entrer

24
 les variables

un nom et un prénom, lesquels seront stockés dans

des variables. Le programme affichera alors le nom
complet, comme vous pouvez le voir ici.

Les fonctions seront abordées en détail dans le cha-

pitre 2. Toutefois, afin de faciliter l’étude de ce chapitre,
nous utiliserons abondamment les fonctions « input() »
et « print() » ainsi que quelques autres dans le cadre de
nos programmes de test.

Si vous effectuez une pause dans votre pratique au

cours de ce chapitre, sachez que le notebook que vous
avez créé (« [Link] ») est stocké automatique-
ment dans Google Drive. Pour le retrouver, lorsque vous
ouvrez Colab, choisissez « Google Drive » dans le menu
d’ouverture des fichiers.

Les conventions de nommage des variables

Voici quelques règles pour nommer correctement vos
variables. Leurs noms peuvent contenir des lettres, des
chiffres et le signe « _ ». En revanche, ils ne peuvent
ni commencer par un chiffre ni c­omporter d’espace.
Aussi, « Ville », « distance » ou « _max10 » seraient des
noms corrects. En revanche, « 1max » ou « Alien Name »
seraient incorrects.
Les noms de variable sont sensibles à la casse.
« Prénom » et « prénom » seraient considérées comme
deux variables différentes.

25
les bases de python

Pour faciliter la compréhension du code, le nom d’une

variable doit idéalement correspondre à son contenu.
Un nom tel que « NinjaSpeed » sera plus facile à inter-
préter qu’un nom peu explicite tel que « N », « NS »…
De même, des noms descriptifs tels que « Ingredient_
Pizza » ou « Navigateur » sont préférables à des appella-
tions comme « a », « xyz », « zzz »…
Évitez d’utiliser comme nom de variable des mots-clés
de Python tels que « Input », « Print », « True »…
Enfin, pour désigner une valeur constante, il est pré-
férable d’utiliser des noms intégralement en majus-
cules : « PI », « VITESSE_LUMIERE », « GRAVITE_
TERRESTRE » qui permettront d’identifier facilement
et rapidement ces constantes.

Les principaux types de variables

Il existe plusieurs types de variables en Python, dont
nous allons voir les principales plus en détail. Il s’agit
des chaînes de caractères, des nombres, des collec-
tions d’éléments et des variables booléennes (avec deux
valeurs possibles) : « True » (vrai) ou « False » (faux).

Les chaînes de caractères

Une variable de type chaîne de caractères contient

du texte, délimité par des guillemets simples ou doubles.
C’est le type de données le plus utilisé en Python.
Dans l’exemple précédent, nous avons manipulé
des variables chaîne de caractères comme « Nom »
et « Prénom ».
Le tout premier exemple donné dans ce chapitre
concernait une chaîne de caractères de ce type :
­P rénom = "Samantha". Nous aurions également pu taper :
Prénom = 'Samantha'.
Rappelons qu’il est possible de changer le contenu
d’une telle variable : Prénom = "Louis".

26
 les chaînes de caractères

Les méthodes
Les variables chaînes de caractères peuvent se voir
appliquer ce que l’on appelle des « méthodes ». Il
s’agit d’une action qui peut être accomplie sur une
variable donnée.
Certaines méthodes peuvent transformer le contenu
d’une chaîne de caractères : les transformer en majus-
cules ou minuscules, supprimer certaines lettres…
Par exemple, l’action « .upper() » convertit le contenu
de la chaîne de caractères en majuscules.
Les méthodes comme « .upper() » sont placées à la fin
du nom de la variable.

La méthode « .upper() »
Rédigeons un petit programme pour transforme un nom
de ville en majuscules grâce à la fonction « .upper() ».

Vous pouvez gérer plusieurs programmes dans un

même notebook. Pour ce faire, il vous faut cliquer sur
« +Code » dans Colab. Une nouvelle cellule est créée
– le terme « cellule » désigne la zone contenant un pro-
gramme. Pour le retrouver, lorsque vous ouvrez Colab,
choisissez « Google Drive » dans le menu d’ouverture des
fichiers.

Cliquez sur « +Code » pour créer une nouvelle cellule

puis tapez le code suivant :

1. Ville = input("Tapez un nom de ville : ")

2. Ville_Majusc = [Link]()
3. print(Ville_Majusc)

Ici, nous demandons à l’utilisateur de taper un nom de

ville. Nous convertissons ce nom de ville en lettres majus-
cules, puis lui affichons ce nom en majuscule.
Testez le programme en cliquant sur « play ».

27
les bases de python

La méthode « .lower() »

La méthode « .lower() » a l’effet inverse de « .upper() » :

elle transforme toutes les lettres d’une chaîne de carac-
tères en minuscules.
Vous pouvez tester cette dernière sur le programme
ci-dessus si vous le souhaitez

La méthode « .replace() »

Un autre exemple de méthode applicable sur les

chaînes de caractères est « .replace() ». Celle-ci rem-
place une partie de la chaîne de caractères par
une autre.

Ici encore, testons un exemple. Cliquez sur « +Code »,

puis tapez le code suivant :

1. Nombizarre = input("Inventez un nom bizarre avec beaucoup de x : ")

2. Nomplusbizarre = [Link]("x", "yxyz")
3. print("Votre nom rendu encore plus bizarre : ", Nomplusbizarre)

À la ligne 1, nous demandons à l’utilisateur de taper

un nom bizarre avec beaucoup de « x ». À la ligne 2,
nous remplaçons tous les « x » de ce nom par « yxyz ».
À la ligne 3, nous imprimons ce nouveau nom.

28
 les nombres

Testez le code.

Dans les exemples de programmes de ce chapitre, afin

de suivre une progression simple, nous supposons que
l’utilisateur tape une réponse correcte. La gestion des
erreurs de frappe sera abordée au chapitre 2.

Les nombres

Les deux principaux types de nombres sont les sui-

vants : entiers et flottants.

Les nombres entiers

Un nombre entier n’a pas de partie décimale. Par
exemple, c’est le cas pour Longueur = 12 ou Âge = 27.
Il est possible d’obtenir un nombre entier à partir
d’un nombre quelconque grâce à la fonction int(). Voici
un exemple :

Âge = input("Entrez un âge: ")

Âge_entier = int(Âge)

Si l’utilisateur tape un nombre tel que « 23.5 », nous

obtiendrons « 23 » dans la variable « Âge_entier ».

Les nombres à virgule flottante

Les nombres à virgule flottante désignent les nombres
avec une partie décimale. Le terme « flottante » signifie
que la virgule peut être à des emplacements divers du
nombre. Comme Python repose sur la notation anglaise,
il faut utiliser un point pour indiquer la décimale. Par
exemple : Note = 13.5 ou Kilomètres = 35.44.

29
les bases de python

Pour convertir un entier en flottant, il est possible

d’utiliser la fonction « float() ». Voici un exemple :

Longueur = input("Entrez une longueur")

Longueur_flottante = float(Longueur)

La fonction « input() » renvoie toujours à une chaîne

de caractères (str), quel que soit le contenu saisi par
l’utilisateur. Pour qu’un nombre entré par l’utilisateur
soit utilisé comme tel, il faut le convertir explicitement
en nombre en utilisant une fonction telle que « int() » ou
« float() ».
À défaut, le nombre tapé sera interprété comme une
chaîne de caractères : si un calcul est effectué avec,
Python renverra une erreur.

Voici, pour vous exercer, un petit programme pour

convertir des degrés Celsius en degrés Fahrenheit :

1. Celsius = input("Entrez une température : ")

2. Température = float(Celsius)
3. Farenheit = (Température * 1.8) + 32
4. print("L'équivalent en Farenheit est de :", Farenheit)

Testez le programme : il invite à entrer une tempéra-

ture qui sera convertie en son équivalent dans le système
anglo-saxon Fahrenheit. Vous pouvez voir à la ligne 2
que le nombre entré par l’utilisateur est d’abord converti
en nombre flottant.

30
 les collections d’éléments

Les collections d’éléments

Un autre type de variables que vous allez avoir à gérer

est la collection d’éléments. Il s’agit de variables qui
contiennent un ensemble de valeurs.

La liste
Définition
Une liste est un ensemble d’éléments ordonnés.
Ces éléments sont placés entre deux crochets : « [ ] » et
séparés par des virgules. Pour se référer à ces éléments,
il faut recourir à leurs indices. Attention, le premier
élément d’une liste a l’indice « 0 » en Python.
Par exemple, considérons cette liste de fruits :
Fruits = ["Oranges", "Bananes", "Pommes", "Poires"]

Pour faire référence aux oranges dans cette liste, il faut

écrire « Fruits[0] ». Si vous écrivez « Fruits[1] », cela ren-
verra aux bananes.
Une liste peut contenir des éléments de tous
types. Par exemple, en voici une avec des chiffres :
­ ge_enfants = [2, 6, 10, 15].
Le contenu d’une liste peut changer à tout
moment. Ainsi, si nous voulions changer l’âge du
quatrième enfant, il faudrait utiliser l’instruction
­suivante : Âge_enfants[3] = 16.
S’il est possible de combiner des éléments de type dif-
férent dans une liste, c’est rarement une bonne pratique :
Fourre_tout = ["Annie", 3.14, "SOLEIL", 1984].

Exemple de programme
Ici, nous allons utiliser une liste publiée par le
magazine Rolling Stone des plus grandes chanteuses
de tous les temps. Nous demandons à l’utilisateur
de taper un numéro et nous lui donnons en retour
­l’artiste classée à cette position. Voici le code :

1. Chanteuses = ["Aretha Franklin", "Whitney Houston", "Billie Holiday", "Mariah Carey",

"Beyoncé"]
2. Chiffre = input("Tapez un chiffre entre 1 et 5 : ")

31
les bases de python

3. Classement = int(Chiffre) - 1
4. print("La chanteuse classée n° ", Chiffre, "est", Chanteuses[Classement])

À la ligne 1, nous donnons la liste des chanteuses

sélectionnées par Rolling Stone. À la ligne 2, nous
demandons à l’utilisateur de taper un chiffre. À la
ligne 3, nous transformons ce chiffre en entier, et lui
soustrayons 1, car le comptage commence à 0. Ainsi,
s’il tape « 2 », cela correspondrait à « Chanteuses[1] »,
et donc à Whitney Houston. À la ligne 4, nous affichons
l’artiste classée à la position correspondante.
Exécutez le code pour vérifier qu’il fonctionne.

Ajouter des éléments à une liste

Il est possible d’ajouter des éléments à la fin d’une liste
grâce à la méthode « .append() ». Par exemple, pour
ajouter les artistes classées numéros 6, 7 et 8, il faut ren-
trer les instructions suivantes :

1. [Link]("Patsy Cline")
2. [Link]("Celia Cruz")
3. [Link]("Nina Simone")

Rappelons que vous pouvez changer un élément d’une

liste à tout moment. Si par exemple, vous estimez que la
chanteuse Adele serait mieux à sa place en huitième posi-
tion, vous pouvez modifier la liste selon vos goûts en
tapant : Chanteuses[7]= "Adele".

32
 les collections d’éléments

Les tuples
Définition

Les tuples désignent des collections d’éléments qui

ne peuvent être changés. Lesdits éléments sont indi-
qués entre deux parenthèses : « ( ) ».
Pourquoi sont-ils utiles ? Parce que certaines séquences
doivent conserver une cohérence. Par exemple, les mois
de l’année seront toujours « Janvier », « Février »… De
même, les jours de la semaine ont des appellations fixes
et il paraîtrait peu approprié de remplacer « Mardi » par
« Mardredi ».
Concernant les jours de la semaine, nous devrions avoir
un tuple tel que celui-ci : Semaine = ("lundi", "mardi", "mercredi", "jeudi",
"vendredi", "samedi", "dimanche").
Pour faire référence à un élément de ce tuple, il
faut toutefois utiliser des crochets, comme pour les
listes. Ainsi, pour faire référence à mercredi, il faut
écrire : « Semaine[2] ».

Exemple de programme

Pour vous exercer, voici un petit programme

impliquant le tuple évoqué ci-dessus sur les jours de
la semaine :

1. Semaine = ("lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche")

2. Numero = input("Tapez un n° entre 1 et 7 : ")
3. Jour = int(Numero) - 1
4. print("Le jour de la semaine n° ", Numero, "est", Semaine[Jour])

Ce programme est analogue au précédent pour les

listes de chanteuses. La différence essentielle est que la
variable « Semaine » est définie comme un tuple.

33
les bases de python

Rappelons que Python est sensible à la casse. Donc,

« Jour » et « jour » sont deux variables différentes.
Si vous faites référence à « Semaine[jour] », vous
obtiendrez une erreur puisque la variable « jour » n’a pas
été définie.

Les sets
Définition
Les sets ou ensembles, définis entre deux accolades,
« { } », sont analogues aux listes mais présentent deux
différences principales :
– chaque élément est unique (on ne peut donc pas
utiliser le même élément deux fois) ;
– les sets ne sont pas ordonnés.
Voici un exemple de set : Prénoms = {"François", "Thomas", "Benjamin",
"Louise", "Alice"}.
Comme ce set n’est pas ordonné, nous ne pouvons pas
faire référence à « Benjamin » en écrivant « Prénoms[2] »,
car une telle instruction renverrait une erreur.
Si nous affichons ce set avec l’instruction
« print(Prénoms) », nous obtiendrons une collection de
noms non ordonnés : {"Alice", "Benjamin", "François", "Louise", "Thomas"}.

Exemple de programme
Pour s’entraîner, voici un exemple simple d’utilisation
de set :
1. Prénoms = {"François", "Thomas", "Benjamin", "Alice", "Thomas", "Alice"}
2. print(Prénoms)

Lorsque vous exécuterez ces deux instructions, vous

pourrez remarquer qu’« Alice » et « Thomas » ne sont
répertoriés qu’une seule fois. D’autre part, l’ordre sera
indépendant de la séquence dans laquelle vous avez tapé
les éléments.

34
 les collections d’éléments

Éliminer des doublons d’une liste

Les sets seront utiles notamment lorsque vous vou-
drez éliminer les doublons d’une liste. Vous pouvez ainsi
utiliser l’instruction « set{} » pour obtenir un set à partir
d’une liste. Voici un exemple :

1. noms = ("Alice", "Bob", "Charlie", "Alice", "Bob")

2. noms_uniques = set{noms}
3. print(noms_uniques)

Ici, nous avons au départ une liste, mais nous l’uti-

lisons pour créer un set. Les prénoms cités deux fois
(« Alice » et « Bob ») ne sont donc cités qu’une fois dans
le set « nom_uniques ».

Les méthodes associées à un set :

unions, intersections, différences…
Il existe des méthodes propres aux sets. En parti-
culier, « .union() » permet de créer un set réunissant
deux sets.
« .intersection() » fait que le set final ne contienne que
les éléments présents dans les deux sets indiqués.
Enfin, « .difference() » fait en sorte que le set final
contienne les éléments présents dans le premier set
et non dans le deuxième.

Vous pouvez tester ces opérations avec le programme

suivant :

1. noms1 = {"Alice", "Bob", "Tancrède"}

2. noms2 = {"Alice", "Danic"}
3. noms_union = [Link](noms2)
4. noms_intersection = [Link](noms2)
5. noms_uniques = [Link](noms2)
6. print(noms_union)
7. print(noms_intersection)
8. print(noms_uniques)

35
les bases de python

Les dictionnaires
Les dictionnaires ont des propriétés similaires aux sets,
mais ils sont organisés selon des paires « clé – valeur ».
Ces paires sont définies entre accolades : ­« { } ». La clé et la
valeur sont séparées par le signe « : ».

Voici un exemple pour tester les dictionnaires :

1. Dernierjour = { "janvier" : 31, "février" : 28, "mars" : 31,

2.              "avril" : 30, "mai" : 31, "juin" : 30,
3.              "juillet" : 31, "août" : 31, "septembre" : 30,
4.              "octobre" : 31, "novembre" : 30, "décembre" : 31}
5. Mois = input("Tapez le nom d'un mois : ")
6. print("Le dernier jour de ce mois est", Dernierjour[Mois])

Dans les lignes 1 à 4, nous définissons un dictionnaire où

chaque mois de l’année est associé à la valeur du dernier
jour du mois. Nous aurions pu définir le dictionnaire sur
une seule ligne, mais cette présentation sur quatre lignes
est plus lisible. À la ligne 5, nous demandons à l’utilisa-
teur de taper le nom d’un mois. Le programme affiche en
retour la valeur du dernier jour du mois correspondant.

36
 les opérateurs

Les variables booléennes

Une variable booléenne ne peut avoir que deux valeurs :
« True » (vrai) et « False » (faux). Nous aurons fortement
recours à ce type de variable à partir du chapitre suivant
mais verrons un exemple d’usage au cours de ce chapitre.

Les opérateurs

Les variables peuvent se voir appliquer des opéra-

teurs de plusieurs types.

Les opérateurs numériques

Définition
Les opérateurs applicables sur une variable numé-
rique sont les opérateurs arithmétiques de base :
– l’addition : « + » ;
– la soustraction : « – » ;
– la multiplication : « * » ;
– la division : « / ».

Voici quelques exemples : Prix = Prix * 1.10 ou Prix = Prix + 0.2.

Exemple de programme
Pour s’entraîner, voici un programme qui utilise des
opérateurs numériques pour calculer un prix déduit de
la promotion journalière :

1. Prix = 100
2. Promotion = input("Entrez le pourcentage de réduction du jour : ")
3. Taux = int(Promotion)
4. Réduction = Prix * Taux / 100
5. Prix_du_jour = Prix - Réduction
6. print("Le prix tenant compte de la réduction est : ", Prix_du_jour)

À la ligne 1, nous définissons le prix d’un produit. À la

ligne 2, nous demandons à l’utilisateur d’entrer un pour-
centage de réduction. Ce chiffre est converti en entier à
la ligne 3. La ligne 4 calcule le montant qui sera déduit
du prix et la ligne 5 applique la réduction.

37
les bases de python

Tapez ce code dans votre notebook et testez-le.

Les opérateurs sur chaîne de caractères

Plusieurs opérations sont possibles sur les chaînes
de caractères.

La concaténation
Le « + » permet de concaténer (combiner) deux ou
plusieurs chaînes de caractères. Voici un exemple :

Prénom = "Gilberto"
Nom = "Masino"
Nom_complet = Prénom + " " + Nom

Ici, dans la variable « Nom_complet », nous obtenons :

« Gilberto Masino ».

La répétition
Le « * » permet de répéter une chaîne de caractères
autant de fois que le nombre spécifié. Par exemple,
Rire = "Hi" * 3 renverrait « HiHiHi ».

Les deux opérateurs « + » et « * » peuvent également

être appliqués à des listes ou des tuples.

La comparaison de chaînes
« == » et « != » permettent de comparer deux chaînes
de caractères. « == » renvoie la valeur booléenne
« True » si les deux chaînes sont équivalentes et « False »
si elles sont différentes.

38
 les commentaires

Voici un exemple :

1. Nom1 = input("Entrez un premier nom : ")

2. Nom2 = input("Entrez un deuxième nom : ")
3. VraiFaux = Nom1 == Nom2
4. print("Ces noms sont-ils identiques ? ", VraiFaux)

Ce programme renvoie « True » ou « False » selon que

les deux noms tapés par l’utilisateur sont les mêmes ou
non. Testez-le !

Les commentaires

Le signe « # » permet d’insérer un commentaire dans

un programme. Il s’agit d’une excellente pratique car elle
facilitera la relecture du programme.

Ainsi, le dernier programme étudié pourrait être

rédigé ainsi :

1. # Demande à l'utilisateur d'entrer deux noms

2. Nom1 = input("Entrez un premier nom : ")
3. Nom2 = input("Entrez un deuxième nom : ")
4. Vrai_faux = Nom1 == Nom2 # Compare les deux noms
5. # Affiche le résultat de la comparaison
6. print("Ces noms sont-ils identiques ?", vrai_faux)

Comme vous pouvez le constater, les commentaires

peuvent être placés sur une ligne séparée ou à la suite
d’une instruction.

39
les bases de python

Vous avez toutes les bases !

Nous avons abordé énormément de choses au cours

de ce premier chapitre. Vous connaissez désormais :
– les principales variables qu’un programme Python
peut manipuler ;
– les divers opérateurs qui peuvent être appliqués sur
les variables ;
– les commentaires.

Il est important de prendre le temps de bien assimiler

ces notions car vous franchirez, au cours du prochain
chapitre, une étape majeure en abordant plusieurs
structures essentielles de la programmation. N’hésitez
pas, lorsque vous en ressentirez le besoin, à parcourir à
nouveau le présent chapitre.
 2.

Les structures essentielles

d’un programme

Ce chapitre sera l’occasion d’aborder trois notions

essentielles au codage : les fonctions, les conditions et
les boucles. Lorsque vous maîtriserez ces trois notions,
vous serez en mesure de développer de nombreux pro-
grammes en Python. Mais vous serez également armés
pour apprendre d’autres langages : en effet, ces notions
sont présentes dans chacun d’eux sous une forme ou
une autre. Elles sont donc incontournables.

Les fonctions

Comprendre les fonctions

Les fonctions sont là pour faciliter le travail du
développeur. Pour bien comprendre une fonction, il
faut penser à une recette de cuisine. Prenons comme
exemple la préparation d’une omelette aux herbes. Elle
va nécessiter :
– des ingrédients (des œufs, des herbes telles
que du persil ou du basilic, du sel, du beurre ou de
l’huile d’olive) ;
– une suite d’actions précise.
Il faudra notamment : 1. laver et découper les herbes ;
2. casser les œufs dans un bol ;
3. les mélanger ;
4. faire chauffer une poêle ;
5. ajouter de l’huile ;

41
les structures essentielles d’un programme

6. verser le mélange d’œufs ;

7. ajouter les herbes ;
8. laisser cuire quelques minutes.

Si nous avons les ingrédients requis et si nous suivons

ces instructions, nous obtiendrons toujours une ome-
lette aux herbes.
Une fonction opère sur le même principe : à partir
d’informations communiquées en entrée (l’équivalent
des ingrédients), elle accomplit une série d’étapes. À
­l’arrivée, elle génère le même résultat (l’équivalent de
l’omelette aux herbes).
Par exemple, il est possible d’imaginer une fonc-
tion dans laquelle les informations données seraient
la vitesse en kilomètres par heure d’un véhicule et un cer-
tain nombre de minutes. Elle communiquerait en sortie
la distance parcourue par ce véhicule. Une fois cette
fonction définie, il sera possible de changer la vitesse et
le temps, mais le résultat sera toujours la distance par-
courue correspondante.
Plutôt qu’écrire plusieurs fois le code qui calcule la
distance parcourue, il suffit de l’écrire une seule fois
dans une fonction. À partir de là, il sera possible de faire
appel à cette fonction autant de fois que nécessaire.

Une fonction évite au développeur d’avoir à récrire

­plusieurs fois le même code.

Définir une fonction

Pour définir une fonction en Python, il faut respecter
plusieurs règles.
Il faut d’abord utiliser le mot-clé « def », indiquer le
nom de la fonction puis, entre parenthèses, la ou les
variables en entrée. Cette ligne doit être conclue par un
deux-points « : ».
À la ligne en dessous, il faut préciser les instructions
qui seront accomplies par la fonction. Ces instructions
doivent être présentées de manière indentée (en décalé).
La dernière instruction commence par « return ».
Elle est suivie d’un ou plusieurs noms de variables.

42
 les fonctions

« Return » renvoie le résultat de l’exécution de la fonc-

tion.

Voici un exemple pour illustrer :

1. def surface_cercle(rayon) :
2. surface = rayon ** 2 * 3.1416
3. return surface

Ici nous définissons une fonction appelée « ­surface_

cercle ». Elle a en entrée une variable appelée « rayon ».
À la ligne 2, nous calculons la surface en multipliant
le carré du rayon (soit rayon à la puissance 2) par un
arrondi du nombre Pi. À la ligne 3, nous avons en sortie
la variable surface.

Lorsqu’une fonction a été définie, il est possible de

l’utiliser à volonté. Ici, « surface_cercle(1) » donnera en
sortie la valeur 3,1416. « surface_cercle(2) » donnera
12,5664 et ainsi de suite.

Pour utiliser la fonction que nous venons de définir,

voici un exemple de programme :

1. def surface_cercle(rayon) :
2. surface = rayon ** 2 * 3.1416
3. return surface
4.
5. # appel de la fonction surface_cercle
6. nombre = input("Entrez la taille d'un rayon de cercle : ")
7. monrayon = float(nombre)
8. masurface = surface_cercle(monrayon)
9. print("La surface du cercle est : ", masurface)

Nous avons volontairement laissé la ligne 4 blanche

afin de rendre la lecture du programme plus claire.
À la ligne 5, nous avons placé un commentaire. À la
ligne 6, nous invitons l’utilisateur à taper un nombre.
Ce nombre est alors converti en nombre de type flot-
tant (voir la page 30 du chapitre 1). « input() » renvoie
en effet par défaut une chaîne de caractères. Il est donc
nécessaire de la convertir en nombre. À la ligne 8, nous

43
les structures essentielles d’un programme

avons l’appel de la fonction « surface_cercle » et, à la

ligne 9, l’affichage du résultat.

Ici comme ailleurs, la meilleure façon de comprendre

la logique de Python consiste à taper ce programme et
à l’exécuter. Depuis Colab, créez un nouveau notebook
et donnez-lui un nom approprié tels que « Fonctions.
ipynb ». Tapez ensuite ce code puis exécutez-le.

Remplacer les virgules par des points

Lorsque vous exécutez le code que nous venons d’étu-
dier, si l’utilisateur a tapé un nombre avec une virgule,
Python renverra une erreur (puisqu’il gère la notation
anglo-saxonne avec des points). Une façon de contourner
ce problème consiste à utiliser la méthode « .replace() ».
Ici, il convient donc d’ajouter une ligne de code :

1. def surface_cercle(rayon) :
2. surface = rayon ** 2 * 3.1416
3. return surface
4.
5. # appel de la fonction surface_cercle
6. nombre = input("Entrez la taille d'un rayon de cercle : ")
7. nombre2 = [Link](",", ".")
8. monrayon = float(nombre2)
9. masurface = surface_cercle(monrayon)
10. print("La surface du cercle est : ", masurface)

44
 les fonctions prédéfinies

Ainsi, à la ligne 7, nous utilisons « replace() » pour

remplacer la virgule éventuellement tapée par l’utilisa-
teur par un point. La ligne 8 convertit alors cet élément
en flottant.

Les fonctions prédéfinies

La force de Python réside en partie dans l’existence

de dizaines et de dizaines de fonctions prédéfinies. En
d’autres termes : des fonctions dont vous n’avez pas besoin
d’écrire le code et qu’il suffit d’appeler.

Print, input, int…

Nous avons d’ores et déjà fait appel à des fonctions
prédéfinies – il aurait été impossible de vous présenter
les bases de Python sans en faire usage.
– « input() », qui invite l’utilisateur à taper quelque
chose ;
– « print() », qui affiche le texte spécifié à l’écran ;
– « int() », qui convertit une variable en nombre entier ;
– « float() », qui convertit une variable en nombre
flottant.

Nous avons par ailleurs utilisé plusieurs méthodes

et celles-ci sont similaires aux fonctions prédéfinies,
la différence étant qu’elles sont associées à un objet
particulier, comme « append() » qui permet d’ajouter
un élément à une liste, « upper() » qui transforme le
contenu d’une variable texte en majuscules…
Et donc oui, vous avez déjà utilisé des fonctions
prédéfinies. Nous allons ici en aborder quelques
­
autres qui peuvent être utiles, de manière courante, à
un programmeur.

45
les structures essentielles d’un programme

Quelques fonctions prédéfinies

couramment utilisées
len()
La fonction « len() » renvoie le nombre d’éléments
d’une variable : longueur d’une chaîne de caractères,
nombre d’éléments d’une liste…
En voici un exemple simple :

1. mot = input("Tapez un mot, de préférence le plus long possible : ")

2. nombre_lettres = len(mot)
3. print("Ce mot comporte ", nombre_lettres, " lettres")

Ici la fonction « len() » est utilisée à la ligne 2 afin

de calculer le nombre de lettres du mot tapé par
­l’utilisateur.
Dans votre notebook, cliquez sur « +Code » afin d’ou-
vrir un nouveau bloc de code, tapez ces instructions puis
exécutez-les.

max()
La fonction « max() » renvoie le plus grand élément
d’une liste, par exemple le nombre le plus élevé d’une
liste de nombres.
Voici un exemple d’usage de cette fonction :

1. Liste_nombres = []
2.
3. # L'utilisateur tape trois nombres
4. Nombre = input("Entrez un nombre : ")
5. Liste_nombres.append(int(Nombre))
6. Nombre = input("Entrez un autre nombre : ")
7. Liste_nombres.append(int(Nombre))
8. Nombre = input("Entrez un autre nombre : ")
9. Liste_nombres.append(int(Nombre))

46
 les fonctions prédéfinies

10. print(Liste_nombres)
11.
12. # Affichage du nombre le plus grand de la liste
13. print("Le plus grand nombre de cette liste est : ", max(Liste_nombres))

À la ligne 1 de ce programme, nous définissons une

liste (entre deux crochets). À la ligne 4, l’utilisateur est
invité à entrer un nombre. À la la ligne 5, ce nombre,
converti en entier avec « int() », est ajouté à la liste grâce
à la méthode « append() » abordée au chapitre précé-
dent. Cette séquence est répétée deux fois. À la ligne 13,
la fonction « max() » est utilisée pour obtenir le nombre
le plus grand parmi ceux que l’utilisateur a tapés.

Tapez ce programme en respectant bien les séquences

de parenthèses, puis exécutez-le.

Il existe d’autres fonctions statistiques de base qui

peuvent agir sur une liste de nombres. C’est notamment
le cas de :
– « min() », qui a l’effet inverse de « max() » et retourne
l’élément le plus petit d’une liste ;
– « sum() », qui retourne la somme d’une liste
de nombres.

47
les structures essentielles d’un programme

D’autres fonctions statistiques prédéfinies sont encore

accessibles en mettant à profit des bibliothèques
externes de fonctions prédéfinies. Nous y reviendrons
plus tard dans ce chapitre.

sorted()
La fonction « sorted() » construit une liste ­d’éléments
triés selon des critères définis, à partir d’une liste. Ces
éléments peuvent être classés par ordre de nombre, par
ordre alphabétique…
Voici un exemple d’usage de « sorted() » :
Capitales = ["Paris", "Londres"]
1. print("Voici plusieurs capitales d'Europe", Capitales)
2.
3. # L'utilisateur est invité à entrer d'autres capitales
4. Autre_capitale = input("Entrez le nom d'une autre capitale : ")
5. [Link](Autre_capitale)
6. Autre_capitale = input("Entrez le nom d'une autre capitale : ")
7. [Link](Autre_capitale)
8.
9. # Affichage de la liste des capitales
10. print("Voici la liste des capitales mise à jour : ", Capitales)
11. Capitales_triées = sorted(Capitales)
12. print("Voici la liste des capitales triées par ordre alphabétique", Capitales_triées)

Ici, nous définissons une liste avec deux capitales

d’Europe. L’utilisateur est invité à taper d’autres capi-
tales, que nous ajoutons à la liste grâce à « append() ».
À la ligne 12, nous nous servons de « sorted() » pour trier
cette liste par ordre alphabétique.

Tapez ce programme en respectant bien les séquences

de parenthèses, puis testez-le.

48
 les fonctions prédéfinies

Si nous souhaitions afficher la liste en ordre inversé,

c’est-à-dire, dans cet exemple, par ordre alphabétique de
Z à A, il faudrait ajouter le mot-clé « reverse » dans l’ins-
truction correspondante. Nous aurions donc à la ligne 12 :
Capitales_triées = sorted(Capitales, reverse).

Quelles sont les fonctions prédéfinies de Python ?

Vous savez désormais comment opèrent les fonctions
prédéfinies. Lorsque vous développez un programme, il
faut donc toujours garder à l’esprit qu’il existe peut-être
une fonction prédéfinie de Python à même de vous
­faciliter le travail et qui vous évitera d’avoir à écrire du
code superflu.

Les bibliothèques prédéfinies externes

L’une des grandes forces de Python, c’est le nombre
considérable de bibliothèques de fonctions prédéfi-
nies qui existent, et ce dans toutes sortes de domaines.
En effet, au fil des années, des milliers de programmeurs
ou de chercheurs ont développé des fonctions Python
élaborées. Il existe des bibliothèques spécifiques dans des
secteurs tels que :
– la programmation de jeux vidéo ;
– l’usage d’intelligence artificielle (IA) génératives telles
que ChatGPT ;
– l’affichage de graphiques ;
– la lecture de fichiers ;
– l’analyse de sites Web…

49
les structures essentielles d’un programme

Le sujet des bibliothèques Python est particulière-

ment vaste et nous lui consacrons un chapitre entier,
le chapitre 5.
Il est possible de raccorder une bibliothèque externe à
votre programme en utilisant « from » suivi du nom de
la bibliothèque. Ensuite, avec « import », vous pouvez
importer la fonction désirée dans le programme.

Nous allons aborder brièvement un exemple simple.

Vous aurez parfois besoin d’obtenir la racine carrée d’un
nombre. Or, il existe une bibliothèque appelée « math »,
qui comporte énormément de fonctions mathématiques,
dont « sqrt() », qui calcule la racine carrée.
Tapez le code qui suit pour voir comment cela
­fonctionne :

1. from math import sqrt

2. nombre = input("Entrez un nombre : ")
3. flottant = float(nombre)
4. racine_carrée = sqrt(flottant)
5. print("La racine carrée de ce nombre est : ", racine_carrée)

À la ligne 1, nous importons la fonction « sqrt() » de la

bibliothèque « math ». À la ligne 4, nous utilisons cette
fonction prédéfinie pour obtenir la racine carrée du
nombre tapé par l’utilisateur.

Comme vous le verrez au chapitre 5, la disponibilité

de centaines de milliers de bibliothèques de fonctions
prédéfinies (vous avez bien lu !) est un atout considé-
rable du langage Python.

50
 les conditions

Les conditions

Le test de condition est l’un des principaux mécanismes

de la programmation. Il est présent dans la grande majorité
des programmes. Le principe est simple :
– si une certaine condition est vérifiée, alors une
action précise est effectuée ;
– sinon, une autre action est accomplie – ou
pas d’action.

En réalité, dans notre existence, nous opérons sans

cesse ainsi : s’il fait beau, nous irons faire du tennis,
sinon, nous resterons à la maison pour jouer à Donjons
et Dragons. Si le supermarché a des boîtes de crème
soja à la vanille, alors nous en achèterons, sinon, nous
prendrons des compotes de pomme et noisette. Si
nous avons un rendez-vous professionnel, nous enfi-
lerons un costume, sinon, nous nous habillerons de
façon décontractée…

Abordons un exemple de la vie courante aisément

convertible en programme Python. Vous êtes dans
un centre de vacances où le repas est servi à 12 h 30.
Vous pouvez décider ce qui suit : « Si je me réveille
avant 10 heures, je prendrai un petit déjeuner. S’il est
10 heures ou plus, je prendrai juste un café ».

If else
En Python, une telle condition est exprimée avec la
clause « if » – pour le « si ». En programmation, une
clause est une partie d’une instruction de programma-
tion. L’action ou les actions accomplies sont ensuite
rédigées sur la ou les lignes suivantes. Cette première
clause est suivie de la clause « else » – pour le « sinon ».
La ou les conséquences sont là encore rédigées sur les
lignes suivantes.

La condition exprimée avec « if » se termine par le

signe « : ». Idem pour « else ». L’action accomplie en
réponse à la condition est toujours indentée.

51
les structures essentielles d’un programme

Voici le programme qui permet d’exprimer la situa-

tion proposée concernant l’heure du petit déjeuner :

1. from datetime import datetime

2.
3. # Obtient l'heure actuelle
4. date = [Link]()
5. heure = [Link]
6.
7. # Test de l'heure
8. if heure < 10:
9. print("Prendre un petit déjeuner")
10. else:
11. print("Prendre un café")

À la ligne 1, nous utilisons une bibliothèque prédé-

finie, « datetime », conçue pour aider à gérer des dates,
des jours et des heures. La fonction « [Link]() »,
indiquée en ligne 4, retourne la date et l’heure actuelle.
En ligne 5, « [Link] » retourne l’heure en cours.
Celle-ci fait alors l’objet d’un test avec le « if » en ligne 8
et le « else » en ligne 10.
Sous Colab, créez un nouveau notebook et nommez-le
« [Link] ». Tapez ensuite le code et testez-le.

52
 les conditions

If, elif et else

La plupart du temps, vous aurez affaire à plusieurs
conditions possibles.
Dans le cas que nous venons de considérer, d’autres
conditions peuvent se présenter :
– s’il est entre 12 h 30 et 14 heures, prendre un déjeuner ;
– s’il est plus de 14 heures et moins de 15 heures,
prendre un petit café ;
– s’il est plus de 15 heures, mais moins de 19 heures,
ne rien consommer ;
– s’il est entre 19 heures et 20 heures, prendre le dîner ;
– au-delà de 20 heures, ne rien consommer.
Pour exprimer une liste de condition, Python dis-
pose d’une clause appelée « elif ». Vous pouvez cumuler
autant de « elif » que désiré. La dernière clause doit être
un « else ».

Modifions le programme énoncé plus haut afin de

prendre en compte les conditions évoquées ci-dessus :

1. from datetime import datetime

2. date = [Link]()
3. heure = [Link]
4. minutes = [Link]
5. print("Il est ", heure, " H et ", minutes, " minutes" )
6.
7. # Test de l'heure
8. if heure < 10:
9. print("Prendre un petit déjeuner")
10. elif (heure < 12) or (heure == 12 and minutes < 30):
11. print("Prendre un café")
12. elif heure < 14:
13. print("Prendre le déjeuner")
14. elif heure < 15:
15. print("Prendre un petit café")
16. elif heure < 19:
17. print("Ne rien consommer")
18. elif 19 < heure_actuelle < 20:
19. print("Prendre le dîner")
20. else:
21. print("Ne rien consommer")

Ici, nous utilisons à nouveau la fonction « datetime.

now() » pour obtenir la date et l’heure du jour. De plus,

53
les structures essentielles d’un programme

nous extrayons les minutes à la ligne 4 avec la méthode

« .minute ». Nous avons ensuite la série de « if » et
de « elif ».
Le programme se déroule ainsi :
– il teste la première condition (le « if »). Si elle est
satisfaite, il exécute l’instruction correspondante et la
séquence s’achève là ;
– à défaut, il teste le premier « elif ». Là encore, si la
condition est satisfaite, il affiche l’instruction qui suit et
cela s’arrête là ;
– à défaut, il teste le « elif » suivant et ainsi de suite.
Si aucune des conditions « if » et « elif » n’est satis-
faite, il exécute l’instruction qui suit la condition « else ».
Notons que, à la ligne 10, nous utilisons le mot-clé
« or » car nous souhaitons tester deux conditions :
– l’heure est inférieure à 12 heures ;
– ou alors elle est égale à 12 heures et le nombre de
minutes est inférieur à 30 (cette fois, pour tester ces
deux conditions simultanément, nous utilisons « and »).
À la ligne 18, nous testons, là encore, deux condi-
tions simultanées sous une autre forme : « La valeur de
heure_actuelle se situe-t-elle entre 19 et 20 ? »

Testez cette nouvelle version du code. Prenez soin de

reproduire chaque ligne telle quelle est rédigée. Pensez
notamment à marquer les deux points à la fin de chaque
« if », « elif » et « else » et à indenter l’instruction qui suit
ces conditions.

Attention : si l’heure renvoyée n’est pas la bonne, cela

provient du fait que Google Colab s’exécute sur un ser-
veur distant géré par Google et que ce serveur peut se
situer dans un autre fuseau horaire. Il existe une façon
de contourner ce problème en faisant appel à une biblio-
thèque externe, pytz, mais il serait superflu de la pré-
senter ici. Ce que nous souhaitons avant tout, c’est bien
intégrer la manière dont fonctionnent les conditions
sous Python.

54
 les boucles

Test d’une variable booléenne

Pour tester une valeur booléenne, c’est-à-dire égale
à « True » ou à « False », il n’est pas nécessaire d’écrire
quelque chose comme : if condition == True :
Il vous suffit d’écrire : if condition:

Un outil indispensable
Il n’est pas nécessaire de nous appesantir davantage
sur la structure « if », « elif » et « else ». Nous aurons de
nombreuses occasions de l’aborder dans cet ouvrage.
Pour l’heure, il faut retenir qu’il s’agit d’un élément-clé
du codage et que vous rencontrerez cette structure (sous
cette forme ou sous une forme similaire) dans tous les
langages de programmation.

Les boucles

Les boucles sont une autre structure essentielle des

langages. Le principe est le suivant : une série d’ins-
tructions est exécutée plusieurs fois, aussi long-
temps qu’une condition particulière n’est pas
satisfaite.
Là encore, dans la vie courante, nous exécutons sou-
vent des boucles. Par exemple, le réveil, qui est situé à
l’autre bout d’une pièce, sonne brièvement. Il sonnera
à nouveau toutes les deux minutes jusqu’à ce que vous
l’éteigniez. Le fait de sonner toutes les deux minutes
serait l’action exécutée en boucle. Autre exemple : lors
d’une soirée, vous continuez d’ajouter de la nourriture
dans votre assiette jusqu’à ce que celle-ci soit pleine.
Ajouter de la nourriture serait la boucle. Vous pouvez
également parcourir un livre jusqu’à atteindre le cha-
pitre « x ». Tant que ce chapitre ne sera pas atteint, vous
continuerez de tourner les pages.
Qu’en est-il dans le cadre d’un programme Python ?
Imaginons que nous souhaitions afficher les chiffres de
1 à 10, suivis de leur élévation à puissance 2. Nous pour-
rions gérer un programme tel que celui-ci :

1. nombre = 1
2. puissance = nombre ** 2

55
les structures essentielles d’un programme

3. print("Le chiffre ", nombre, "à la puissance 2 est égal à ", puissance)
4. nombre = 2
5. puissance = nombre ** 2
6. print("Le chiffre ", nombre, "à la puissance 2 est égal à ", puissance)
7. nombre = 3
8. puissance = nombre ** 2
9. print("Le chiffre ", nombre, "à la puissance 2 est égal à ", puissance)
(…)
28. nombre = 10
29. puissance = nombre ** 2
30. print("Le chiffre ", nombre, "à la puissance 2 est égal à ", puissance)

Nous avons une même séquence de trois instruc-

tions dix fois de suite, de 1 à 10. Avouons-le : il est
bien fastidieux d’avoir à réécrire plusieurs fois le
même code. L’utilisation d’une boucle va simplifier
les choses.

For
La boucle « for » répète une certaine suite d’instruc-
tions un certain nombre de fois. Sa forme la plus cou-
rante est la suivante :
– « for i in range (nombre de départ, nombre d’ar-
rivée) » suivi de « : » ;
– la suite d’instructions à exécuter, présentée sous
forme indentée.
Initialement, « i » est égal au nombre de départ.
Chaque fois que les instructions sont exécutées, la
valeur de « i » est incrémentée de 1. Aussi longtemps
que « i » est inférieur au nombre d’arrivée, la séquence
est ­exécutée.

Dans le chapitre 1, nous vous avons invité à utiliser

des noms de variables explicites et, ici, nous utili-
sons « i ». Il se trouve que l’usage de « i » s’est natu-
rellement généralisé en association avec « for » et ce
dans la plupart des langages de programmation. Vous
pouvez, bien évidemment utiliser un nom explicite à la
place de « i ».

56
 les boucles

Voici un exemple dans lequel nous adaptons en boucle

« for » le programme pour afficher les chiffres de 1 à 10,
suivis de leur élévation à puissance 2 :

1. for i in range(1, 11):

2.       puissance = i ** 2
print("Le nombre ", i, "à la puissance 2 est égal à ", puissance)
3.       

Avec cette forme, notre programme tient sur seu-

lement trois lignes à la place de 30 dans l’exemple
qui précède. La valeur « i » démarre à la valeur 1. La
puissance correspondante calculée est affichée, puis
« i » devient égal à 2. Les instructions des lignes 2
et 3 sont exécutées une deuxième fois. La variable
« i » obtient à présent la valeur 3, et ainsi de suite.
L’opération se poursuit aussi longtemps que « i » n’est
pas égal à 11 – lorsque cette situation se produit, la
boucle s’arrête.

Créez un nouveau notebook, nommez-le « Boucles »,

tapez le programme, puis exécutez-le.

Avouons-le : indiquer « range(1,11) » n’est pas très

intuitif. Il pourrait sembler plus sensé d’indiquer
« range(1,10) ». Cette logique est propre à Python, dont la
numérotation démarre à 0.

57
les structures essentielles d’un programme

« For » avec une liste

Si nous utilisons une liste d’éléments avec « for », la
syntaxe est plus simple, comme dans cet exemple :

1. semaine = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]

2. for jour in semaine:
3. print(jour)

Testez cet exemple. Vous verrez qu’il affiche un à un

les sept jours de la semaine.

While
La boucle « while » fonctionne un peu différemment.
Tant qu’une certaine condition est satisfaite ou bien
n’est pas satisfaite, les instructions correspondantes
sont exécutées.
Là encore, le mieux est d’observer son fonctionne-
ment avec un exemple pratique. Un nombre aléatoire est
généré, que l’utilisateur est invité à deviner. Il doit donc
entrer un nombre. Aussi longtemps qu’il n’a pas deviné
le bon nombre, la question lui est posée.
Voici le programme qui correspond à cette situation :

1. nombre_entier = 0
2.
3. import random
4. aleatoire = [Link](1,10) # Génère un entier aléatoire entre 1 et 10
5.
6. while nombre_entier != aleatoire:
7. nombre=input("Tapez un nombre entre 1 et 10 : ")
8. nombre_entier = int(nombre)
9. print("Gagné !")

Ici, à la ligne 3 nous faisons appel à la bibliothèque

« random » pour générer un nombre aléatoire. À la
ligne 4, la fonction « randint » de « random » génère un
entier aléatoire de 1 à 10. L’utilisateur est invité à taper
un nombre. Aussi longtemps que ce nombre n’est pas
égal au nombre entier aléatoire, les instructions dépen-
dant de la boucle « while » (lignes 7 et 8) sont exécutées.
Si la réponse est bonne, la boucle s’arrête et le pro-
gramme affiche « Gagné ! ».

58
 les boucles

Là encore, tapez ce programme et testez-le.

Les autres formes de boucles

La boucle sur une seule ligne

Il existe des formes un peu différentes des boucles

« for » et « while ». À titre d’exemple, la boucle « for »
dans cet exemple tient sur une seule ligne et génère les
carrés des nombres 0 à 11.

1. carrés = [chiffre ** 2 for chiffre in range(11)]

2. print(carrés)

À la ligne 1, la liste « carrés » est composée des

nombres 0 à 10 élevés au carré, grâce à une boucle
« for » qui opère sur la variable « chiffre » depuis la
valeur 0 jusqu’à 10.

Indication d’un incrément

Dans l’exemple suivant, nous indiquons à la boucle
de s’exécuter tant que « i » est inférieur à 10, mais tout
en incrémentant « i » de 3 à chaque occurrence. Cette
séquence va donc afficher les nombres 0, 3, 6 et 9.

59
les structures essentielles d’un programme

1. for i in range (0, 10, 3):

2. print(i)

L’incrément peut aussi être négatif, comme dans

cet exemple où nous partons de 10 pour soustraire 3 à
chaque exécution de la boucle :

1. for i in range(10 , 0 , -3):

2. print(i)

Avec cet exemple, nous obtenons la suite de nombres

10, 7, 4, 1.

Il existe d’autres variantes des boucles « for » et

« while » mais vous venez de voir les principales. Nous
aurons l’occasion d’en aborder de différentes au cas par
cas au fil de l’ouvrage.

Paré pour écrire des programmes !

Sans en avoir l’air, nous avons accompli un long

chemin : si vous maîtrisez les notions exposées aux cha-
pitres 1 et 2, vous êtes déjà en mesure de coder. Bravo !
Presque tous les programmes que vous serez amené à
écrire feront appel à des fonctions prédéfinies (ou défi-
nies par vous-même), aux tests de conditions ou aux
boucles portant sur des variables.
Maintenant que les notions essentielles ont été abor-
dées, nous consacrerons la suite de cet ouvrage à mettre
en pratique vos connaissances sur des cas concrets. Cela
sera également l’occasion d’affiner certaines notions.
 3.

La gestion des erreurs

Après la rédaction d’un programme Python, vous

testez celui-ci en cliquant sur « play ». C’est là que les
ennuis peuvent commencer : régulièrement, l’IDE vous
renvoie un message d’erreur. Il est alors nécessaire de
savoir repérer l’anomalie qui s’est glissée dans votre
code. C’est précisément ce nous allons aborder dans ce
court chapitre.

Les erreurs les plus fréquentes

dans un programme Python

Votre IDE Python, qu’il s’agisse de Colab ou d’un

autre, fait de son mieux pour exécuter le programme que
vous lui soumettez. S’il bloque, c’est qu’il ne parvient pas
à analyser le code. Le plus souvent, il va s’arrêter sur des
erreurs de syntaxe : la forme d’une instruction n’est pas
conforme aux règles d’usage de Python. Il est donc inté-
ressant de bien connaître les erreurs rencontrées le plus
fréquemment pour les repérer rapidement.

Oublier les deux-points

Plusieurs structures de programmation Python, notam-
ment les conditions (« if »), les boucles (« for », « while »)
ou les définitions de fonction requièrent la présence
du signe « : » à la fin de la première ligne du bloc de
code correspondant.

61
la gestion des erreurs

Oublier l’indentation
Au sein de plusieurs structures, notamment celles citées
plus haut, le code doit être écrit avec une indentation
dès la deuxième ligne du bloc de code.

Confondre les signes « = » et « == »

Avec Python, le signe « = » sert à attribuer une valeur
à une variable. En revanche, le signe « == » sert à com-
parer deux valeurs.

Oublier les guillemets

dans les chaînes de caractères
Lorsque l’on attribue une valeur à une chaîne de carac-
tère, il est impératif qu’elle soit placée entre deux guille-
mets « " " » ou « ' ' ». À défaut, la valeur est interprétée
comme un nom de variable. Or, comme celle-ci n’a pas
été déclarée, il en résulte une erreur.
Par ailleurs, les deux guillemets doivent être de
même nature.

Oublier les parenthèses

dans l’appel d’une fonction
Lorsque l’on fait appel à une fonction, il peut arriver
que celle-ci n’attende pas d’argument (c’est le cas par
exemple de « time() », qui renvoie le temps actuel).
Toutefois, il ne faut pas oublier les ­parenthèses.

Nommer incorrectement les variables

Les noms de variables ne peuvent commencer que
par une lettre ou par un tiret bas : « _ ». D’autre part,
ils ne peuvent contenir que des lettres, des chiffres ou
le caractère « _ ». Tout autre signe renverra une erreur.
Par ailleurs, il n’est pas possible d’utiliser un mot-
clé Python tel que « if » ou « return » comme nom
­
de variable.

Combiner des contenus de types différents

Par exemple, si l’on essaye de concaténer une chaîne
de caractères et un nombre, l’IDE renvoie une erreur.

62
 les messages d’erreurs de l’ide

Oublier les crochets

lors de la manipulation d’une liste
Pour accéder aux éléments d’une liste, il faut employer
des crochets et non des parenthèses.

Les messages d’erreurs de l’IDE

Pour informer le programmeur d’une erreur, l’IDE

génère un message d’erreur dans la partie où le pro-
gramme devrait s’exécuter. Il repère par ailleurs la
ligne qui pose problème et l’indique par l’affichage
d’un signe. Dans le cas de Colab, la ligne est soulignée
avec une ondulation, comme vous pouvez le voir dans
cet exemple :

Vous pouvez repérer en premier lieu le numéro de la

ligne prise en faute grâce au soulignement. L’instruction
qui correspond est reproduite par l’IDE sous le bloc du
programme. Une flèche verticale située sous la ligne
indique l’emplacement exact de l’erreur. Le message
d’erreur lui-même apparaît plus bas (en anglais).
Dans l’exemple donné ici, l’IDE nous indique qu’il
manque le signe « : » à la fin de la huitième ligne.
Dès que la ligne est corrigée, le soulignement disparaît
et il n’y a plus qu’à relancer l’exécution.

63
la gestion des erreurs

L’aide des IA génératives

Lorsqu’un programme est très long, l’erreur peut

être difficile à repérer. Dans ce cas, le mieux consiste à
faire analyser le code Python par une intelligence arti-
ficielle (IA) générative telle que ChatGPT ou Gemini
de Google.
Pour ce faire, il est possible de taper une phrase telle
que : « Où se trouve l’erreur dans le code qui suit ? »
dans l’interface de conversation. Il vous suffit ensuite de
copier-coller votre code afin que l’IA analyse ce qui ne
fonctionne pas.
ChatGPT est particulièrement efficace dans cet exer-
cice, même en version gratuite. L’IA vous indique où
se trouve l’erreur et vous propose le code corrigé. Voici
un exemple :

Elle est conçue par ailleurs pour être didactique. En

effet, elle peut proposer d’ajouter certaines instruc-
tions ou de changer d’approche et explique chaque fois
clairement pourquoi elle suggère ces modifications.
Nous vous recommandons donc vivement de recourir à
ChatGPT pour améliorer votre codage en Python.

64
 l’aide des ia génératives

ChatGPT est accessible depuis l’adresse : [Link]

[Link] ou depuis le service Copilot de Microsoft :
[Link]
Gemini de Google est accessible à l’adresse suivante :
[Link]
 4.

Quelques programmes de base

Le temps est venu de mettre à profit l’ensemble des

éléments que vous avez étudiés jusqu’ici. Pour ce faire,
nous allons désormais réaliser quelques programmes
qui intégreront les diverses notions abordées : variables,
fonctions, méthodes, test de conditions, boucles, com-
mentaires… Nous en profiterons pour aborder diverses
notions complémentaires (et bien utiles). Comme vous
pourrez le constater au travers des exemples présentés
ici, le codage est une activité vraiment très attrayante !

Les années bissextiles

Un grand nombre de programmes Python consistent

à adapter, sous forme de programmes, des formules
mathématiques. Nous vous proposons ici de rédiger un
programme qui vous permettra de déterminer si une
année est bissextile ou non. Mathématiquement, les
règles sont les suivantes :
– l’année doit être un multiple de 4 ;
– si l’année se termine par 0 (et qu’elle est donc un
multiple de 100), elle doit aussi être un multiple de 400.
Nous allons tester ces conditions en utilisant l’opéra-
teur « % » (« modulo ») de Python qui renvoie le reste
d’une division. Par exemple, si le reste d’une division
par 4 est égal à 0, nous savons que l’année est un mul-
tiple de 4.
Dans le code qui suit, nous allons également véri-
fier que l’utilisateur tape bien un nombre pour éviter

66
 les années bissextiles

l’affichage d’un message d’erreur s’il tape des lettres ou

d’autres caractères inappropriés.

1. an = input("Tapez une année : ")

2.
3. while not [Link]():
4. print("Vous n'avez pas entré une année. Recommencez")
5. an = input("Tapez une année : ")
6. else:
7. annee = int(an)
8.
9. # le reste de la division par 4 donne zéro et l'année ne se termine par 00
10. if (annee % 4 == 0) and (annee % 100 != 0):
11. print(annee, "est une année bissextile")
12.
13. # cas d'une année se terminant par 00
14. elif (annee % 400 == 0) and (annee % 100 == 0):
15. print(annee, "est une année bissextile")
16.
17. # si aucune des deux conditions ci-dessus n'est satisfaite
18. else:
19. print(annee, "n'est pas une année bissextile")

À la ligne 3, nous utilisons une méthode propre aux

chaînes de caractères « .isdigit » afin de vérifier que l’uti-
lisateur a bien tapé des chiffres. S’il a tapé autre chose,
l’instruction « while not [Link]() » constate que « an »
n’est pas composé de chiffres et renvoie donc le booléen
« True ». Les instructions qui se trouvent aux lignes 4
et 5 sont donc exécutées jusqu’à ce que l’utilisateur tape
bien des chiffres.
Ce n’est qu’une fois que l’utilisateur a donné une
réponse valide que les instructions calculant si l’année
est bissextile sont exécutées. Voici une illustration de
l’exécution du programme :

67
quelques programmes de base

Le générateur de phrases aléatoires

Notre programme génère cinq phrases aléatoires

à partir de listes de mots.

Vous avez peut-être entendu parler du livre Cent mille

milliards de poèmes de Raymond Queneau. Dans cet
ouvrage, quatorze vers sont imprimés sur des languettes
séparées. En sélectionnant différemment ces languettes,
le lecteur peut générer des centaines de milliards de
poèmes différents.
Dans un même ordre d’idée, nous vous proposons de
programmer un générateur de phrases aléatoires basé
sur la combinaison, au hasard, de diverses parties d’une
phrase : sujets, verbes, compléments…
Voici le code de ce programme, suivi de quelques
explications.

1. import random
2. # Listes de mots
3. sujet = ["Jane", "Pilou", "Garance", "Tommy", "Jenny", "Falbala"]
4. verbe = ["éponge", "asperge", "avale", "mastique", "réchauffe", "râpe", "émiette"]
5. complément = ["du thym", "des carottes", "du gazon", "des sushis", "des cachous", "un
brocoli"]
6. conjonction = ["tandis que", "alors que", "parce que", "oubliant que", "tout en vérifiant
que"]
7. personne = ["Paul", "Ray", "Josie", "Dimitri", "Madeleine", "Anastasie"]
8. autre_verbe = ["astique", "inonde", "éclabousse", "souffle sur", "repeint"]
9. autre_complément = ["un pull", "sa guitare", "la pelouse", "la toiture", "les essuie-glaces"]
10. def generer_phrase():
11.        mot1 = [Link](sujet)
12.        mot2 = [Link](verbe)
13.        mot3 = [Link](complément)
14.        mot4 = [Link](conjonction)
15.        mot5 = [Link](personne)
16.        mot6 = [Link](autre_verbe)
17.        mot7 = [Link](autre_complément)
18.        return f"{mot1} {mot2} {mot3} {mot4} {mot5} {mot6} {mot7}"

68
 la suite de fibonacci

19. # Génère et affiche cinq phrases aléatoires

20. for i in range(5):
21.        numero = i+1
22.        print(str(numero) + ".", generer_phrase())

Au début du programme, nous importons la biblio-

thèque « random » que nous avons abordée au chapitre 2
(voir p. 58). Celle-ci génère des nombres aléatoires.
Les listes de mots sont ensuite définies. Vous pouvez,
bien évidemment, les étendre à volonté, tout en veillant à
ce que chaque verbe et chaque complément ait une logique
qui fonctionne quelle que soit la situation.
À la ligne 11, nous définissons une fonction qui ren-
voie un mot aléatoire de chaque liste définie plus haut.
Nous utilisons pour ce faire la fonction « choice » de la
bibliothèque « random ».
À la ligne 18, nous indiquons « f" » suivi de plu-
sieurs accolades. Il s’agit d’un moyen efficace de for-
mater des chaînes de caractères. « f" » signifie que
Python va insérer le contenu des variables placées entre
« { » et « } ».
La boucle qui démarre à la ligne 22 affiche alors
quatre appels de la fonction de génération de phrases
aléatoires. « Str(numéro) » convertit le numéro en
chaîne de caractères, ce qui permet de lui accoler la
chaîne « " " ».

La suite de Fibonacci

La suite de Fibonacci a été formulée en 1202 par

Léonard de Pise, également connu sous le nom de
Leonardo Fibonacci – fameux mathématicien italien.
La séquence fonctionne de sorte que chaque nombre
soit la somme des deux précédents en commençant
avec 0 et 1. Plus la suite progresse, plus le rapport entre
deux nombres successifs s’approche du nombre d’or
– noté avec la lettre grecque « φ » –, dont la valeur est
de 1,6180339887… Or, ce nombre d’or est interprété
comme une clé de l’harmonie universelle. Il se retrouve
dans certaines formes de rectangles, de triangles et

69
quelques programmes de base

d’autres figures géométriques. Il sert particulièrement

en architecture.
Nous vous proposons de créer un programme Python
qui calcule la suite de Fibonacci après avoir demandé à
l’utilisateur combien il souhaite avoir de nombres.

1. nombres = int(input("Combien de nombres souhaitez-­vous dans la suite de Fibonacci ? "))

2.
3. def fibonacci(n):
4.     a, b = 0, 1
5.    compteur = 1
6.    result at = []
7.    while compteur <= n :
8.        compteur = compteur + 1
9.        [Link](a)
10.        a, b = b, a + b
11.    return resultat
12.
13. # Générer les premiers termes de la suite de Fibonacci
14. print(fibonacci(nombres))

Dans cet exemple, nous définissons une fonction

appelée « fibonacci ». Celle-ci initialise deux entiers à 0
et à 1. Puis, de nouveaux nombres de Fibonacci sont
ajoutés à la liste résultat en fonction d’une valeur n.
La fonction est ensuite appelée avec le nombre entré
par l’utilisateur.
Comme vous pouvez le remarquer, il faut recourir
ici à deux niveaux d’indentation dans la mesure où la
boucle se situe au sein de la fonction que nous avons
définie.

Le jeu du pendu
L’heure est venue d’aborder un plus long programme
avec le jeu du pendu – qui consiste à faire deviner à un
joueur (ici à l’utilisateur) un mot, lettre après lettre.
À chaque étape, si le joueur n’a pas trouvé une lettre du

70
 le jeu du pendu

mot, le croquis de la potence évolue. Au bout de six essais

manqués, la partie est perdue.
Voici deux exemples. À droite, le joueur a gagné, à
gauche, il a perdu :

Dans ce programme, nous allons utiliser plusieurs élé-

ments que nous n’avons pas abordés jusqu’alors. Nous
les expliquerons à la suite du code que voici :
1. import random
2.
3. liste_de_mots = ['abri', 'kangourou', 'igloo', 'gingembre', 'shampoing', 'kayak']
4.
5. # Dessins ASCII pour représenter la potence
6. dessin1 = """
7.    +---+
8.     |   |
9.         |
10.         |
11.         |
12.         |
13. ========= """
14.
15. dessin2 = """
16.    +---+
17.     |   |

71
quelques programmes de base

18.     0   |
19.          |
20.          |
21.          |
22. ========= """
23.
24. dessin3 = """
25.    +---+
26.     |   |
27.     0   |
28.     |   |
29.          |
30.          |
31. ========="""
32.
33. dessin4 = """
34.    +---+
35.     |   |
36.     0   |
37. / |   |
38.          |
39.          |
40. ========= """
41.
42. dessin5 = """
43.    +---+
44.     |   |
45.     0   |
46.  / | \ |
47.          |
48.          |
49. ========="""
50.
51. dessin6 = """
52.    +---+
53.     |   |
54.     0   |
55.  / | \   |
56.   /    |
57.        |
58. ========="""
59.
60. dessin7 = """
61.    +---+
62.     |   |

72
 le jeu du pendu

63.     0   |
64.  / | \   |
65.   / \   |
66.         |
67. ========="""
68.
69. dessins = [dessin1, dessin2, dessin3, dessin4, dessin5, dessin6, dessin7]
70.
71. def jouer_pendu():
72. mot = [Link](liste_de_mots) # Sélectionne un mot aléatoire de la liste
73. lettres_trouvees = set()          # Ensemble des lettres que le joueur a devinées
74. erreurs = 0             # Nombre d’erreurs
75. lettre_joueur = ''      # Lettre tapée par le joueur
76.
77. print("JEU DU PENDU. Essayez de trouver le mot caché.")
78.
79. # Boucle principale du jeu
80. while erreurs < len(dessins) - 1:
81.       affichage = "" # Affichage des lettres que le joueur a trouvées
82.       for lettre in mot:
83.     if lettre in lettres_trouvees :
84.    affichage += lettre
85.     else :
86.    affichage += "_"
87.
88. # Si le joueur a trouvé toutes les lettres
89.   if "_" not in affichage :
90.       print("Bravo !", mot, " était le mot attendu")
91.   break
92.
93. if lettre_joueur :
94.       print(dessins[erreurs]) # Affiche la potence actuelle
95.       print("Lettres trouvées :", affichage)
96. else:
97.       print("__________________")
98.
99. # Le joueur propose une lettre
100.     lettre_joueur = input("\n\t Tapez une lettre : ").lower()
101. if lettre_joueur not in mot:
102.       print("\n\t Dommage ! ", lettre_joueur, " n'est pas dans le mot.")
103.       erreurs += 1
104. else:
105.       print("\n\t Bien joué ! La lettre", lettre_joueur, "est dans le mot.")
106.       lettres_trouvees.add(lettre_joueur)
107.
108. # Si le joueur n'a pas trouvé le mot

73
quelques programmes de base

109. if erreurs == len(dessins) - 1:

110.       print(dessins[-1]) # Affiche la potence finale
111.       print("\n\t Perdu ! Le mot était :", mot)
112.
113. jouer_pendu()

Analysons ensemble ce programme : à la ligne 3, nous

avons une liste de mots. C’est l’un de ces mots que le
joueur va devoir trouver. Vous pouvez changer cette liste
et l’étendre à volonté.
Entre les lignes 5 et 6, nous trouvons les sept états
possibles de la potence. Ici, ils sont représentés en
caractères ASCII et, plus précisément, avec des signes
tels que « + », « - », « | »… À l’ère où les jeux vidéo sont
d’une incroyable sophistication visuelle, cette représen-
tation de la potence pourra sembler primitive. Il serait
tout à fait possible de recourir à des potences en mode
graphique. Cependant, ce type d’affichage aurait rendu
le programme inutilement complexe à ce stade de notre
étude. Comme vous pouvez le remarquer, trois paires
de guillemets d’affilée (« """ ») sont utilisés pour la défi-
nition de chaque dessin. Cela permet de définir un
contenu s’étalant sur plusieurs lignes. Python comprend
que tout ce qui se trouve entre « """ » et « """ » est une
même valeur.
À la ligne 69, nous formons une liste à partir des
sept dessins représentés plus haut. Ainsi, selon le
nombre d’erreurs commises par l’utilisateur, il ne res-
tera plus qu’à afficher la potence correspondante – ce
que nous faisons à la ligne 94.
La fonction « jouer_pendu » est définie à partir de la
ligne 71.
À la ligne 72, un mot est choisi au hasard (grâce à la
fonction « random » abordée au chapitre 2 (voir p. 58).
La boucle « while », qui se trouve dans les lignes 80
à 86, constitue une variable « affichage » qui contient
les lettres que l’utilisateur a trouvées à leur bon empla-
cement. L’opérateur « += » a pour effet d’ajouter chaque
lettre trouvée à « affichage ». À défaut, « _ » est mis à la
place de la lettre non trouvée.
La condition « if » de la ligne 89 teste s’il n’y a plus
aucun « _ » dans la variable affichage. Si c’est le cas,

74
 les outils du programmeur

l’utilisateur a trouvé le mot dans son intégralité. La com-

mande « break » met alors fin à la fonction.
La séquence qui se trouve aux lignes 93 à 95 affiche la
potence dès lors que l’utilisateur a commencé à taper au
moins une lettre.
La lettre entrée par l’utilisateur (ligne 100) est placée
dans la variable « lettre_joueur ». La méthode « .lower »
veille à la transformer en minuscule. Les expressions
« \n » et « \t » ont pour effet respectif de créer un retour
à la ligne et une tabulation.
Les lignes 101 à 106 vérifient si la lettre tapée par l’uti-
lisateur figure dans le mot. Si elle n’y est pas, le comp-
teur « erreurs » est incrémenté de 1. Si elle s’y trouve,
elle est ajoutée dans la variable « lettres_trouvees » vue
précédemment.
Si le compteur d’erreurs est égal à la longueur de la
liste dessins (minorée de 1, puisque Python compte
à partir de 0), c’est que le joueur a perdu. En écrivant
« dessin[–1] », nous affichons le premier élément de
cette liste en partant de la fin, soit la potence finale.

Testez ce programme afin de voir comment il se

comporte, y compris lorsque le joueur ne trouve pas la
bonne réponse.

Les outils du programmeur

Vous avez dû le remarquer : l’essentiel des outils mis à

contribution dans ces programmes a été abordé dans les
chapitres 1 et 2. À partir des notions présentées dans ces
chapitres, vous pouvez donc aisément rédiger un grand
nombre de programmes.
Toutefois, il est possible d’étendre considérablement
le potentiel de Python. C’est ce que nous allons voir
au chapitre 5.
 5.

Les bibliothèques Python

L’une des grandes forces de Python réside dans le vaste

ensemble de bibliothèques qui y sont associées. Au fil
des années, des centaines de milliers de programmeurs
ont créé des fonctions prédéfinies qu’ils ont placées dans
des bibliothèques appropriées pour les partager avec
d’autres utilisateurs. Celles-ci sont là pour simplifier vos
programmations : lorsque vous abordez une tâche, elles
permettent de gagner du temps (et des lignes de code).

Les bibliothèques concernent tous les types de domaines.

Elles permettent notamment de :
– lire et écrire des fichiers ;
– afficher des graphismes ;
– analyser un site Web ;
– créer des personnages et décors de jeu vidéo ;
– gérer des applications d’intelligence artificielle ;
– développer des applications Web ;
– développer des applications iPhone / Android…

Dans le segment des jeux vidéo 2D par exemple, vous

pouvez faire appel à la bibliothèque « Pygame ». Celle-ci
vous proposera des fonctions pour afficher un décor,
déplacer des personnages à l’écran… Pour les connais-
seurs, le jeu Fight Time a été développé grâce à des
fonctions de « Pygame ». Il existe également des biblio-
thèques plus avancées consacrées aux jeux en 3D telles
que « Panda3D ».

76
 le site pypi

Les bibliothèques sont habituellement regroupées sur

le site PyPi ([Link]). Certaines sont accessibles depuis
des sites tels que Github, d’autres encore depuis une
adresse Web spéciale.

Le site PyPi

Dans ce chapitre, nous nous concentrerons sur le

site PyPi, qui contient plus de 530 000 « projets »
(bibliothèques) !
La première étape consistera à installer la biblio-
thèque. Or, avec PyPi, une fois cette démarche faite,
vous n’aurez plus à préciser où se trouve le code corres-
pondant. En effet, la commande « pip install » ira auto-
matiquement chercher le « package » (un ensemble de
code) correspondant dans PyPi, le téléchargera, effec-
tuera les vérifications d’usage et l’installera sur votre sys-
tème. C’est l’un des avantages considérables du site.
Sur Google Colab, il faudra indiquer « !pip install »
pour obtenir le même effet. Nous aurons donc une
séquence telle que :

!pip install pandas

import pandas

Il n’est pas toujours nécessaire d’utiliser une instruction

telle que « pip install » ou « !pip install ». En effet, certains
IDE tels que Google Colab intègrent l’usage des biblio-
thèques les plus populaires.

La bibliothèque « Pandas »

La bibliothèque « Pandas » analyse de larges volumes

de données. Sous « Pandas », les fichiers sont appelés
des « dataframes ». Retenons que les informations sont
présentées sous forme de lignes et de colonnes, à la
manière des tableaux créés avec Microsoft Excel, Google
Sheet ou Pages.

77
les bibliothèques python

Le cas du Titanic
Dans le cadre de ce chapitre, nous allons mettre à
contribution un dataframe que l’on trouve aisément sur
le Web, celui des passagers du Titanic. Les éléments de
ce dataframe sont présentés sous forme de valeurs sépa-
rées par des virgules, dans un format appelé « .csv ».
Lorsqu’un tel fichier est importé sous une interface
comme Google Sheets, les lignes apparaissent bien orga-
nisées. La toute première ligne correspond au titre de
chaque colonne.

Le fichier que nous utilisons ici est disponible à

l’adresse : [Link] Les
colonnes présentent, pour chaque passager :
– son numéro ;
– s’il a survécu au naufrage (0 s’il n’a pas survécu, 1
s’il a survécu) ;
– sa classe ;
– son nom ;
– son sexe ;
– son âge (au moment du naufrage, en 1909) ;
– son numéro de ticket ;
– le tarif de son billet ;
– son numéro de cabine ;
– son port d’embarquement.
Le fichier ne recense que 891 des 2 224 passagers que
transportait le paquebot, mais cela sera suffisant pour
nos besoins.

78
 la bibliothèque « pandas »

Notons que toutes les colonnes ne sont pas rensei-

gnées : l’âge est parfois manquant.

La liste des femmes de Queenstown

qui ont survécu
Avec « Pandas », il est aisé d’opérer des analyses sur
un tel dataframe. Par exemple, supposons que nous sou-
haitions extraire de ce fichier les données de toutes les
femmes qui ont embarqué à Queenstown et qui ont sur-
vécu. Pour chacune d’elles, nous souhaiterions afficher
le nom, la classe de son billet et son âge.
Voici un programme Python qui va nous permettre
d’afficher ces données :

1. !pip install pandas

2. import pandas as pd
3.
4. # Chargement des données depuis un fichier
5. données_titanic = pd.read_csv('[Link]
6.
7. données_titanic['Age'] = données_titanic['Age'].fillna("")
8.
9. # Passagères de Queenstown qui ont survécu
10. survivantes = données_titanic[(données_titanic['Survécu'] == 1) &
11. (données_titanic['Sexe'] == 'femme') &
12. (données_titanic['Port'] == 'Queenstown')
13. ]
14.
15. # Sélection Nom, Classe et Age
16. Lignes_affichées = survivantes[['Nom', 'Classe', 'Age']]
17.
18. # Afficher toutes les lignes des survivantes
19. print(Lignes_affichées)

Au début de ce programme, nous installons la biblio-

thèque « Pandas », puis nous l’importons sous un titre
plus court – celui de « pd ». Cette pratique est courante
dans Python : la bibliothèque est désignée par une abrévia-
tion qui aide à son usage. Ainsi, à la ligne 5, nous pouvons
utiliser l’instruction « pd.read_csv » pour lire le fichier
« [Link] », plutôt que « pandas.read_csv ».
À la ligne 7, nous prenons en compte que la colonne
« Âge » est souvent vide. Dans ce cas de figure, grâce à la

79
les bibliothèques python

méthode « fillna("") », si la valeur n’est pas renseignée,

elle est remplacée par un blanc. À défaut, « Pandas »
afficherait la valeur « NaN », ce qui produirait une liste
peu facile à lire.
Les lignes 10 à 13 permettent de filtrer le dataframe
« [Link] » afin d’en extraire les lignes répondant à
ces trois conditions :
– le passager a survécu ;
– c’était une femme ;
– elle a embarqué à Queenstown.
En une seule instruction, nous balayons ainsi la tota-
lité du dataframe afin d’en extraire les lignes qui corres-
pondent ! Telle est la souplesse de « Pandas ».
La ligne 16 crée un dataframe comportant unique-
ment les colonnes « Nom », « Classe » et « Âge » à partir
du dataframe des lignes sélectionnées préalablement
(aux lignes 10 à 13).
La dernière instruction imprime ce dataframe.

Comme à l’accoutumée, tapez ce programme dans

votre IDE et testez-le !

80
 la bibliothèque « pandas »

Le nombre de survivants
Il est également possible d’utiliser Pandas pour
obtenir des fonctions statistiques. Voici un p
­ rogramme
pour compter le nombre de survivants, par sexe et
par classe :

1. import pandas as pd
2.
3. données_titanic = pd.read_csv('[Link]
4.
5. # Grouper les données par Classe et Sexe et calculer la somme des survivants
6. nombre_de_survivants = données_titanic.groupby(['Classe', 'Sexe'])['Survécu'].sum()
7.
8. print(nombre_de_survivants)

À la ligne 6, nous utilisons une méthode de « Pandas »

appelée « groupby() », qui regroupe les données de
« [Link] » par classe et par sexe. Pour chacune de
ces catégories, nous demandons la somme de ceux qui
ont survécu.
Notons que nous n’avons pas réinstallé Pandas
avec l’instruction « !pip install pandas ». En effet, une
fois la bibliothèque installée, elle est active pour toute
la ­session.
Après exécution, le programme donne les chiffres
­suivants :

Classe Sexe
1 femme 91
homme 45
2 femme 70
homme 17
3 femme 72
homme 47
Name: Survécu, dtype: int64

Il est ainsi facile d’identifier qu’un plus grand nombre

de femmes a survécu ! La dernière ligne indique quant à
elle que les données concernent la colonne « Survécu »

81
les bibliothèques python

et sont de type « int64 » (« entier 64 bits ») – car ce pro-

gramme a été exécuté sur un ordinateur 64 bits.

Pour accéder aux fonctions d’une bibliothèque telle

que « Pandas », il est possible de se référer à la docu-
mentation accessible depuis le site [Link]
[Link]/.
Toutefois, le plus simple reste de demander à une
IA (comme ChatGPT, Gemini ou Claude) de décrire
­simplement les principales fonctions de la bibliothèque
en question.

La représentation d’informations
sous formegraphique
avec Matplotib et Seaborn

Il est également possible de représenter les données

sous une forme beaucoup plus parlante, notamment à
l’aide de graphiques. Voici un exemple concernant les
données sur lesquelles nous venons de travailler :

Ici, il apparaît nettement que le nombre de survivants

est bien plus élevé chez les femmes. Nous constatons par
ailleurs qu’un pourcentage raisonnable de passagers de

82
 la représentation d’informations sous forme

deuxième et troisième classe ont figuré parmi les sur-

vivants – même si les femmes de première classe ont
bénéficié du taux le plus élevé de sauvetage. Comme
le veut l’adage, un dessin est plus parlant qu’une suite
de nombres.
Pour obtenir ce graphique, nous avons fait appel à
deux bibliothèques propres à Python, « Matplotlib »
et « Seaborn ».

« Matplotlib » est une bibliothèque spécialisée dans

la visualisation de données sous forme graphique :
courbes, histogrammes, nuages de points, cartes…

« Seaborn » est une bibliothèque apparue plus récem-

ment, qui simplifie et améliore l’usage de « Matplotlib ».
Pour simplifier, il est possible de réaliser en une seule
ligne avec « Seaborn » ce qui prendrait une dizaine de
lignes de code sous « Matplotlib ».

Voici un programme qui met à contribution « Matplotlib »

et « Seaborn » pour afficher les données des survivants
du Titanic sous forme graphique :

1. !pip install pandas

2. !pip install seaborn
3. !pip install matplotlib
4.
5. import pandas as pd
6. import seaborn as sns
7. import [Link] as plt
8.
9. # Lectures des données de [Link]
10. données_titanic = pd.read_csv('[Link]
11.
12. # Regroupement des informations par 'Classe' et 'Sexe' et calcul de la somme des survivants
13. nombre_de_survivants = données_titanic.groupby(['Classe',
'Sexe'])['Survécu'].sum().reset_index()
14.
15. # La 3e colonne est renommée pour plus de clarté
16. nombre_de_survivants.columns = ['Classe', 'Sexe', 'Nombre de Survivants']
17.
18. # Création d'un diagramme avec Seaborn
19. [Link](x='Classe', y='Nombre de Survivants', hue='Sexe', data=nombre_de_survivants)

83
les bibliothèques python

20.
21. # Ajout des titres et des labels avec Matplotlib
22. [Link]('Nombre de Survivants du Titanic par Classe et Sexe')
23. [Link]('Classe')
24. [Link]('Nombre de Survivants')
25.
26. # Affichage de l'histogramme
27. [Link]()

Dans les lignes 1 à 7, nous installons les bibliothèques

« Pandas », « Seaborn » et « Matplotlib », puis nous les
importons, sous les noms de « pd », « sns » et « plt ».
Nous avons indiqué « [Link] » dans l’ins-
truction liée à l’importation de « Matplotlib », car cette
bibliothèque comporte de nombreux modules. « pyplot »
est celui qui aide à gérer l’affichage de graphiques.
La ligne 10 engage la lecture des données du fichier –
c’est la même instruction que celle utilisée pour les deux
programmes précédents. De même, l’instruction de la
ligne 13 a été abordée : elle permet le regroupement des
données par « Classe » et « Sexe » et calcule le nombre
de survivants. Toutefois, nous avons ajouté l’expression
« .reset_index() ». Celle-ci a pour objet de convertir les
données regroupées en colonnes. En d’autres termes,
elle crée un dataframe que pourront aisément exploiter
« Matplotlib » et « Seaborn ».
La ligne 19 contient l’instruction donnée à Seaborn de
représenter ces données sous forme d’histogramme :
– « [Link] » sert à créer un diagramme à barres ;
– « 'Classe' » est utilisé comme axe (horizontal) des
abscisses (x) et « 'Nombre de Survivants' » comme axe
(vertical) des ordonnées (y) ;
– « hue='Sexe' » permet de différencier les barres en
affichant une couleur différente selon le sexe du passage.
Les instructions des lignes 22 à 24 servent à légender
l’ensemble en ajoutant des titres au graphique et aux
deux axes.
L’instruction « [Link]() » affiche le graphique qui a
ainsi été composé.

Comme toujours, n’oubliez pas de rédiger ce pro-

gramme et de le tester.

84
 les bibliothèques, une mine de possibilités

Les bibliothèques, une mine de possibilités

Vous avez pu le constater au cours de ce chapitre, si

vous parvenez à maîtriser progressivement l’usage des
bibliothèques de Python, un monde s’ouvrira à vous !
Si vous deviez devenir expert et créer, à votre tour, des
fonctions prédéfinies, n’oubliez pas de les partager et
de proposer à « PyPi » les bibliothèques que vous aurez
pu programmer.
 6.

La distribution des programmes

Lors des chapitres précédents, nous avons utilisé

un IDE pour exécuter les programmes développés
en Python. Toutefois, si vous créez une application,
vous ne pouvez pas exiger de l’utilisateur qu’il dispose
d’un IDE tel que Colab ou Jupyter pour s’en servir.
Les programmes sont couramment diffusés sous la
forme d’un fichier portant l’extension « .exe » sous
Windows ou « .app » sur MacOS. Celui-ci va lancer
une ­installation – qui parfois crée des dossiers appro­
priés – permettant à l’utilisateur d’exécuter l’applica-
tion correspondante.

La compilation

Le processus qui consiste à convertir un script Python

en fichier exécutable fonctionnant de manière autonome
s’appelle la compilation. Le code que vous aurez écrit
sera transformé en un langage proche de celui du micro-
processeur de l’ordinateur – fort difficile à déchiffrer
pour un non-spécialiste. L’exécution du code généré par
la compilation est beaucoup plus rapide que lorsqu’on
passe par une IDE.
Dans le cas de Python, cette compilation nécessite
d’adapter votre code afin qu’il intègre les bibliothèques
externes comme « Pandas » ou « Matplotib ». Cela doit
aussi lui permettre de s’adapter à l’environnement d’ac-
cueil : Windows, MacOS, Linux… Il s’agit donc d’une
tâche relativement complexe.

86
 pyinstaller

PyInstaller

En l’an 2000, un développeur Python, Gordon MacMillan,

a entrepris d’écrire une application qui permettrait de
générer un exécutable totalement autonome, intégrant
toutes les dépendances nécessaires, depuis un script
Python. Son projet a été nommé « PyInstaller ».
D’autres développeurs ont apporté leur contribution et,
peu à peu, « PyInstaller » est devenu une application fort
efficace. Son usage vous paraîtra aisé dès lors que vous
l’aurez utilisée une ou deux fois. Nous allons donc étudier
comment mettre en œuvre « PyInstaller » sous Windows
pour le jeu du pendu, que nous avons codé à la fin du cha-
pitre 4 de ce livre (voir p. 70).

Créer un fichier « .py »

La première étape consiste à créer un fichier texte
dans lequel se trouve le code du jeu, avec l’extension
« .py ». Pour ce faire, il vous suffit de copier les lignes
de codes correspondantes dans un éditeur de texte tel
que OneNote ou Bloc-notes. Au moment d’enregistrer le
fichier, donnez-lui le nom « [Link] ».
Placez ce fichier dans un dossier de votre ordinateur.
Dans notre exemple, nous avons placé le nôtre dans un
dossier intitulé « scripts-python » à la racine du disque :

87
la distribution des programmes

Installer Python sur votre ordinateur

Jusqu’à présent, nous avons mis à profit un IDE. Pour
exploiter « PyInstaller », il faut disposer d’une copie de
­l’application Python sur votre PC ou sur votre Mac. Voici
les différentes étapes pour y parvenir.

1. Sous Windows, affichez l’« invite de commandes »

– tapez ce terme dans la zone de recherche afin de pou-
voir y accéder. Vous voyez apparaître une ligne telle que
celle-ci : C:\Users\user>.
2. Tapez simplement Python comme ceci : C:\Users\
et appuyez sur la touche « Entrée ». Depuis sa
user>python
boutique d’applications, Windows donnera alors accès
à la dernière version de Python dont il dispose.
3. Cliquez sur « Installation ». Windows va télécharger
cette application et procéder à son installation – qui
prend environ cinq minutes.
Si ce n’était pas le cas (si vous aviez par exemple une
ancienne version de Windows), il faudrait alors télé-
charger Python depuis le Microsoft Store ou bien
depuis le site [Link].

88
 pyinstaller

Exécuter PyInstaller
Une fois l’installation de Python achevée, retournez sur
l’« invite de commandes ».

1. En premier lieu, il faut créer des commandes que

nous placerons dans le dossier « scripts-python »
où se trouve le programme « [Link] ». Tapez le
code ­suivant :

C:\Users\user>CD ..
C:\User\>CD ..
C:\>CD scripts-python
C:\scripts-python>

En utilisant ainsi la commande « CD » (pour « change

directory »), nous nous plaçons dans le dossier qui com-
porte le script « [Link] ».

2. Tapez la commande « pip –version » pour vérifier

que Python est bien reconnu par le système : C:\scripts-
python>pip –version. Dans sa réponse, le système confirme
qu’il a accès à Python.

3. Il faut ensuite installer « PyInstaller » avec la com-

mande « pip install » abordée au chapitre 5 (voir p. 77).
Voici l’instruction à taper :
C:\scripts-python>python -m pip install pyinstaller.
L’option « -m » permet d’exécuter n’importe quel module
Python installé sur votre ordinateur sans avoir à indi-
quer où il se trouve exactement.

4. Une fois l’installation confirmée, vous pouvez lancer

« PyInstaller » sur le fichier « [Link] » avec cette
commande : C:\scripts-python>python -m PyInstaller --onefile [Link].
L’option « –onefile » indique à « PyInstaller » de créer
un seul fichier exécutable. Les explications figurent
plus bas.

Et voilà ! La création du programme autonome

« [Link] » a été effectuée.

89
la distribution des programmes

Les fichiers produits par PyInstaller

Consultez le dossier « scripts-python ». Comme vous
le verrez, il contient, en plus du fichier « [Link] »,
deux dossiers et un fichier « [Link] ».
Le dossier « dist » (distribution) est celui dans lequel se
trouve l’application demandée. Ce fichier peut être lancé
tel quel, ce que nous ferons très bientôt. Habituellement,
il contient certaines dépendances nécessaires à son exé-
cution. « PyInstaller » se charge de les repérer après avoir
analysé le script, puis les intègre au projet. Toutefois,
comme nous avons spécifié le paramètre « onefile », seul
l’exécutable figure dans ce dossier.
Le dossier « build » abrite des fichiers temporaires
générés lors de la création de l’application. Il n’est pas
nécessaire pour sa distribution – il sert à traquer d’éven-
tuelles erreurs.
Le fichier « .spec » est un fichier de configuration pour
l’exécutable. Il est possible d’en personnaliser le contenu :
inclusion d’images, d’une icône propre à ­l’application…
Une fois le fichier « .spec » amendé, « PyInstaller »
peut être relancé en vue de produire un exécutable plus
élaboré. Nous n’aborderons pas ce point ici.

Exécuter notre programme

Ouvrez le dossier « dist ». Vous y trouvez votre pro-
gramme tel que vous pourriez le distribuer. Cliquez
dessus et il s’exécute à l’écran !
 à vos marques…

Distribution d’applications pour mobile

Il existe également des outils de compilation adaptés
aux environnements iOS (iPhone, iPad) et Android
(comme Pybee’s BeeWare, qui est en mesure de créer
des applications fonctionnant sur ces plateformes, mais
également sous Windows ou MacOS).

À vos marques…
Il est possible que ce chapitre vous ait semblé plus
complexe que les précédents, mais il était important de
montrer que Python vous donne l’occasion de créer des
programmes complets qu’il vous sera possible de dif-
fuser et même, à terme, de vendre – si vous souhaitez
transformer votre aptitude au code en gagne-pain.
Certes, le jeu du pendu présenté ici mériterait d’être doté
d’une interface plus sophistiquée, mais cela déborderait
le cadre de ce livre d’introduction.
L’essentiel, c’est que vous ayez désormais les bases
pour devenir un programmeur, qu’il s’agisse d’un loisir

91
la distribution des programmes

ou d’un travail. Vous pourrez même, à terme, réaliser

des jeux ou des applications de niveau professionnel.
Vous l’aurez compris, Python fourmille de possibi-
lités en tous genres, ne serait-ce qu’avec ses très nom-
breuses bibliothèques externes. L’aventure ne fait que
commencer ! Il ne nous reste qu’à vous souhaiter tout le
succès possible dans votre usage de Python…