Cours de Python

July 15, 2022

destiné aux étudiants de Licence 2 Informatique LMD (Faculté des Sciences et Technologie)

1 Objectifs du cours
• comprendre la programmation comme un outil informatique incontournable
• maîtriser des concepts fondamentaux de la POO
• développer des compétences d’implémentation des programmes informatiques
• maîtriser des concepts de la POO en Python

2 Documentation
• Apprendre à programmer avec Python 3 par Gérard Swinnen

3 Outils
• Anaconda: [Link]
– Spyder
– Jupyter Notebook

4 Installation d’une librairie

• Ouvrir l’application Command Prompt
• Taper: pip install nom_de_la_librairie
• Par exemple: pip install pandas

5 Evaluation
• plusieurs travaux dirigés (généralement à la fin de chaque séance)
• une interrogation orale sous forme d’exposé
• deux travaux pratiques (un en groupe et un autre individuel)
• examen

6 Sujets d’exposé (en groupe)

1. création d’un backend en Python (comme librairie) pour la gestion de la deliberation des
étudiants

1
 2. création d’un backend en Python (comme librairie) pour la gestion de la charge horaire des
cours
3. création d’un frontend en Python pour la gestion de la deliberation des étudiants
4. création d’un frontkend en Python pour la gestion de la charge horaire des cours
5. programmation Google Pub/Sub en Python
6. gestion de collaboration de développeurs via Github
7. gestion de projets de programmation informatique
8. test and deploiement des applications web
9. environnements de test et de production des applications web
10. slack et espace de travail
11. comparaison des fournisseurs cloud
12. interaction entre BigQuery et Python
13. recherche et analyse de grande masse de données:Elastic search
14. recherche et analyse de grande masse de données: Solr
15. la technologie Splunk
16. la technologie Jenkins
17. la technologie Jira
18. XML pour interactions des systèmes
19. la technologie Kafka
20. solutions d’expérience produit et d’adoption numérique: Pendo
21. sestion de la relation client: Salesforce
22. service client: Freshdesk
23. APIs et programmation
24. chat
25. programmation mobile
26. programmation web
27. programmation desktop
28. Kubernetes
29. JSON pour interactions des systèmes
30. Technologie Docker
31. SymPy et algèbre
32. Python et C++: PyQt
33. sémantique de Python
34. SMS et Python
35. mailing et Python
36. logiciel de messagerie client: Freshchat
37. Python et html: transformer le html d’une page web en JSON
38. Python et html: transformer le html d’une page web en XML
39. visualisation 3D
40. 3FA en Python

6.1 Directives
• au plus 10 étudiants par groupe
• un rapport (d’au moins 10 pages) à rédiger structurée selon:
– introduction
∗ problématique
∗ objectifs

2
 ∗ etc.
– concepts de base
– experimentation
– conclusion
• participation de tous membres du groupe
• exposé par groupe

7 Introduction
7.1 C’est quoi Python ?
• Le langage de programmation Python a été créé en 1989 par Guido van Rossum, Pays-Bas.
• Le nom Python vient d’un hommage à la série télévisée Monty Python’s Flying Circus
dont G. van Rossum est fan.
• Sa première version officielle (version 2) a été publiée en 1991.
• La dernière version de Python est la version 3 (version 3.7 qui a été publiée en Juin 2018).
• La version 2 de Python est désormais obsolète et a cessé d’être maintenue depuis le 1er janvier
2020.
• La Python Software Foundation est l’association qui organise le développement de Python et
anime la communauté de développeurs et d’utilisateurs.

7.2 Caractéristiques
• Python est multiplateforme, c’est-à-dire qu’il fonctionne sur de nombreux systèmes
d’exploitation : Windows, Mac OS X, Linux, Android, iOS, depuis les mini-ordinateurs Rasp-
berry Pi jusqu’aux supercalculateurs.
• Il est gratuit. Il peut être installé sur autant d’ordinateurs que possible (même sur un télé-
phone!).
• C’est un langage de haut niveau. Il demande relativement peu de connaissance sur le fonc-
tionnement d’un ordinateur pour être utilisé.
• C’est un langage interprété (contrairement à des langages comme le C ou le C++).
• Il est orienté objet, c’est-à-dire qu’il est possible de concevoir en Python des entités qui miment
celles du monde réel (une cellule, une protéine, un atome, etc.) avec un certain nombre de
règles de fonctionnement et d’interactions.
• Il est relativement simple.
• Il est très utilisé en analyse de données. Toutes ces caractéristiques font que Python est
désormais enseigné dans de nombreuses formations, depuis l’enseignement secondaire jusqu’à
l’enseignement supérieur.

7.3 Python, un langage de programmation

• Un ordinateur est une machine dont la fonction principale est de traiter des données, c’est-à-
dire d’exécuter des séries d’instructions pour effectuer différentes tâches.
• Un développeur est appelé à fournir des séries d’instructions à l’ordinateur afin qu’il exécute
certaines tâches précises dans un certain ordre.

3
 • Pour cela, il va falloir que l’ordinateur puisse comprendre le langage humain. Le souci, ici,
est que les ordinateurs ne comprennent qu’un seul langage : le binaire ou “langage machine”
qui est très opaque pour les humains et très long à écrire.
• Pour pallier à ce problème, certaines personnes ont créé ce qu’on appelle des langages de
programmation.
• Le but premier de tout langage de programmation est de passer des instructions à l’ordinateur.
• Schématiquement, on utilise des langages de programmation car il est plus facile qu’un humain
puisse exprimer et expliciter des séries d’instructions en suivant des conventions d’écriture
humaines plutôt que de passer des instructions directement en binaire à l’ordinateur.
• Le langage de programmation se charge de la conversion : il reçoit des instructions et les
transforme en binaire pour les passer à l’ordinateur afin que celui-ci les exécute.
• Tous les langages de programmation ne sont pourtant pas égaux : certains sont plus facilement
compréhensibles que d’autres et certains permettent de transmettre uniquement certaines
instructions à l’ordinateur.
• Python est un langage de programmation dit de “très haut niveau”. Cela signifie qu’il possède
un haut niveau d’abstraction par rapport au langage machine.
• Pour le dire très simplement : plus un langage de programmation est de “haut niveau”, plus
sa syntaxe se rapproche du langage humain plutôt que du langage machine.
• Un langage de haut niveau est donc plus facile à comprendre et à utiliser qu’un langage de
plus bas niveau.

7.4 Python, un langage interprété

• Comment font les langages de programmation pour transformer des instructions humaines en
instructions compréhensibles par un ordinateur ? Ils leur faut un traducteur.
• Il existe deux types de traducteurs: interpreteur et compilateur.
• Pour exécuter un programme, les opérations d’analyse et de traductions sont réalisées à chaque
exécution du programme (par un interprète) ou qu’une fois pour toutes (par un compilateur).
• L’interprétation repose sur l’exécution dynamique du programme par un autre programme
(l’interpréteur), plutôt que sur sa conversion en un autre langage (par exemple le langage
machine).
• Ainsi, contrairement au compilateur, l’interpréteur exécute les instructions du programme
(ou en évalue les expressions), au fur et à mesure de leur lecture pour interprétation.
• Du fait de cette phase sans traduction préalable, l’exécution d’un programme interprété est
généralement plus lente que le même programme compilé.
• En revanche, les langages interprétés sont généralement plus simples à appréhender puisqu’on
ne passe pas par une étape de compilation avant d’exécuter son programme.
• En effet, un langage comme Python fonctionnera avec n’importe quel système d’opération
(OS) du moment que l’OS en question possède l’interpréteur Python. Un compilateur, de

4
 l’autre côté, va produire un programme écrit en langage assembleur et ce langage assem-
bleur va être différent pour chaque OS. Par conséquent, les programmes compilés ne peuvent
s’exécuter que sur des ordinateurs dotés de la même architecture que l’ordinateur sur lequel
ils ont été compilés.

7.5 Python, un langage extensible et polyvalent

• Python est modulable et extensible : une fois qu’on connait les bases du langage, on va
pouvoir relativement simplement ajouter de nouveaux modules pour étendre les possibilités
de ce langage.
• Python est un langage de programmation conçu dès le départ pour être “full stack”, c’est-à-
dire pour avoir de multiples applications à la différence du PHP, par exemple, qui a clairement
été imaginé pour fonctionner dans un contexte Web.
• Python est un langage orienté objet à la base mais il supporte également d’autres paradigmes
comme la programmation procédurale et fonctionnelle.
• Un paradigme est une “façon de coder” ou une “façon d’imaginer le code et de le structurer”.

7.6 Les versions Python

• Avant de passer à la suite, il est important de parler des différentes versions du langage Python
car, sur ce point, l’équipe de développement de Python a fait des choix particuliers.
• En informatique, les langages évoluent par “version”. Les équipes qui créent un langage
travaillent sans cesse à l’amélioration de celui-ci mais chaque changement fait sur le langage
n’est pas immédiatement intégré au langage ni disponible au public.
• Au contraire, une liste de modifications sont faites au langage en arrière plan et, dès que
l’équipe gérant l’évolution du langage juge les changements suffisamment importants et sta-
bles, une nouvelle “version” du langage qui incorpore ces changement est distribuée.
• La première grosse mise à jour de Python date de 2000 avec la version Python 2. Les versions
se sont ensuite enchainées normalement avec Python 2.1, 2.2, 2.3, etc. jusqu’en 2009 avec la
sortie de Python 3.
• Pour Python 3, l’équipe qui gère l’évolution du Python a fait le choix audacieux de partir sur
de nouvelles bases et de casser la compatibilité avec les anciennes versions.
• Généralement, lorsqu’un langage évolue et que de nouvelles versions paraissent, les équipes
de développement font bien attention à proposer une compatibilité ascendante, c’est-à-dire
à faire en sorte que les codes créés sous d’anciennes versions fonctionnent toujours avec les
nouvelles versions des langages. En effet, sans ce principe de compatibilité, la plupart des
programmes et des sites web ne fonctionneraient pas puisque les développeurs de ceux-ci
devraient absolument les modifier à chaque nouvelle version d’un langage utilisé pour coller
aux nouvelles normes.
• A l’inverse, le fait de proposer une comptabilité ascendante entre chaque version pose de
vrais problèmes d’héritage aux développeurs d’un langage puisque ces derniers sont obligés
de conserver certaines syntaxes et fonctionnalités totalement obsolètes.
• Voulant modifier en profondeur leur langage et proposer une version beaucoup plus “propre”
et au goût du jour, la Python Software Foundation (l’équipe chargée du développement du
Python) a donc décidé de faire table rase pour Python 3 et de partir sur de nouvelles bases.

5
 • Le souci ici est que Python 2.x était déjà très populaire à l’époque et que cela allait mettre de
nombreuses personnes dans l’embarras. L’équipe de Python a donc fait le choix de conserver
deux versions du langage : Python 2.x et Python 3.x et de les faire évoluer de front. Pour
être tout à fait précis, la version 3 est la version dont les fonctionnalités allaient continuer
d’évoluer tandis que la version 2 n’allait recevoir que des mises à jour liées à la sécurité.

7.7 Python est un langage Open Source

• Cela signifie que ses sources et son interpréteur sont disponibles au public et donc que
n’importe qui peut commencer à développer ses propres programmes Python gratuitement.
• Pour coder en Python, un seul programme va être strictement obligatoire : l’interpréteur
Python qui va pouvoir être utilisé de manière dynamique.

8 Plan du cours
1. Eléments de base en python
2. Concepts de la programmation orientée objet en python (P.O.O)
3. Création et déploiement des librairies
4. Création et déploiement des APIs
5. Programmation Réseaux
6. Programmation Cloud
7. Simulation et Jeux
8. Industrie logicielle
9. Applications

9 Eléments de base en python

9.1 Syntaxe de base de Python : indentation, commentaires, print() et help()
• Chaque langage informatique est basé sur une série de règles et de conventions.
• La syntaxe d’un langage définit ses différents éléments et la façon dont on va devoir les utiliser.
• Pour le moment, on décrit quatre éléments de syntaxe de base qui sont les commentaires,
l’indentation, la fonction print() et la fonction help().

9.1.1 Les commentaires

• Les commentaires sont des éléments de langage qu’on retrouve dans de nombreux langages
de programmation.
• Les commentaires servent à “commenter” le code : ils vont être ignorés lors de l’exécution du
code (ils n’auront aucun impact sur le script) et vont donc être totalement transparents pour
l’utilisateur final.
• On utilise généralement les commentaires pour documenter un code (pour soi ou pour d’autres
développeurs si le code a vocation à être distribué) ou pour empêcher son exécution. En
Python, on utilise le signe # pour écrire un commentaire dans notre code.
• Python n’a pas de syntaxe particulière pour écrire des commentaires multi-lignes. Pour écrire
un commentaire sur plusieurs lignes, on insérera un ‘#’ au début de chaque ligne.
[ ]: # un commentaire sur une ligne

6
 9.1.2 L’indentation Python
• L’indentation correspond au fait de créer des retraits au niveau de certaines lignes de code.
Dans la grande majorité des langages, l’indentation n’a qu’une visée esthétique : elle permet
à un script d’être plus lisible pour un développeur.
• Généralement, une bonne indentation est censée représenter les dépendances au sein d’un
code : on ajoutera un retrait à chaque fois qu’une instruction est incluse / dépend d’une
autre.
• En Python, l’indentation a un tout autre rôle : elle est utilisée par Python pour définir des
blocs de code, c’est-à-dire pour indiquer à l’interpréteur quelle instruction appartient à quelle
autre.
• Si on indente mal le code Python, celui-ci ne s’exécutera tout simplement pas et Python
renverra une erreur. Cela est cependant relativement évident et ne devrait pas vous poser
de problème : dès qu’il y a une relation de dépendance, il faudra ajouter un retrait (une
tabulation).

9.1.3 La fonction print()

• Les fonctions sont d’autres éléments de langage qui seront étudiés plus tard. Grosso-modo, une
fonction est définie par un nom et une série d’instructions. Lorsqu’on appelle une fonction
(en utilisant son nom et un couple de parenthèses juste derrière), elle exécute toutes les
instructions qu’elle contient. Les fonctions servent généralement à effectuer une action précise
qui peut être plus ou moins complexe.
• La fonction print() permet tout simplement d’afficher le message qu’on va lui passer comme
paramètres. La fonction print() est l’une des fonctions les plus utilisées.
• En effet, cette fonction va être très précieuse puisqu’elle va également permettre d’afficher
des résultats auxquels on n’a pas directement accès.
[ ]: print("entrez votre nom svp")

[ ]: print("entrez votre nom svp!", "Notice", sep="-")

[ ]: print("entrez votre nom svp!", end="\t")

print("notice")

9.1.4 La fonction help()

La fonction help() est utilisée pour afficher la documentation des modules, fonctions, classes,
mots-clés, etc.
[ ]: help(print)

9.2 Variables
• Une variable, dans le domaine de la programmation informatique, est un conteneur qui sert
à stocker une valeur. Les variables possèdent deux caractéristiques fondamentales :
– Les variables ont une durée de vie limitée (une variable ne vit généralement que le temps
de l’exécution d’un script ou de la fonction qui l’a définie). Ce qui signifie qu’on ne va
pas pouvoir utiliser les variables pour stocker des données de manière pérenne.

7
 – La valeur d’une variable peut varier : les variables peuvent peuvent stocker différentes
valeurs au cours de leur vie (la nouvelle valeur remplaçant l’ancienne).
– Les variables sont donc au coeur des scripts puisqu’elles vont permettre de conserver des
valeurs le temps d’un script et d’effectuer toutes sortes de manipulations sur ces valeurs
en toute simplicité.

9.2.1 Déclaration d’une variable

• Python ne possède pas de syntaxe particulière pour créer ou “déclarer” une variable : les
variables Python sont automatiquement créées au moment où on leur assigne une valeur
(déclaration implicite).
• Pour créer une variable en Python, on va donc devoir choisir un nom et affecter une valeur à
ce nom, c’est-à-dire stocker une valeur dans notre variable.
• Le choix du nom pour nos variables est libre en Python. Il faut cependant respecter les règles
usuelles suivantes :
– Le nom doit commencer par une lettre ou par un underscore.
– Le nom d’une variable ne doit contenir que des caractères alphanumériques courants
(pas d’espace dans le nom d’une variable ni de caractères spéciaux comme des caractères
accentués ou tout autre signe).
– On ne peut pas utiliser certains mots qui possèdent déjà une signification spéciale pour
le langage (on parle de mots “réservés”).
– Notez que les noms de variables en Python sont sensibles à la casse, ce qui signifie qu’on
va faire une différence entre l’emploi de majuscules et de minuscules : un même nom
écrit en majuscules ou en minuscules créera deux variables totalement différentes.
– Pour affecter ou “assigner” une valeur à une variable, on utilisera un opérateur qu’on
appelle opérateur d’affectation ou d’assignation et qui est représenté par le signe =.
Attention, le signe = ne signifie pas l’égalité.
– Le signe = ne sert pas à dire que la valeur est égale au nom de variable ou que la
variable “vaut” cette valeur, il indique simplement qu’on affecte ou qu’on stocke une
certaine valeur dans un conteneur.
[ ]: age = 19

[ ]: age

Notez déjà qu’on va également pouvoir effectuer des affectations multiples en Python, c’est-à-dire af-
fecter plusieurs valeurs à plusieurs variables très facilement en utilisant la syntaxe nom_variable_1,
nom_variable_2, nom_variable_3 = valeur1, valeur2, valeur3.
[ ]: age, poids, taille = 22, 65.7, 1.81

[ ]: age

[ ]: poids

[ ]: taille

8
 9.2.2 Type de données
• En programmation, les données qu’on va pouvoir manipuler avec un langage sont générale-
ment classées par “type”.
• Un “type” de données est défini par les manipulations qu’on va pouvoir faire sur ces données
: on va pouvoir effectuer les mêmes opérations sur chaque donnée d’un même type et des
opérations différentes sur différents types de données.
• Pour un nombre entier par exemple, il semble tout à fait logique de pouvoir effectuer des
opérations mathématiques de base avec ce nombre : addition, soustraction, multiplication,
etc. En revanche, on ne peut pas effectuer les mêmes opérations / manipulations sur un texte,
puisque multiplier un texte par quelque chose par exemple n’a pas de sens.
• Python définit de nombreux types de données qui sont : nombres entiers, décimaux, com-
plexes, chaines de caractères, booléens, listes, tuples, dictionnaires, etc.
• Dans ce cours, on va passer en revue les types de données les plus simples (nombres et
booléens). Les autres types de données feront l’objet de leçons séparées.

Les types primitifs: int, float et complex Python définit trois types de valeurs numériques
supportées : - Le type int qui représente tout entier positif ou négatif. - Le type float qui représente
les nombres décimaux et certaines expressions scientifiques comme le e pour désigner une exponen-
tielle par exemple. - Le type complex qui représente les nombres complexes ou nombres imaginaires
et qui se sert de la lettre j pour représenter la partie imaginaire d’un nombre.
• Le type de données “nombre entier” ou int (“int” = “integer” = entier) couvre tous les nombres
entiers positifs ou négatifs.
• On va pouvoir effectuer toutes sortes d’opérations arithmétiques avec ce premier type de
données : addition, soustraction, multiplication, division, élévation à la puissance, etc.
• Pour effectuer des opérations arithmétiques entre différentes valeurs numériques, ces opéra-
teurs arithmétiques sont utilisés: + pour l’addition, - pour la soustraction, etc.
• On va pouvoir effectuer ces opérations directement entre nombres et se servir de Python
comme une calculatrice ou affecter ces nombres à des variables.
• Le type de données “nombre décimal” ou float couvre tous les nombres décimaux (c’est-à-dire
les nombres à virgule) ainsi que certaines expressions scientifiques comme le e qui désigne une
exponentielle.
• Attention : dans le monde de la programmation, les notations anglo-saxonnes sont la norme.
Il faudra donc bien faire attention à utiliser un . et non une , pour les décimaux.
• Il y a différentes choses à noter par rapport au type float en Python :
– Toute opération arithmétique entre nombres de type float donne un résultat de type
float;
– Toute opération arithmétique entre nombres de types int et float donne un résultat de
type float;
– La division classique donne toujours un résultat de type float.
• None est vue comme une valeur Null dans d’autres langages de programmation.
[ ]: test = None

Le type booléen

9
 • Le type booléen est un type qui ne contient que deux valeurs qui servent à représenter deux
états. Les deux valeurs sont True (vrai) et False (faux).
• Pour stocker un booléen dans une variable, il ne faut pas utiliser de guillemets : si on les
utilise, ce seront les chaines de caractères “True” et “False” qui seront stockés et on ne va pas
pouvoir effectuer les mêmes opérations.
• Les valeurs booléennes sont très utilisées en informatique. Elles sont notamment très utiles
pour valider ou invalider un test et sont au coeur des différentes structures de contrôle en
général.
• Les premiers caractères des valeurs booléennes sont toujours en majuscules (True et False).

[ ]: b = True

[ ]: b

Nombre complexe
x + yj ∈ C où a, b ∈ R .

[ ]: a = 3 + 4j
b = 4 + 1.5j

[ ]: a + b

[ ]: a - b

[ ]: a * b

[ ]: a / b

9.3 Utiliser la fonction type() pour connaître le type d’une valeur

• On voudra souvent s’assurer qu’une variable contient bien une valeur d’un certain type,
notamment pour pouvoir effectuer différentes manipulations avec cette variable.
• Pour connaitre le type de valeur stockée dans une variable, on peut utiliser la fonction type().
On va passer la variable à tester en argument de cette fonction. La fonction type() va alors
tester la valeur contenue dans la variable et renvoyer le type de cette valeur.
[ ]: age = 19

[ ]: type(age)

[ ]: poids = 67.5

[ ]: type(poids)

10
 9.4 Les opérateurs Python
• Un opérateur est un signe ou un symbole qui va nous permettre de réaliser une opération. Le
signe = par exemple est en Python l’opérateur d’affectation simple : il permet d’affecter une
valeur à une variable.
• Python dispose de nombreux opérateurs qui peuvent être catégorisés comme suit :
– Les opérateurs arithmétiques ;
– Les opérateurs d’affectation ou d’assignation ;
– Les opérateurs de chaines ;
– Les opérateurs de comparaison ;
– Les opérateurs logiques ;
– Les opérateurs d’identité ;
– Les opérateurs d’appartenance ;
– Les opérateurs binaires.

9.4.1 Les opérateurs arithmétiques

• Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques
comme des additions, soustractions, multiplication, etc. entre différentes variables contenant
des valeurs numériques.
• Python reconnaît et accepte les opérateurs arithmétiques suivants :
• Le modulo correspond au reste d’une division Euclidienne (division entière) tandis que
l’opérateur // permet d’obtenir le résultat entier d’une division (ou la partie entière de ce
résultat pour être tout à fait exact).
• addition
[ ]: 12 + 12

• soustraction
[ ]: 34 - 12

• division
[ ]: 12 / 2

• division entière
[ ]: 12//2

• exposant
[ ]: 12**2

• multiplication
[ ]: 12*2

• modulo

11
[ ]: 12 % 3

9.4.2 Les opérateurs de comparaison

• Ils interviennent quand on compare la valeur d’une variable à une certaine autre valeur donnée.
• Voici ci-dessous les différents opérateurs de comparaison disponibles en Python ainsi que leur
signification:
• Lorsqu’on utilise un opérateur de comparaison, on demande à Python de tester si telle valeur
est supérieure, égale, inférieure ou différente à telle autre valeur. Python va donc comparer
les deux valeurs et renvoyer un booléen : True si la comparaison est vérifiée ou False dans le
cas contraire.
• Notez que les opérateurs de comparaison d’égalité et de différence testent l’égalité et la dif-
férence à la fois sur les valeurs et sur les types. Ainsi, si on demande à Python de tester
l’égalité entre la chaîne de caractères “5” et le chiffre 5, celui-ci renverra False puisque pour
lui ces deux valeurs ne sont pas égales.
[ ]:

9.4.3 Les opérateurs d’appartenance ou d’adhésion

• Python possède deux opérateurs d’appartenance qui permettent de tester si une certaine
séquence de caractères ou de valeurs est présente ou pas dans une valeur d’origine.
• Ces opérateurs ne fonctionnent qu’avec des séquences (chaines de caractères, listes, etc.) et
ne vont donc pas marcher avec des valeurs de type numérique par exemple.
• L’opérateur in permet de tester si une certaine séquence de caractères ou de valeurs est
présente dans une valeur d’origine et renvoie True si c’est le cas.
[ ]: prenoms=["jeannot","francois","antho","laureine","denise"]

[ ]: if "jeannot" in prenoms:
print("oui")

• L’opérateur not in permet au contraire de tester si une certaine séquence de caractères ou de

valeurs n’est pas présente dans une valeur d’origine et renvoie True si c’est le cas.
[ ]:

9.4.4 Les opérateurs de chaînes

• Les opérateurs de chaînes permettent de manipuler des données de type str (chaînes de
caractères) et par extension des variables stockant des données de ce type.
• Il y a deux opérateurs de chaîne : l’opérateur de concaténation + et l’opérateur de répétition
*.
• L’opérateur de concaténation va permettre de mettre bout à bout deux chaînes de caractères
afin d’en former une troisième, nouvelle.
• L’opérateur de répétition va permettre de répéter une chaîne un certain nombre de fois.

12
 • Ces deux symboles remplissent donc un rôle relativement similaire que lorsqu’ils sont utilisés
avec des données de type numériques mais attention tout de même de ne pas confondre le
+ utilisé pour additionner deux nombres et le + utilisé pour concaténer deux chaînes de
caractères : on distingue ici bien deux opérateurs différents même si le même symbole est
utilisé.
[ ]: nom = "Denise"

[ ]: prenom = "Ntumba"

[ ]: fullname =nom+" "+prenom

[ ]: fullname

9.5 Structures des données

• Jusqu’à présent, une seule valeur est stockée dans une variable. Les structures des données
représentent des données composées ou combinées.
• Structures des données: tuple, chaines de caractères, liste, dictionaires, Stack, Queue, etc.

9.5.1 Chaînes de caractères

• Les chaînes de caractères peuvent être indexées, ce qui signifie qu’on peut accéder aux car-
actères par leur position). Cela est logique après tout : les chaînes de caractères sont des
“séquences” de caractères tandis que les listes sont des “séquences” de valeurs.
• Le premier caractère d’une chaîne possède l’indice 0, le deuxième l’indice 1 et etc; On va
également pouvoir utiliser des indices négatifs et récupérer des tranches avec :
[ ]: nom = "mon prénom est Yan "

[ ]: nom[2]

• Cependant, Python n’a pas de type de données chaînes de caractères, un seul caractère est
simplement une chaîne d’une longueur de 1.
• Quelques fonctions
[ ]: [Link]()

[ ]: [Link]()

[ ]: [Link]()

• Les chaines de caractères sont ce qu’on appelle communément du texte. Pour définir une
chaine de caractères ou pour stocker une chaine de caractères dans une variable, il faudra
l’entourer de guillemets simples ou doubles droits.
[ ]: nom = "Ntumba"

[ ]: nom

13
 • Le caractère d’échappement en Python est l’antislash .
[ ]: concept = "je m\'appelle Denise"

[ ]: concept

9.5.2 Liste
• Une liste est en effet, par définition, composée d’une suite de valeur ou d’éléments.
• Pour définir une nouvelle liste en Python, on va devoir utiliser une paire de crochets [ ]. Les
différents éléments de la liste sont placés dans ces crochets en les séparant par des virgules.
On peut par exemple créer une liste de 5 éléments et la placer dans une variable liste comme
ceci :
[ ]: liste1 = [2,10,12,18,20]

[ ]: liste1

• De plus, vous devez savoir que tous les éléments d’une liste ne sont pas forcément du même
type, on va très bien pouvoir créer des listes composées de nombres, chaînes et booléens par
exemple :
[ ]: listes = [2,"Denise",True,4.5,20,2,3,5,4]

[ ]: listes

Récupérer une ou plusieurs valeurs dans une liste

• Les listes Python sont par défaut indexées ou indicées. Cela signifie que chaque valeur d’une
liste est liée à un indice qu’on va pouvoir utiliser pour récupérer cette valeur en particulier.
• Les listes possèdent des indices numériques qui commencent à 0. La première valeur d’une
liste possède donc toujours l’indice 0, la deuxième valeur l’indice 1, la troisième valeur l’indice
2, etc.
• Pour récupérer une valeur en particulier dans une liste, on va devoir préciser le nom de la liste
suivi de l’indice de cette valeur entre crochets. Notez que les indices négatifs sont acceptés;
dans ce cas on partira de la fin de la liste (l’indice -1 correspond au dernier élément, -2 à
l’avant dernier, etc.).

[ ]: listes = [2,"Denise",True,4.5,20,2,3,5,4]

[ ]: listes

[ ]: listes[1]

• On va également pouvoir récupérer une tranche de valeurs dans une liste, c’est-à-dire un
ensemble de valeurs qui se suivent. Pour cela, on utilisera le symbole : entre les crochets avec
0, 1 ou 2 indices autour.
• Si on utilise : sans indice, alors une copie superficielle de la liste sera renvoyée. Si on mentionne
un indice avant : mais pas d’indice après, alors une copie superficielle partielle de la liste de

14
 départ sera renvoyée, en commençant à copier à partir de l’indice donné. Si au contraire on
mentionne un indice après : mais pas d’indice avant, une copie superficielle partielle de la liste
de départ sera renvoyée qui commence au début de la liste et jusqu’à l’indice donné. Enfin,
si deux indice sont mentionnés de part et d’autre de :, la tranche de valeurs correspondant à
ces indices sera renvoyée.
[ ]: listes = [2,"Denise",True,4.5,20,2,3,5,4]

[ ]: listes[1:4]

Ajouter, supprimer, modifier des éléments d’une liste

• A la différence des types de données comme les chaînes qui sont immuables, les listes sont un
type de données altérable ce qui signifie qu’on va pouvoir altérer leur structure ou modifier
leur contenu en ajoutant, supprimant ou remplaçant des valeurs.
• En effet, une fois que l’on définit une valeur “chaîne de caractères” par exemple, celle-ci ne
peut plus être modifiée par la suite. Les seules opérations qu’on va pouvoir faire vont être
de créer une nouvelle chaîne en concaténant deux chaînes d’origine (qui une nouvelle fois
ne seront pas modifiées) ou de remplacer une chaine par une autre valeur en affectant une
nouvelle valeur dans une variable (ce qui a pour effet d’écraser la chaîne de départ).
• Au contraire des chaines, on peut ajouter, modifier ou supprimer des valeurs dans une liste.
Pour cela, on va mentionner le nom de notre liste avec l’indice de la ou des éléments à ajouter
/ modifier et leur affecter une nouvelle valeur. Les affectations de tranches sont possibles :

[ ]: prenoms = ["mol","francois","antho","laureine","denise"]

[ ]: prenoms[0]

[ ]: prenoms[0]="john"

[ ]: prenoms

[ ]: prenoms[:]=[]

[ ]: prenoms

9.5.3 Tuples
• Les chaînes de caractères et les listes sont deux types séquentiels de données : ce sont des
données qui sont organisées sous la forme de séquences de caractères ou de valeurs. Les tuples
sont un autre type séquentiel de données.
• Les tuples ressemblent aux listes : un tuple consiste en différentes valeurs entourées par
des virgules. Notez qu’on encadre généralement les valeurs d’un tuple avec un couple de
parenthèses même si cela n’est pas obligatoire.
• Les tuples peuvent contenir différents types de valeurs comme des nombres, des chaînes, des
listes etc. et même d’autres tuples imbriqués. Illustrons immédiatement cela :
[ ]: t1=(12,13,15)

15
[ ]: t2=(12,13,["mol","francois","antho","laureine","denise"])

[ ]: t2

• La grande différence entre un tuple et une liste est qu’un tuple est une donnée immuable à
la différence d’une liste qui est altérable. Cela signifie qu’on ne va pas pouvoir modifier les
valeurs d’un tuple après sa création.
• Il va donc être intéressant d’utiliser des tuples plutôt que des listes dans les cas où on veut
s’assurer que les données ne soient pas modifiées dans un programme.

9.5.4 Dictionnaires
• Les dictionnaires sont un type natif de données Python. Ce type de données peut, de la
même façon que les données séquentielles, contenir plusieurs valeurs et chaque valeur va être
indexée ce qui signifie qu’un indice unique va être attribué à chaque valeur.
• La grande différence entre les données séquentielles et les dictionnaires se situe dans la façon
d’indexer les valeurs et dans la nature de l’index. Dans le cas des séquences, les différentes
valeurs sont associées à des index numériques commençant à 0.
• Les dictionnaires laissent une liberté dans le choix d’index. La conséquence de cela est que
les valeurs d’un dictionnaire ne sont pas ordonnées à la différence des valeurs d’une séquence.

Création d’un dictionnaire Python

• Pour créer un nouveau dictionnaire, un couple d’accolades { } est utilisé et définir les paires
clef : valeur à l’intérieur des accolades comme ceci :
[ ]: d={"prenom":"Denise","age":23,"sport":["Escalade","Ski Nordique"]}

[ ]: d

[ ]: d["sport"]

• On utilise une nouvelle fois le syntaxe avec des crochets pour lire les différentes valeurs du
dictionnaire. Pour être tout à fait précis, on passe ici une clef entre crochets pour récupérer
la valeur qui lui est associée.

Ajout et modification de valeurs dans un dictionnaire

• Les dictionnaires sont altérables, ce qui signifie qu’on va pouvoir modifier ou ajouter des
valeurs dans un dictionnaire après sa création.
• Pour cela, on va tout simplement utiliser le nom de notre dictionnaire suivi d’un couple de
crochets [ ] en passant une clef entre ces crochets puis affecter une valeur à cette clef. Dans le
cas où la clef existe déjà, l’ensemble clef : valeur n’est pas ajouté mais la valeur originellement
liée à la clef est plutôt remplacée par la nouvelle valeur.
[ ]: d["mail"] = "dena@[Link]"

[ ]: d["telephone"]="0810568649"

16
[ ]: d

• Pour supprimer une paire clef : valeur d’un dictionnaire, nous allons utiliser l’instruction
del(abréviation de “delete” = supprimer en anglais) suivi du nom du dictionnaire avec la clef
de l’élément à supprimer entre crochets comme ceci :
[ ]: d

[ ]: del d["mail"]

[ ]: d

9.5.5 Ensemble
• Les ensembles sont utilisés pour stocker plusieurs éléments dans une seule variable.
• C’est l’un des 4 types de données intégrés à Python utilisés pour stocker des collections de
données, les 3 autres sont List, Tuple et Dictionary, tous avec des qualités et une utilisation
différentes.
• Dans un ensemble, les doublons non autorisés.
• Un ensemble est une collection non ordonnée, non modifiable et non indexée.
– Remarque : les éléments de l’ensemble ne sont pas modifiables, mais vous pouvez
supprimer des éléments et en ajouter de nouveaux.
[ ]: promotions = {"L1", "L2", "L3", "M"}
print(promotions)

[ ]: len(promotions)

• Un ensemble peut contenir différents types de données

[ ]: exemples = {True, "Mayimona", 12}

• Supprimer le premier item de l’ensemble

[ ]: [Link]()

[ ]: exemples

• Ajouter un item dans l’ensemble

[ ]: [Link](False)

[ ]: exemples

Operations
[ ]: not [Link](promotions)

17
[ ]: [Link](exemples)

[ ]: [Link](promotions)

9.5.6 Pile
• Une pile est une structure de données linéaire qui stocke les éléments de manière Last-In/First-
Out (LIFO). - Dans la pile, un nouvel élément est ajouté à une extrémité et un élément est
supprimé à cette extrémité uniquement.
• Les opérations d’insertion et de suppression sont souvent appelées push et pop.
• Les opérations associées à la pile sont :
– empty(): retourne si la pile est vide.
– size(): renvoie la taille de la pile .
– top() / peek(): renvoie une référence à l’élément le plus haut de la pile .
– push(a): insère l’élément ‘a’ en haut de la pile.
– pop(): supprime l’élément le plus haut de la pile.

Implémentation avec une liste

[ ]: pile = []

[ ]: [Link]('a')
[Link]('b')
[Link]('c')
pile

[ ]: print([Link]())
print([Link]())
print([Link]())

[ ]: print(pile)

Utilisation d’une fonction

[ ]: from collections import deque
pile_q = deque()

pile_q.append('a')
pile_q.append('b')
pile_q.append('c')

print(pile_q)

[ ]: print(pile_q.pop())
print(pile_q.pop())
print(pile_q.pop())

18
[ ]: print(pile_q)

9.5.7 File d’attente

• La file d’attente est une structure de données linéaire qui stocke les éléments de manière
premier entré, premier sorti (FIFO).
• Avec une file d’attente, l’élément ajouté le moins récemment est supprimé en premier.
• Un bon exemple de file d’attente est toute file d’attente de consommateurs pour une ressource
où le consommateur arrivé en premier est servi en premier.
• Les opérations associées à la file d’attente sont:
– Enqueue: ajoute un élément à la file d’attente. Si la file d’attente est pleine, on dit
alors qu’il s’agit d’une condition de débordement.
– Dequeue: supprime un élément de la file d’attente. Les éléments sont sautés dans le
même ordre dans lequel ils sont poussés. Si la file d’attente est vide, on dit qu’il s’agit
d’une condition de sous-dépassement.
– Front: récupère l’élément avant de la file d’attente.
– Rear: récupère le dernier élément de la file d’attente.

Implémentation avec une liste

[ ]: file = []

[ ]: [Link]('a')
[Link]('b')
[Link](1)

[ ]: print(file)

[ ]: print([Link](0))
print([Link](0))
print([Link](0))

[ ]: file

Utilisation d’une fonction

[ ]: from collections import deque
file_q = deque()

[ ]: file_q.append('a')
file_q.append('b')
file_q.append('c')

[ ]: file_q

[ ]: print(file_q.popleft())
print(file_q.popleft())

19
 print(file_q.popleft())

[ ]: file_q

9.6 La structure conditionnelle If

• Dans cette nouvelle partie, les structures de contrôle seront étudiées. Une structure de contrôle
est un ensemble d’instructions qui permet de contrôler l’exécution du code.
• Il existe différents types de structures de contrôle. Les deux types de structures les plus com-
munément utilisées sont les structures de contrôle conditionnelles qui permettent d’exécuter
un bloc de code si une certaine condition est vérifiée et les structures de contrôle de boucle
qui permettent d’exécuter un bloc de code en boucle tant qu’une condition est vérifiée.
• Les structures de contrôle conditionnelles (ou plus simplement conditions) permettent
d’exécuter différents blocs de code selon qu’une condition spécifique soit vérifiée.
• Python fournit la structure conditionnelle if avec trois arguments :
– La condition if (“si”);
– La condition if…else (“si…sinon”);
– La condition if…elif…else (“si…sinon si… sinon”).

9.6.1 L’argument if
• La structure conditionnelle if est une structure de base qu’on retourne dans de nombreux
langages de script. Cette condition permet d’exécuter un code si (et seulement si) une certaine
condition est vérifiée.
• On va en fait passer une expression à cette condition qui va être évaluée par Python. Cette
expression sera souvent une comparaison explicite (une comparaison utilisant les opérateurs
de comparaison) mais pas nécessairement.
• Si Python évalue l’expression passée à True, le code dans la condition if sera exécuté. Dans
le cas contraire, le code dans if sera ignoré.
• Par exemple,
[ ]: age=18
if (age>18):
print("tu es majeur")

• Pensez bien à indiquer le : et à bien indenter le code qui doit être exécuté si la condition est
vérifiée.

9.6.2 L’argument if… else

• L’argument if permet seulement d’exécuter un bloc de code si le résultat d’un test est évalué
à True.
• L’ajout de ;’argument else à if rend la structure if plus complète. Cette combinaison permet
d’exécuter un premier bloc de code si un test renvoie True ou un autre bloc de code dans le
cas contraire.
• La syntaxe d’une condition if…else est la suivante :

20
[ ]: age =18
if(age>18):
print("tu es majeur")
else:
print("tu es minuer")

• L’argument else prend en charge tous les cas non pris en charge par le if.

9.6.3 L’argument elif

• L’argument elif est utilisé lorsqu’il y a plusieurs conditions à vérifier.
• Python sort de la structure conditionnelle dans son ensemble sans même lire ni tester la fin
de celle-ci dès qu’un cas de réussite à été rencontré et que son code a été exécuté.

9.6.4 Utiliser les opérateurs logiques avec les conditions

• Les opérateurs logiques vont être principalement utilisés avec les conditions puisqu’ils vont
nous permettre d’écrire plusieurs comparaisons au sein d’une même condition ou encore
d’inverser la valeur logique d’un test.
• Les opérateurs logiques and et or vont nous permettre de passer plusieurs tests pour évaluation
à Python. On va par exemple pour tester si une variable x contient une valeur inférieure à 5
et / ou si y contient une valeur inférieure à 10 au sein d’une même condition.
• Dans le cas où on utilise and, chaque expression devra être évaluée à True par Python pour
que le code dans la condition soit exécuté.
[ ]: a=18

if (a>0 and a<100):

print("")
else:
print("")

9.7 Boucles
• Les boucles permettent d’exécuter plusieurs fois un bloc de code, c’est-à-dire d’exécuter un
code « en boucle » tant qu’une condition donnée est vérifiée.
• Python a deux types de boucles:
– La boucle while (“tant que…”);
– La boucle for (“pour…”).
• Le fonctionnement général des boucles sera toujours le même : on pose une condition qui sera
généralement liée à la valeur d’une variable et on exécute le code de la boucle « en boucle »
tant que la condition est vérifiée.
• Pour éviter de rester bloqué à l’infini dans une boucle, il est crucial que la condition donnée
soit fausse à un moment donné (pour pouvoir sortir de la boucle). Selon le type de condition,
on va avoir différents moyens de faire cela.
• La boucle while généralise la boucle for

21
 – avec la boucle for, le nombre maximum d’iterations est connu en amont. Ceci n’est pas
le cas pour la boucle while.

9.7.1 La boucle While

• La boucle while va nous permettre d’exécuter un certain bloc de code « tant qu’une » condition
donnée est vérifiée. Sa syntaxe est la suivante :
[ ]: x=0
while x<10:
print(x)
x+=1

• Littéralement, cette boucle signifie “tant que x stocke une valeur strictement inférieure à 10,
affiche la valeur de x puis ajoute 1 à cette valeur”.
• Note : Lorsqu’on ajoute 1 à une variable, on dit qu’on l’incrémente. À l’inverse, lorsqu’on en-
lève 1 à la valeur d’une variable, on dit qu’on la décrémente. Les opérations d’incrémentation
et de décrémentation sont très fréquentes au sein des boucles. On s’en sert généralement pour
que la condition d’exécution de la boucle soit fausse à un moment donnée.

9.7.2 La boucle For

• La boucle for possède une logique et une syntaxe différente de celles des boucles for générale-
ment rencontrées dans d’autres langages.
• En effet, la boucle for permet d’itérer sur les éléments d’une séquence (liste, chaine de carac-
tères, etc.) selon leur ordre dans la séquence.
• La condition de sortie dans cette boucle est implicite : on sortira de la boucle après avoir
parcouru le dernier élément de la séquence.
• La syntaxe de cette boucle est la suivante :
[ ]: prenoms=["mol","francois","antho","laureine","denise"]

[ ]: for i in prenoms:
print(i)

[ ]: compteurs = [len(item) for item in prenoms]

compteurs

La fonction range()
• La fonction range() est utilisée pour itérer sur une suite de nombres avec une boucle for.
• Cette fonction permet de générer une suite de valeurs à partir d’un certain nombre et jusqu’à
un autre suivant un certain pas.
• Dans son utilisation la plus simple, quand un nombre est passé en argument (entre les paren-
thèses) de range(), la fonction génèrera une suite de valeurs de 0 jusqu’à ce nombre – 1 avec
un pas de 1. range(5) par exemple génère les valeurs 0, 1, 2, 3 et 4.

[ ]: for i in range(5):
print(i)

22
 • Si on précise deux nombres en arguments de cette fonction, le premier nombre servira de
point de départ pour la génération de nombres tandis que le second servira de point d’arrivée
(en étant exclus). range(5, 10) par exemple permet de générer les nombres 5, 6, 7, 8 et 9.

[ ]: for i in range(5,10):
print(i)

• Finalement, on peut préciser un troisième argument de range() qui permet de préciser son pas,
c’est-à-dire l’écart entre deux nombres générés. Ecrire range(0, 10, 2) par exemple permet de
générer les nombres 0, 2, 4, 6 et 8.
[ ]: for i in range(0,10,3):
print(i)

Les instructions break et continue

• Les instructions break et continue sont souvent utilisées avec les boucles mais qui peuvent
être utilisées dans d’autres contextes.
• L’instruction break permet de stopper l’exécution d’une boucle lorsqu’une certaine condition
est vérifiée. On l’inclura souvent dans une condition de type if.
[ ]: for i in range(10):
if i==5:
break
print(i)

• L’instruction continue permet, elle, d’ignorer l’itération actuelle de la boucle et de passer

directement à l’itération suivante. Cette instruction permet d’ignorer toute ou partie de la
boucle dans certaines conditions.
[ ]: for i in range(10):
if i==5:
continue
print(i)

9.8 Fonction
• Une fonction est un bloc de code nommé. Une fonction correspond à un ensemble
d’instructions créées pour effectuer une tâche précise, regroupées ensemble et qui va être
exécuté autant de fois souhaité en “l’appelant” par son nom. Notez “qu’appeler” une fonc-
tion signifie exécuter les instructions qu’elle contient.
• Une fonction encapsule la complexité de code.
• Les fonctions Python peuvent être prédéfinies ou créées par l’utilisateur.

9.8.1 Les fonctions prédéfinies

• Les fonctions prédéfinies sont des fonctions déjà créées et mises à la disposition du program-
meur.
• On a déjà vu quelques fonctions prédéfinies comme la fonction print() et la fonction type().

23
 9.8.2 Les fonctions définies par l’utilisateur
• En plus des fonction prédéfinies, Python laisse au programmeur la possibilité de définir des
fonctions. Ces fonctions ne seront bien évidemment disponibles et utilisables que dans l’espace
où elles ont été définies.
• Les fonctions vont aussi être de très bons outils d’abstraction lorsqu’on voudra distribuer le
code : on préférera souvent fournir des fonctions à utiliser aux autres développeurs plutôt
que de les laisser se débrouiller avec des séries d’instructions “sauvages”.
• Pour définir une nouvelle fonction en Python, le mot clef def est utilisé, qui sert à introduire
une définition de fonction. Ce mot clef doit être suivi du nom de la fonction, d’une paire de
parenthèses au sein desquelles on pourra fournir une liste de paramètres et de : pour terminer
la ligne comme ceci def ma_fonction():.
• Le nom d’une fonction Python doit respecter les normes usuelles des noms : un nom de
fonction doit commencer par une lettre ou un underscore et ne contenir que des caractères
alphanumériques classiques (pas d’accent ni de cédille ni aucun caractère spécial).
• Notez que les noms de fonctions sont sensibles à la casse en Python. Par exemple les fonctions
ma_fonction(), Ma_fonction(), ma_FONCtion() et MA_FONCTION() sont différentes.
• Exemple d’une fonction sans paramètres
[ ]: def bonjour():
print("Bonjour")

[ ]: bonjour()

• Exemple d’une fonction avec paramètres

[ ]: def somme(x, y):
return x + y

[ ]: somme(10, 5)

• Exemple d’une fonction sans paramètres et valeurs par défaut

[ ]: def produit(x, y, z = 20):
return x*y*z

[ ]: produit(2, 1, 4)

[ ]: produit(3, 2)

[ ]: produit(z=2, x= 4, y=1)

• Il est à noter que les paramètres par défaut occupent toujours les dernières places
dans la liste des paramètres.
• On peut changer l’ordre de paramètres d’une fonction lors de l’utilisation. Dans ce cas, les
noms de paramètres doivent être specifiés

24
 9.8.3 Fonction anonyme
• Les fonctions anonymes sont utilisées lorsqu’il n’est pas nécessaire de nommer une fonction.
• Les lambda montrent leur utilité lorsque des fonctions qui prennent une autre fonction comme
argument sont utilisées. Un exemple d’une telle fonction en python pourrait être : filter(),
map() ou reduce().
• Exemple de la fonction lambda
[ ]: sum_lambda = lambda x,y : x+y

[ ]: sum_lambda(1, 2)

• Utilisation de la fonction filter dans lambda

[ ]: nombres = [1,2,3,7,0,9,30,34,32,8]
nombres_filtres = list(filter(lambda x: x > 5, nombres))
nombres_filtres

[ ]: def mon_filtre(x):
return x >5

[ ]: nombres_filtres = list(filter(mon_filtre, nombres))

nombres_filtres

9.8.4 Les fonctions de conversion

• Python possède certaines fonctions qui permettent de modifier le type de certaines données,
c’est-à-dire de les “convertir”. Ces fonctions portent le nom du type de donnée souhaitée :
– La fonction str() retourne une chaine de caractères à partir d’une donnée qu’on va lui
passer en argument;
– La fonction int() retourne un entier à partir d’un nombre ou d’une chaine contenant un
nombre qu’on va lui passer en argument;
– La fonction float() retourne un nombre décimal à partir d’un nombre ou d’une chaine
contenant un nombre qu’on va lui passer en argument;
– La fonction complex() retourne un nombre complexe à partir d’un nombre ou d’une
chaine contenant un nombre qu’on va lui passer en argument;
– La fonction bool() retourne un booléen à partir d’une donnée qu’on va lui passer en
argument;
– La fonction list() retourne une liste à partir d’une donnée itérable (une donnée dont on
peut parcourir les valeurs);
– La fonction tuple() retourne un tuple à partir d’une donnée itérable;
– La fonction dict() crée un dictionnaire à partir d’un ensemble de paires clef = “valeur”;
– La fonction set() retourne un ensemble (set) à partir d’une donnée itérable.

9.8.5 Les fonctions mathématiques

• Python possède également certaines fonctions qui permettent d’effectuer des opérations math-
ématiques, comme des calculs d’une somme ou de recherche du plus grand ou du plus petit
nombre dans une liste.

25
 • Par exemple, les fonctions round(), sum(), min() et max().
• La fonction round() permet d’arrondir un nombre spécifié en argument t à l’entier le plus
proche avec un degré de précision (un nombre de décimales) éventuellement spécifié en deux-
ième argument.
• Le nombre de décimales par défaut est 0, ce qui signifie que la fonction retournera l’entier le
plus proche.
• La fonction sum() permet de calculer une somme. On peut lui passer une liste de nombres en
arguments par exemple. On peut également lui passer une valeur “de départ” en deuxième
argument qui sera ajoutée à la somme calculée.
• La fonction max() retourne la plus grande valeur d’une donnée itérable, c’est-à-dire d’une
donnée dont on peut parcourir les différentes valeurs.
– On peut lui passer autant d’arguments qu’on souhaite comparer de valeurs. Notez qu’on
peut également comparer des chaines même si max() est peu souvent utilisée pour faire
cela.
• La fonction min(),

La librairie Math
[ ]: import math as m

[ ]: [Link](10.4)

[ ]: [Link](10.4)

[ ]: [Link](0)

[ ]: [Link](1)

La librairie Numpy
[ ]: import numpy as np
A = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

[ ]: [Link]

[ ]: [Link](axis=1)

[ ]: [Link](axis=0)

[ ]: [Link](axis=0)

[ ]: [Link](A)

Systeme d’equations lineaires



−x + y + z =1
2x−y + 3z =2


−x + 2y + 6z =4

26
 Ax = b

Solution
x = A−1 b

 
−1 1 1
A =  2 −1 3
−1 2 6
 
1
b = 2
4

[ ]: A = [Link]([[-1, 1, 1], [2, -1, 3], [-1, 2, 6]])

b = [Link]([1, 2, 10])
[Link](A, b)

9.9 Erreurs and Exceptions

Une erreur est une erreur, un acte, une affirmation ou une croyance qui s’écarte involontairement
de ce qui est correct, juste ou vrai. En Python, comme dans tout autre langage de programmation
avancé, il existe trois types d’erreurs :
• Erreurs de syntaxe (analyse)
• Erreurs logiques
• et erreurs d’exécution (exceptions).
• Une erreur de syntaxe est détectée lors de la compilation du code (c’est ce que nous appelons
communément Erreur). Ils sont surtout rencontrés par les novices comme l’indentation,
l’appel de elif sans if précédent, l’utilisation d’une variable avant sa création… Avec des
erreurs de syntaxe, le programme ne peut pas être exécuté tant qu’il n’est pas corrigé.
• L’erreur logique n’est pas détectée par le compilateur mais donne un résultat erroné. C’est
juste une question de ton cerveau, secoue-le un peu…
• Enfin, l’erreur d’exécution est ce que nous appelons Exceptions, elles sont détectées lors de
l’exécution du programme. Ouvrir un fichier inéxistant, diviser une valeur par zéro, utiliser
un index de liste hors de sa plage, convertir une liste en entier ou tout autre numérique…
Objectifs d’apprentissage
Définition des erreurs et des exceptions.
Comment corriger les erreurs et gérer les exceptions
Prévention des exceptions.
### Erreur de syntaxe
[ ]: b=11
c=b

27
 Pourquoi les codes suivants sont-ils incorrects ?
[ ]: elif b==10: print("This is true")

[ ]: a=10.
if a>5: print("greater than 5") else: print("less than 5")

Les erreurs de syntaxe sont dues à l’immaturité des programmeurs. Mais plus vous
faites d’erreurs, plus vous devenez mature. Une erreur de syntaxe ne peut pas être
gérée.

9.9.1 Erreur logique

Ce code est-il correct ?
[ ]: #Surface d'un rectangle
from math import pi
width=3.
height=2.
area=pi*width*height
print(area)

La seule façon de gérer l’erreur de logique est de vérifier votre cerveau… Sinon,
humiliez-vous et posez des questions à vos collègues.

9.9.2 Exceptions

[ ]: a=input("lire une chaine de caractere comme valeur: ")

int(a)

[ ]: print ("la valeur de d est: ", d)

[ ]: in_value=10.0
out_value=in_value/0
print (out_value)

Les types d’exceptions doivent être connus à l’avance.

Imaginez dans votre code que vous ouvriez un fichier enregistré chez vous avec un chemin complet
de votre ordinateur,
(ex. /home/jmf/Documents/python2022),
et vous donnez exactement le même code à votre ami. Le nom d’utilisateur de l’ordinateur de votre
ami n’est pas jmf comme indiqué dans le chemin, une exception se produira.

Gestion des exceptions

try:
#codes susceptibles de générer une erreur
except typeofError as var_n:

28
 #traitement d'erreur
except typeofError:
#traitement d'erreur
except:
#traitement d'erreur
finally:
#codes sans erreurs

Types des exceptions: ZeroDivisionError, ValueError, IOError, NameError, TypeError, ….

• Gérer une exception sans spécifier son type
[ ]: n=float(input("Lire un nombre decimal pour n: "))
d=float(input("Lire un nombre decimal pour d: "))
try:
q=n/d
print("Le quotient est: ", q)
except:
print ("Erreur")

• Try… Except … Finally

[ ]: n=float(input("Lire un nombre decimal pour n: "))
d=float(input("Lire un nombre decimal pour d: "))
try:
q=n/d
print("Le quotient est: ", q)
except:
print ("Erreur")
finally:
print("La fin de ce code")

• Gérer une exception en spécifiant son type

[ ]: n=float(input("Lire un nombre decimal pour n: "))
d=float(input("Lire un nombre decimal pour d: "))
try:
q=n/d
print("Le quotient est: ", q)
except ZeroDivisionError as err_name:
print(err_name)

• Mauvaise référence d’erreur

[ ]: try:
a=input("Lire une chaine de caractere comme valeur: ")
b=int(a)
print("L'entier est: ", b)
except NameError as err_name:

29
 print (err_name)

[ ]: try:
a=input("Lire une chaine de caractere comme valeur: ")
b=int(a)
print("L'entier est: ", b)
except ValueError as err_name:
print (err_name)

proposer une bonne référence

[ ]:

Exemple 1 Le code suivant peut-il déclencher une exception ? Si oui quand?

[ ]: def sumof(x):
n=len(x)
s=0
for i in range(n):
s+=x[i]
return s

[ ]: x=[2,4,7]
sumof(x)

Corrigez votre code en cas de Oui à la première question

[ ]: # votre code ici

Exemple 2 Le code suivant peut-il donner une exception ? Si oui quand?

[ ]: def powerof(x, y):
return x**y

[ ]: x=3
y=1
powerof(x, y)

Corrigez votre code en cas de Oui à la question

[ ]: # votre code ici

9.10 Visualisation
La visualisation des données améliore la communication des informations que vous souhaitez
partager de manière claire et compréhensible. La visualisation peut être textuelle, tabulaire ou
graphique. Bien qu’il y ait des gens qui l’ont dans leurs gènes, mais cette compétence (visualisa-
tion) peut être apprise, et dans la plupart du temps en pratiquant. Objectifs d’apprentissage

30
 Qu’est-ce que la visualisation des données ?
Modes de visualisation des données.
Principes de choix du type de visualisation à utiliser.
Utilisation de divers types de visualisation de données.
Utilisation de Matplotlib pour les types courants de visualisation de données.
Utilisation de Pandas pour l’analyse des données.
Utilisation de Networkx pour Graph.

9.10.1 Principes
Dans quel cas la visualisation graphique peut être plus appropriée que la visualisation
textuelle ou tabulaire ?
Choisissez une visualisation textuelle, tabulaire ou graphique :
• On veut connaître la moyenne des étudiants en L2 LMD sur les dix dernières années. Quel
type de visualisation est le plus approprié ? Pourquoi? Donnez la structure de votre sortie.
• Un autre souhaite connaître le nombre total d’étudiants en Informatique par université. Quel
type de sortie est le plus approprié ? Pourquoi?
• La visualisation n’est pas unique.
[ ]: # vos réponses

Ne faites pas ce que vous voulez, mais ce que les données exigent.

9.10.2 Visualisation textuelle

La visualisation textuelle est un ensemble de mots complet en lui-même (ou significatif), véhiculant
une information qui, dans certains cas, peut être une affirmation, une question ou une exclamation.
• Exemple
[ ]: print("Je suis Makote en L2 LMD, âgé de 20 ans.")

• structure : nom, pays, contexte

[ ]: etudiants=[["Elie","Burundi", "Physique"],
["Timothy","Zambie", "P.M"], ["Siyabonga","Afrique du Sud", "P.M"],␣
,→["Juliana","Bénin", "C.S"]]

for item in etudiants:

print (item[0], " ", item[1], " ", item[2])

** Est-ce que ça a l’air bien ? **

• Sortie formatée avec impression

31
 L’utilisation de %style peut être utile. Le style peut être une chaîne (%s), un flottant (%f), un
entier (%d). L’utilisation de % ou format aide à référencer les données à imprimer.

[ ]: for item in etudiants:

print('%s %s %s' % (item[0],item[1],item[2]))

ou
[ ]: for item in etudiants:
print('{} {} {}'.format (item[0],item[1],item[2]))

• Il est même possible de changer l’ordre d’affichage :

[ ]: for item in etudiants:
print('{2} {0} {1}'.format (item[0],item[1],item[2]))

Padding: le rend meilleur. On peut définir la longueur des différentes chaînes avec %length s.
[ ]: for item in etudiants:
print('%15s %15s %15s' % (item[0],item[1],item[2]))

[ ]: for item in etudiants:

print('%-15s %-15s %-15s' % (item[0],item[1],item[2]))

[ ]: for item in etudiants:

print('{:>15} {:>15} {:>15}'.format (item[0],item[1],item[2]))

Une idée sur l’alignement à gauche avec le format ?

• Coloriez votre texte
Pour mettre en évidence une partie de votre texte, les codes d’échappement ANSI peuvent être
utiles. Les différentes couleurs sont gérées par l’utilisation de certains codes dans la commande
print.
Text Color
Code
Text Style
Code
Background Color
Code
Black
30
Normal
0

32
 Black
40
Red
31
Bold
1
Cyan
46
Blue
34
Underline
2
Whyte
47
…
…
…
…
…
…
[ ]: print('\033[1;34;47m {:>15} {:>15} {:>15}'.format␣
,→("Name","Country","Background"))

print('\033[1;34;47m {:>15} {:>15} {:>15}'.format␣

,→("----------","----------","----------"))

for item in etudiants:

print('\033[0;31;47m {:>15} {:>15} {:>15}'.format (item[0],item[1],item[2]))

• Répétition d’un caractère spécifique soit au début soit à la fin de la chaîne en faisant :
[ ]: '{:*>10}'.format('student')

• Tronquer une information:

[ ]: '%.10s' % ('Je suis en RDC')

Question : obtenir le même résultat avec le format.

[ ]: # votre réponse

33
 • Combine padding and truncating
[ ]: '%-15.10s' % ('I am in South Africa')

• Nombres formatés
[ ]: info=[[10, 10, 12.45], [5, 11, 12.45421]]
for item in info:
print('%d %4d %.3f' % (item[0],item[1],item[2]))

• Obtenez le résultat ci-dessus avec format.

[ ]: # réponse

9.10.3 Visualisation tabulaire: Pandas

pandas is a data analysis open source library for Python.
• Visualisation tabulaire avec chaîne
[ ]: for item in etudiants:
print('%-15s %-15s %-15s' % (item[0],item[1],item[2]))

• Visualisation tabulaire avec Pandas

[ ]: #library pour pandas
import pandas as pd
#librairie pour le calcul scientifique
import numpy as np

[ ]: n = [n for n in range(1,5)]
df = [Link](etudiants, columns=["Nom", "Pays", "Background"], index=n)

[ ]: df

• Nous pouvons enregistrer le résultat dans un fichier externe tel que csv.
[ ]: df.to_csv("[Link]", sep=',', header=True)

• Analyse statistique des données tabulaires

Comme ensemble de données pour l’analyse statistique, nous utilisons : PIB par
continent. Le PIB (produit intérieur brut) est une mesure monétaire de la valeur marchande de
tous les biens et services finaux produits dans un laps de temps. Il est souvent utilisé pour estimer
la santé économique de tout un pays et aussi pour faire des comparaisons internationales.
[ ]: data=pd.read_csv('data/gapminder_gdp_africa.csv', index_col='country')
data

• Transpose les données

34
[ ]: data.T

Data information and descrption

• [Link]() pour en savoir plus sur une dataframe.

[ ]: [Link]()

• [Link]() obtient les statistiques récapitulatives des seules colonnes contenant

des données numériques. Toutes les autres colonnes sont ignorées.
[ ]: [Link]()

• [Link] la variable stocke des informations sur les colonnes du dataframe.

[ ]: [Link]

[ ]: # select values by numerical index

print([Link][0,0])

[ ]: # select values by name

print([Link]['South Africa','gdpPercap_2007'])

[ ]: # get all columns or all rows for a particular value

[Link]["South Africa", :]

[ ]: print([Link][:,'gdpPercap_2007'])

• Puisqu’il s’agit d’une colonne, vous pouvez obtenir le même résultat avec
[ ]: data["gdpPercap_2007"]

[ ]: data.gdpPercap_2007

• Sélectionnez plusieurs colonnes ou lignes à l’aide de [Link] et d’une tranche nommée

[ ]: [Link]["Angola":"Egypt", "gdpPercap_1962":"gdpPercap_1972"]

Question : Obtenez le résultat ci-dessus mais avec [Link]

[ ]: # votre réponse

[ ]: [Link]["Angola":"Egypt", "gdpPercap_1962":"gdpPercap_1972"].max()

[ ]: [Link]["Angola":"Egypt", "gdpPercap_1962":"gdpPercap_1972"].min()

• Sélectionner les données en fonction de la valeur (comparaison)

35
[ ]: [Link]()

[ ]: [Link]()

[ ]: subset=[Link]["Angola":"Egypt", "gdpPercap_1962":"gdpPercap_1972"]
subset

[ ]: # Which values are greater than 2000?

subset>2000

• Sélectionnez des valeurs ou NaN à l’aide d’un masque booléen

[ ]: mask=subset>2000
filtered_subset=subset[mask]
filtered_subset

• Remplacer une valeur par Pandas

[ ]: filtered_subset.replace(to_replace=[Link], value=0)

9.10.4 Visualisation graphique

En général, les graphiques montrent la distribution sous-jacente des données, la fréquence des
occurrences des valeurs, la corrélation entre les variables ou le résumé d’une grande quantité de
données.

Matplot Matplotlib est une bibliothèque Python qui dessine des figures en 2D et 3D.
[ ]: # Python library for plotting
import [Link] as plt
# %matplotlib inline

[ ]: #list of ages
age=[18, 20, 24, 19, 17]
#plot of list
[Link](age)
#setting of y label
[Link]('Ages')
#showing figure
[Link]()

• Afficher le vecteur Âges contre vecteur Pourcentages : les deux listes doivent avoir la même
taille.
[ ]: percentages=[60, 80, 90, 95, 98]

[Link](percentages, age)
[Link]('Percentages')

36
 [Link]('Ages')
[Link]()

Axe de la figure : une idée de la raison pour laquelle le code suivant n’affiche pas le graphique ?
Corrigez-le le cas échéant.
[ ]: [Link](percentages, age, 'bo')
[Link]([10, 25, 50, 100])
[Link]()

• Dans le paramètre bo, b définit la couleur du graphique (b=bleu) et o le type de point.

• Labels, title, text, axis, figure size and grid
[ ]: [Link](figsize=(10,8))
[Link]('number of students')
[Link]('countries ID')
[Link]('Histogram of Frequency')
[Link](3, 30, 'Comment')
[Link]([0, 10, 1, 54])
[Link](True)
[Link]()

Disable axis and enable legend

[ ]: [Link]([1,2,3])
[Link]([1,1,1],[3,2,1])
[Link]('off') #disable axis
[Link](["Line 1", "Line 2"])
[Link]()

Define legend location

[ ]: [Link]([1,2,3])
[Link]([1,1,1],[3,2,1])
[Link]('off') #disable axis
[Link](["Line 1", "Line 2"], loc=3)
[Link]()

Latex in Matplotlib:
** r’$latex command$’ **
[ ]: [Link]('number of students ('r'$\delta$)')
[Link]('countries ID ('r'$\mu$)')
[Link]('Histogram of Frequency')
[Link](3, 30, r'$\mu=54,\ \delta=56$')
[Link]([0, 10, 1, 54])
[Link](True)
[Link]()

37
 Multi subfigures
[ ]: import numpy as np
data=[x for x in [Link](1., 20., .75)]
squareddata=[Link](data, 2)
cubeddata=[Link](data, 3)

[Link](data, data, 'b*', data, squareddata, 'r--', data, cubeddata, 'g^')

[Link]()

Subfigures dans une figure

La fonction subplot(nrows, ncols, plot_number) définit les sous-figures dans une figure. Ses
paramètres nrows et ncols sont utilisés pour diviser la figure en nrows * ncols sous-axes, et
plot_number est utilisé pour identifier la sous-parcelle particulière dans la grille.
[ ]: [Link](2, 2, 1)
[Link](2, 2, 2)
[Link](2, 2, 3)
[Link](224)
[Link]()

Que se passera-t-il avec le code suivant ? Explication…

[ ]: [Link](2, 2, 5)

Pourquoi les première et deuxième sous-parcelles ne sont-elles pas affichées ? Com-

ment les réparer ?
[ ]: def f(x):
return [Link](-x) * [Link](2*[Link]*x)

[ ]: xdata = [Link](0.0, 5.0, 0.1)

ydata= [Link](0.0, 5.0, 0.02)

[Link](211)
[Link](xdata, f(xdata), 'bo', ydata, f(ydata), 'k')

[Link](222)
[Link](ydata, [Link](2*[Link]*ydata), 'r--')

[Link](233)
[Link](xdata, [Link](2*[Link]*xdata), 'ro')
[Link]()

Scatter: tente de montrer la corrélation entre les variables ou de comparer un grand nombre de
points de données.

38
[ ]: points=[Link](0, 2, (1000,2))
[Link]('x')
[Link]('y')
[Link](points[:,0], points[:,1],
marker=',', edgecolor='r', s=3)
[Link]()

Histogram: est utilisé pour tracer la fréquence des occurrences dans une donnée continue qui a
été en classes (bins). Cela peut aider à percevoir la distribution sous-jacente des données.

[ ]: x =120 + 22 * [Link](200)
n, bins, patches =[Link](x, bins=20, facecolor='r')
[Link]('Interval')
[Link]('Frequency')
[Link]('Histogram')
[Link]([40, 160, 0, 30])
[Link](True)
[Link]()

[ ]: n

[ ]: bins

Histogram avec plusieurs jeux de données

[ ]: y = 130 + 15*[Link](300)
n, bins, patches = [Link]([x, y])
[Link]()

Bar Chart: est utilisé pour montrer la fréquence des occurrences dans les variables ordinales et
nominales.
[ ]: countries = ('RSA', 'Benin', 'Botwana', 'Zambia', 'Burundi', 'Algeria',␣
,→'Swaziland', 'Ghana', 'Egypt', 'Madagascar')

y_pos = [Link](len(countries))
effectives = [2,1,3,2,2,2, 2, 2, 2, 5]

[ ]: [Link](y_pos, effectives, align='center', alpha=0.5)

[Link](y_pos, countries, rotation='vertical')
[Link]('Effective')
[Link]('AIMS Students')
[Link]()

Boxplot: Il affiche le résumé des chiffres statistiques des données ou la distribution des données
en fonction de : minimum, premier quartile, médiane, troisième quartile et maximum.
[ ]: data=[Link](10, 2)
data

39
[ ]: [Link](data)
[Link]()

Comment interpréter ce boxplot ?

[ ]: # votre réponse

Exercise
Combinez the deux histograms, le pie et the boxplot ci-dessus dans une seule figure.
[ ]: # votre réponse

Graphe avec Networkx Qu’est-ce qu’un graphe ?

Le graphe est utilisé pour modéliser les relations dans les systèmes physiques, biologiques, sociaux
et d’information.
[ ]: # library for the use of graph
import networkx as nx
help(nx)

• Créer un graphe vide avec networkx

[ ]: G = [Link]()
G

• Ajouter un sommet
[ ]: G.add_node("A")

• Obternir les sommets du graphe

[ ]: [Link]()

• Ajouter une liste de nœuds

[ ]: G.add_nodes_from(["B","C"])

[ ]: [Link]()

• Ajouter un arc
[ ]: G.add_edge("A","B")

• Obtenir la liste des arcs

[ ]: [Link]()

• Ajouter une liste des arcs

40
[ ]: G.add_edges_from([("A","C"),("B","C")])
[Link]()

Que se passera-t-il avec le code suivant ?

[ ]: G.add_edges_from([("A","D"),("A","E")])
[Link]()

• Vérifiez si G a le nœud A et le bord (“D”,“E”)

[ ]: G.has_node("A"), G.has_edge("D","E")

• Dessinez un graphe
[ ]: nx.draw_networkx(G, with_labels=True)
[Link]('off')
[Link]()

• Créer un chemin de longueur n

[ ]: P = nx.path_graph(12)

[ ]: print([Link]())

[ ]: [Link]()

• Ajouter des nœuds à G à partir d’un graphe P existant

[ ]: G.add_nodes_from(P)

[ ]: [Link]()

• Ajouter des arêtes à G à partir d’un graphe existant P

[ ]: G.add_edges_from([Link]())

[ ]: [Link]()

• Effacer le graphe G
[ ]: [Link]()

[ ]: [Link]()

• Créer des nœuds à partir des arêtes

[ ]: G.add_edges_from([(1,2),(1,3)])

[ ]: [Link]()

41
 • Obtenir le nombre de nœuds et d’arêtes
[ ]: G.number_of_nodes(), G.number_of_edges()

• Obtenir les voisins d’un nœud particulier

[ ]: [Link](1)

• Supprimer un nœud particulier et une arête particulière

[ ]: G.remove_node(3)

[ ]: G.remove_edge(1,2)

[ ]: [Link](), [Link]()

• Obtenir le degré de nœud

[ ]: [Link](G)

[ ]: [Link](G,1)

[ ]: [Link](1)

[ ]: [Link]([1,2])

Graphe orienté
[ ]: DG=[Link]()

[ ]: DG.add_weighted_edges_from([('B','A',5), ('B','C',8), ('D','B',4), ('A','C',1),␣

,→('D','C',3), ('F','D',2), ('C','F',1)

, ('E','F',6), ('E','C',1), ('A','E',5)])

[ ]: pos={"A":[1, 1], "B":[0, 0], "C":[2, 0], "D":[1, -1], "E":[3, 1], "F":[3, -1]}
edge_labels=dict([((u,v,),d['weight']) for u,v,d in [Link](data=True)])
nx.draw_networkx_edge_labels(DG,pos,edge_labels=edge_labels)
nx.draw_networkx(DG, pos=pos)
[Link]('off')
[Link]()

Le chemin le plus court

[ ]: nx.dijkstra_path(DG,'B','F')

[ ]: nx.dijkstra_path_length(DG,'B','F')

[ ]: DG.out_degree('A',weight='weight')

42
[ ]: [Link]('C',weight='weight')

[ ]: [Link]('A'), [Link]('C')

9.11 Documentation
[ ]: import numpy as np
def fxname(A, p):
"""
Returns a...

Parameters
----------
A: matrice de dimension n x m
p: nombre maximum
"""
farthest=[]
for k in range(p):
index=[Link](A)
i, j= getI(index, n, n)
[Link](data[i])
[Link](data[j])
A[i, j]=0
A[j, i]=0
return farthest

[ ]: help(fxname)

43