Cours D'introduction À La Programmation II - 082952

Institut Supérieur Technique du Sankuru
Cours d’Introduction à la Programmation II
A la découverte de Python
Par Christophe LWANYI ASHIMALU,

Doctorant
Année Académique 2021 - 2022
1
Aide Python
Python est l’un des langages de programmation les plus utilisés au monde. Grâce à sa
syntaxe sèche et puissante, et à son support multiplateforme, il est utilisé pour de nombreux
types d’applications, de la mise en réseau au Web, en passant par l’apprentissage
automatique. Ce guide complet et pratique part des bases du langage, pour apprendre même
les fonctionnalités les plus complexes.
2
Plan du Cours : Premiers pas avec le langage Python

1. Introduction et un peu d’histoire
2. Pourquoi utiliser Python
3. Installer Python sur Windows, Linux et Mac
4. L’interpréteur Python et l’IDLE
5. Les fonctions d’impression et d’entrée
6. Indentation
Variables et types de données

7. Variables et commentaires en Python
8. Nombres et opérateurs logiques en Python
9. Chaînes en Python
10. Tuple
11. Listes en Python
12. Dictionnaires
13. Set et frozenset
14. Types intégrés: Résumé
Programmation avec Python

15. Instructions conditionnelles
16. Cycles: pour et pendant
17. Compréhension de la liste/de l’ensemble/de l’énoncé
18. Fonctions en Python
19. Gestion des exceptions
20. Gérer les fichiers
21. Modules
22. Créer de nouveaux formulaires
23. Colis
Programmation orientée objet avec Python

24. Programmation orientée objet
25. Classes en Python
26. Hérédité
27. Méthodes spéciales
28. Surcharge de l’opérateur
Interface Graphique avec Python

29. GUI sur Python : les frameworks à utiliser
30. Tkinter
31. PyQt
32. Kivy
Idées
3
33. Python et Java

34. Python et bases de données
35. Python et cgi
36. Multithread
37. Fichiers JSON : lecture et écriture
38. Fichiers XML : lecture et écriture
39. Future Statement
40. pip : le gestionnaire de paquets pour Python
4
Chapitre 1. Introduction et un peu d’histoire

Python est un langage de programmation moderne, avec une syntaxe simple et
puissante qui facilite l’apprentissage. Les domaines d’application de ce langage de
programmation sont variés : développement de sites ou d’applications Web et de bureau,
création d’interfaces graphiques, administration système, informatique scientifique et
numérique, bases de données, jeux, graphismes 3D, etc.
L’objectif de ce guide est de fournir un aperçu général de la programmation en
Python, ce qui permet au lecteur de développer rapidement et facilement ses propres
applications.
Avant de commencer, il peut être utile de comprendre comment et où Python est né.
Pour ce faire, il faut remonter un peu dans le temps précisément au début des années quatre-
vingt. Au cours de ces années, à l’Institut national de recherche en mathématiques et en
informatique (CWI) à Amsterdam, certains chercheurs, dont Guido Van Rossum, ont
développé un langage appelé ABC, très puissant et élégant, qui était devenu populaire dans le
monde Unix.
Quelques années plus tard (fin des années quatre-vingt), Guido Van Rossum avait
une série d’idées visant à améliorer ABC, et il a donc commencé à travailler sur le
développement d’un nouveau langage : Python, en fait. En 1996, il écrivait comme préface
au livre « Programming Python », première édition, les mots suivants :
“Il y a plus de six ans, en décembre 1989, je cherchais un projet de programmation de passe-
temps qui était censé m’occuper pendant la semaine proche de Noël. Mon bureau... il aurait
été fermé, mais j’avais un ordinateur, et pas beaucoup plus. J’ai décidé d’écrire un
interpréteur pour un nouveau langage de script auquel je penserais plus tard : un descendant
d’ABC, qui était censé appartenir à des hackers Unix. J’ai choisi Python comme nom pour le
projet, étant légèrement irrévérencieux (et parce que je suis un grand fan de Monty Python’s
Flying Circus)”.
En 2000, Van Rossum et son équipe ont déménagé à BeOpen.com et ont formé
l’équipe BeOpen PythonLabs, avec Python maintenant dans la version 1.6. Peu de temps
après, la version 2.0 a été publiée, qui, entre autres choses, a amélioré le langage avec l’ajout
de "list comprehension”.
En 2001, Python 2.1 a été publié, et la licence a été redéfinie comme la « Python
Software Foundation License ». Python 2.2 était considéré comme une « version propre », et
la principale nouveauté introduite concernait l’unification des types / classes.
Il faut se rendre en décembre 2008 pour assister à une véritable révolution, avec la
sortie de la version 3.0 de Python (ou « Python 3000 » ou « Py3k »). Cette nouvelle version
est très similaire à la précédente, mais a simplifié le langage et introduit plusieurs
améliorations (telles que les chaînes Unicode par défaut). En raison de ces changements,
comme nous le verrons dans ce guide, Python 3 n’est pas compatible avec Python 2.
Au moment de la rédaction de ce cours, il y a 10 versions de Python 3 (jusqu’à Python
3.10), qui ajoutaient plus de fonctionnalités et de nouveaux modules. La dernière version de
Python 2 est Python 2.7, qui ne reçoit désormais que des corrections de bogues.
5
1.1. Différences entre Python 2 et Python 3

La liste suivante comprend quelques-uns des principaux changements introduits par
Python 3 (qui seront plus clairs dans le reste du cours) :
- print est une fonction (dans Python 2, c’était une instruction) et doit être appelée entre
parenthèses : print('x')
- l’input a été supprimée et raw_input a été renommé input ;
- toutes les chaînes sont maintenant Unicode par défaut, ce qui permet l’utilisation de
n’importe quel alphabet ;
- les types unicode et str python 2 ont été renommés respectivement en str et bytes ;
- les types long et int ont été unifiés en int ;
- la division entre deux int renvoie maintenant un float (par exemple : 5 / 2 == 2.5) ;
- des fonctions telles que la plage, la map et le zip sont maintenant plus efficaces ;
- des méthodes telles que dict.keys(), dict.values() et dict.items() renvoient la vue au
lieu de créer de nouvelles listes ;
- l’opérateur <> et d’autres syntaxes dupliquées et obsolètes ont été supprimés ;
- certains modules, méthodes et fonctions ont été renommés pour respecter le style
d’écriture PEP 8.
Vous pouvez trouver en détail toutes les nouvelles de la version 3.0 et aussi des
versions ultérieures sur le site officiel de python. Dans les prochains chapitres de ce cours,
nous verrons plus en détail comment utiliser Python et les fonctionnalités mentionnées ci-
dessus.
Chapitre 2. Pourquoi utiliser Python ?

Aujourd’hui, il existe de nombreux langages de programmation, mais qu’est-ce qui
vous pousse à utiliser Python, quelle est la particularité de ce langage? Pour réaliser cela,
dans cette leçon, nous examinons certaines des forces de Python et certaines de ses
principales applications.
2.1. Python : Les points forts
2.1.1. C’est gratuit

Python est entièrement gratuit et vous pouvez l’utiliser et le distribuer sans restrictions
de droits d’auteur. Bien qu’il soit gratuit, depuis plus de 25 ans, Python a une communauté
très active et reçoit constamment des améliorations qui la maintiennent à jour et en phase
avec son temps.
2.1.2. C’est multi-paradigme
Python est un langage multi-paradigme, qui prend en charge à la fois la
programmation procédurale (qui utilise des fonctions) et la programmation orientée objet
(y compris des fonctionnalités telles que l’héritage unique et multiple, la surcharge
d’opérateurs et le typage de canard). Il prend également en charge plusieurs éléments de
programmation fonctionnelle (tels que les itérateurs et les générateurs).
6
2.1.3. Il est portable

Python est un langage portable développé en ANSI C. Vous pouvez l’utiliser sur
différentes plates-formes telles que: Unix, Linux, Windows, DOS, Macintosh, Systèmes en
temps réel, OS / 2, Android et iOS mobiles. Ceci est possible parce qu’il s’agit d’un langage
interprété, de sorte que le même code peut être exécuté sur n’importe quelle plate-forme tant
que l’interpréteur Python est installé.
2.1.4. C’est facile à utiliser
Python est un langage de haut niveau à la fois simple et puissant. La syntaxe et les
différents modules et fonctions déjà inclus dans le langage sont cohérents, intuitifs et faciles à
apprendre, et la conception du langage est basée sur le principe du moindre étonnement
(c’est-à-dire « moindre surprise »: le comportement du programme coïncide avec ce qui est
attendu).
2.1.5. Il regorge de bibliothèques
Chaque installation Python inclut la bibliothèque standard, c’est-à-dire une collection
de plus de 200 modules pour effectuer les tâches les plus disparates, telles que l’interaction
avec le système d’exploitation et le système de fichiers, ou la gestion de différents protocoles.
De plus, le Python Package Index vous permet de télécharger et d’installer des milliers de
modules complémentaires créés et maintenus par la communauté.
2.1.6. Il est performant
Bien que Python soit considéré comme un langage interprété, les programmes sont
automatiquement compilés dans un format appelé bytecode avant d’être exécutés. Ce format
est plus compact et efficace, et garantit donc des performances élevées. De plus, différentes
structures de données, fonctions et modules Python sont implémentés en interne en C pour
être encore plus performants.
2.1.7. Gère automatiquement la mémoire
Python est un langage de haut niveau qui adopte un mécanisme de garbage collection
qui prend automatiquement en charge l’allocation et la libération de la mémoire. Cela permet
au progammateur d’utiliser les variables librement, sans avoir à se soucier de les déclarer et
d’allouer et de libérer manuellement des espaces mémoire (ce qui est nécessaire dans les
langages de niveau inférieur tels que C ou C ++).
2.1.8. Peut être intégré à d’autres langages
En plus de l’interpréteur classique écrit en C (et appelé CPython),il existe également
d’autres interprètes qui permettent l’intégration avec plusieurs autres langages. IronPython
vous permet d’utiliser Python dans le framework .NET, d’utiliser ses fonctions et d’interagir
avec d’autres langages .NET. Afin d’intégrer Python et Java, vous pouvez utiliser Jython. Il
existe également d’autres interpréteurs, tels que PyPy: une implémentation haute
performance écrite en Python.
2.1.9. Ce que vous pouvez faire avec Python
Comme nous l’avons mentionné, l’équipement standard et les bibliothèques tierces
complètent Python avec des fonctionnalités qui en font un outil flexible dans divers
domaines.
7
2.1.10. Programmation GUI

Avec Python, vous pouvez écrire des interfaces utilisateur graphiques (GUI) en
utilisant toutes les principales boîtes à outils :
- Tkinter: déjà inclus dans la bibliothèque standard et basé sur Tcl / Tk.
- PyQt/PySide : vous permet d’utiliser avec Python la boîte à outils Qt (versions 4 et 5),
le framework multiplateforme historiquement créé par Nokia.
- PyGtk: basé sur la boîte à outils GTK populaire.
- wxPython : Une interface Python pour la boîte à outils wxWidgets.
Les programmes qui utilisent ces boîtes à outils peuvent s’exécuter sur toutes les
principales plates-formes (Linux, Windows, Mac).
2.1.11. Développement Web
Il existe un certain nombre de possibilités pour le développement Web de haut et de
bas niveau. Pour créer des sites Web et des applications Web, il existe plusieurs frameworks
Web tels que :
Django: l’un des frameworks Web les plus populaires, qui fournit plusieurs outils
pour créer des sites et des applications Web.
Flacon : un « microframework » qui permet de créer rapidement des sites simples.
Web2py: Un autre excellent framework facile à utiliser.
Il existe également plusieurs autres frameworks web qui permettent la création de tout
type de site et de webapp. Le site officiel de Python comprend une liste de frameworks Web
(avec une brève description) et un guide qui explique comment utiliser Python beautiful web.
La plate-forme Google App Engine vous permet de lancer vos propres applications
Web dans l’infrastructure Google. App Engine dispose d’un environnement d’exécution
Python dédié, qui inclut l’interpréteur Python et la bibliothèque Python standard.
Si vous voulez descendre à un niveau inférieur, il existe des modules de la
bibliothèque standard tels que socket, httplibet urllib,mais aussi des frameworks pour prendre
en charge la programmation réseau. L’un d’eux est Twisted: un puissant moteur réseau
piloté par les événements - écrit en Python - qui prend en charge de nombreux protocoles
réseau, notamment SMTP, POP3, IMAP, SSHv2 et DNS.
Vous pouvez également utiliser Python pour accéder aux bases de données. La
bibliothèque standard comprend une interface pour SQLite et il est également possible
d’installer des modules pour s’interfacer avec d’autres bases de données (PostgreSQL,
Oracle, MySQL et autres).
Pour la création de jeux, Pygame est un excellent framework qui permet leur
développement de manière simple et intuitive. Pour réaliser des applications scientifiques,
SciPy fournit un écosystème d’outils pour les mathématiques, les sciences et l’ingénierie.
2.2. Qui utilise Python
Aujourd’hui, Python est utilisé dans de nombreuses grandes entreprises du marché
informatique, notamment :
La NASA utilise Python pour le développement de systèmes de contrôle ;
Yahoo! a développé certains services Internet en Python ;
Google, Youtube et RedHat utilisent Python.
8
Chapitre 3. Installer Python sur Windows, Linus et Mac

Par souci de comodité, nous utiliserons Python 3. Vous pouvez télécharger
gratuitement la dernière version de Python 3 (3.5 au moment de la rédaction) sur le site
officiel.
3.1. Installer Python sur Windows
Sur la page de téléchargement, vous pouvez trouver le fichier .exe pour les versions
Windows 32 bits et 64 bits. Il suffit de le lancer et de suivre les différentes étapes, en vous
rappelant de sélectionner l’élément Ajouter Python 3.X à PATH au début de l’installation.
Après l’installation, python sera placé par défaut dans C:\Python3X (par exemple :
C:\Python312 pour la version 3.12). À ce stade, vous pouvez déjà l’utiliser, via Démarrer ->
Tous les programmes -> Python3.12 -> Python.
Après avoir sélectionné Ajouter Python 3.X à PATH lors de l’installation, il devrait
être possible de lancer Python à partir de l’invite de commande simplement en tapant la
commande .py ou py -3
Dans le cas où, lors de l’installation, nous n’avions pas sélectionné l’option
susmentionnée, il est toujours possible d’ajouter Python à la variable d’environnement PATH
manuellement, en suivant les étapes suivantes. Tout d’abord, nous allons dans panneau de
configuration -> système -> paramètres système avancés -> variables d’environnement. Nous
modifions ensuite la variable PATH entre les variables système en ajoutant C:\Python3X (où
le X correspond à la version installée).
3.2. Modification de la variable Path
Pour vérifier que tout a réussi, nous démarrons l’invite de commande (Start -> Run ->
cmd) et tapons :
echo %PATH%
Si la sortie inclut la chaîne C:\Python3X,vous pouvez démarrer Python en tapant

simplement pypy ou -3python
9
3.3. Démarrage de Python
Si Python a été installé avec succès, vous verrez un court message indiquant la
version de l’interpréteur python, suivi de l’invite ().>>>
Sur le site officiel, il existe également un guide d’installation et d’utilisation de
Python sur Windows.
3.4. Installer Python sur Linux
Dans les systèmes Linux, Python est souvent déjà présent dans la configuration de
base. Vous pouvez toujours vérifier s’il y en a et quelles versions sont présentes. Pour ce
faire, nous tapons à partir du shell ce qui suit :
$ python
Ou
$ python3
Si les deux commandes échouent, Python n’est pas installé. Si python démarre
seulement Python2 c’est que la commande python3 n’est pas présente, seul Python 2 est
installé. Si, au contraire, la commande python ou python3 démarre Python 3 alors Python 3
est installé.
Dans le cas où Python 3 n’est pas installé, vous devrez l’installer en utilisant le
gestionnaire de paquets pour les systèmes Linux : apt pour les distributions basées sur
10
Debian, rmp pour les distributions basées sur RedHat. Vous pouvez également télécharger et
compiler manuellement des sources Python.
Plus en détail, selon votre système, vous pouvez démarrer l’une des commandes
suivantes :
Commander Description
$ yum install python3 Pour les distributions basées sur des paquets rpm, tels que
Red Hat, Fedora, Centos
$ apt-get install python3 Pour les distributions basées sur Debian, telles que
Ubuntu
Enfin, voyons comment installer Python en compilant les sources.
Tout d’abord, nous devons vérifier la dernière version des sources du site, puis nous
lançons les commandes suivantes :
$ cd /tmp
$ wget http://www.python.org/ftp/python/3.x/python-3.x.tar.bz2
Ce faisant, nous avons téléchargé une archive .tar.bz2 contenant les sources Python.
Maintenant, extrayons le contenu :
$ tar -xjf python-3.x.tar.bz2
$ cd python-3.x
Il ne reste plus qu’à démarrer l’installation :

$ ./configure
$ make
$ sudo make install
Remarque : Vous pouvez utiliser

make altinstall
au lieu de
make install
pour empêcher la version que vous venez d’installer d’être associée à la commande python
3.5. Installer Python sur Mac
Comme dans les systèmes Linux, également dans les Mac, nous devrions trouver
Python prêt à être utilisé. Pour vérifier cela, une fois de plus, il suffit de lancer une fenêtre de
terminal et de taper python. Probablement la version 2.7 sera affichée, mais nous voulons
utiliser le 3.X. Nous devrons donc visiter le site et télécharger la version pour Mac OS qui
convient le mieux à nos besoins. Enfin, nous pouvons procéder à l’installation.
À la fin de l’installation, en lançant python à partir du terminal apparaîtra toujours
l’ancienne version. Par conséquent, vous devez ouvrir le terminal et taper :
vim ~/.bash_profile
11
Une fois ouvert le fichier, nous ajoutons la ligne suivante :

alias python="python3"
Maintenant, en essayant à nouveau de lancer python à partir du terminal, par défaut
démarrera la version 3.X.
Chapitre 4. L’Interpréteur Python et l’IDLE

Comme nous l’avons vu dans les chapitres précédents, si nous lançons la commande
python en ligne de commande, à la fois dans les environnements Windows et Linux, une
nouvelle invite est affichée caractérisée par 3 caractères de majeur (>>>), que nous
appellerons désormais interpréteur interactif.
L’interpréteur interactif est capable de lire et d’évaluer les expressions saisies par
l’utilisateur, mais il est également possible d’exécuter des scripts contenant des séquences
d’instructions Python, en tapant la commande :
python script.py
Il est intéressant d’ouvrir une petite parenthèse sur ce qui se passe lorsque vous
exécutez un script, en entrant un peu plus dans les détails.
Chaque fois que la commande
python
est appelée, le code écrit est analysé à la recherche de token (jetons), chacun d’entre eux étant
analysé dans une arborescence logique qui représente le programme. Pareille structure est
finalement transformée en bytecode (fichiers avec l’extension .pyc ou .pyo). Pour pouvoir
exécuter ces bytecodes, un interpréteur spécial connu sous le nom de machine virtuelle
Python en anglais Python Virtual Machine (PVM) est utilisé.
Sorgente (file.py) -> Bytecode (file.pyc) -> Runtime (PVM)
Exécution en ligne de commande
12
Revenons à l’accent mis sur le fonctionnement de base de l’interprète interactif.

Dans ce mode, taper des commandes Python obtient immédiatement une réponse :
>>> 5 * 3
15
>>>
>>> a = 5
>>> b = 6
>>> 2 * (a+b) + 3*a
37
4.1. Exécution de scripts .py

Mais comment créer et exécuter un fichier Python ? Vous devez d’abord générer un
fichier texte simple et l’enregistrer avec une extension .py, par exemple, helloworld.py. À ce
stade, nous pouvons ouvrir le fichier créé avec n’importe quel éditeur de texte (à exception de
Word, mais Notepad, Notepad ++, Sublime Text ou similaire) et écrire :
print('Hello World!')
Notez que, sous Windows, nous pouvons créer un fichier texte, mais nous ne pourrons
peut-être pas modifier son extension. Dans ce cas, nous pouvons créer le fichier directement à
partir de l’éditeur de texte avec la bonne extension, ou modifier le paramètre du système qui
cache les extensions. Comme premier exemple, nous ajoutons à notre fichier helloworld.py
une seule ligne de code, composée de la fonction
print()
, qui imprimera ainsi une chaîne. En exécutant le fichier à partir du terminal, nous
obtiendrons ce qui suit :
$ python helloworld.py
Hello World!
4.2. Utilisation d’IDLE

Maintenant que nous avons brièvement vu comment exécuter un fichier Python à
partir de la ligne de commande, nous pouvons examiner un environnement visuel qui vous
permet d’éditer, d’exécuter et de déboguer des programmes Python à partir d’une seule
interface : IDLE (Integrated Development and Learning Environment).
IDLE offre une interface visuelle pour Python et peut fonctionner sous Windows, Linux ou
Mac OS. Il est démarré par un script Python (idle.pyw), qui dans les versions récentes de
Windows se trouve dans C:\Python3X\Lib\idlelib.
Cependant, il est possible de le lancer rapidement à partir du menu Démarrer -> Tous les
programmes -> Python 3.X.
13
En lançant IDLE, une fenêtre apparaîtra avec l’invite de commande Python désormais
bien connue (>>>), et les éléments de menu que vous avez l’habitude de voir dans d’autres
applications similaires.
Commençons à nous familiariser avec cet outil.
4.3. Ouvrir et exécuter un fichier

Pour ouvrir un fichier Python déjà existant, nous pouvons sélectionner Fichier ->
Ouvrir (Ctrl + O), tandis que pour en créer un nouveau, nous pouvons sélectionner Fichier -
> Nouvelle fenêtre (Ctrl + N). Dans les deux cas, vous pouvez exécuter le script en
sélectionnant Run -> RunModule (F5) dans le menu :
14
4.4. Personnaliser l’IDE
Vous pouvez également personnaliser l’IDE en fonction de vos besoins. Pour ce faire,
il suffit de sélectionner le menu : Options -> Configure IDLE.
À partir de cet écran, vous pouvez choisir le type et la taille de la police, ainsi que la
largeur de l’indentation (dont nous parlerons plus tard). Vous pouvez également
15
personnaliser les couleurs des mots-clés et de divers autres éléments en modifiant les
paramètres accessibles via l’onglet Mise en surbrillance.
Chapitre 5. Les fonctions print et input
Dans ce chapitre, nous apprendrons à connaître deux fonctions de base de Python :

print et input. Ces fonctions sont utilisées respectivement pour afficher et demander des
valeurs à l’utilisateur. Les deux sont particulièrement utiles lors de la création des premiers
tests et programmes en ligne de commande, mais ils seront également utiles à l’avenir.
5.1. Print
Nous avons déjà vu, dans les leçons passées, la fonction « print », qui sert à imprimer
en sortie (généralement à l’écran, mais aussi sur des fichiers ou d’autres flux) la valeur d’une
variable ou d’une expression.
>>> a = 12
>>> b = 3
>>> print(a, b, a-b)
12 3 9
>>>
>>> c = 'Hello'
>>> print(c, 'World!')
Hello World!
On peut noter que la fonction print prend en entrée un nombre variable d’arguments
(même de types différents), les convertit en chaînes (string) et les affiche dans des sorties
séparées par un espace et suivies d’un caractère de retour à la ligne (\n). Il vous permet
également de spécifier le séparateur, le caractère de fin, le flux et d’autres paramètres.
Lorsque vous travaillez à partir de l’interpréteur interactif, vous n’avez pas besoin
d’utiliser print pour voir la valeur d’une variable ou d’une expression, mais il vous suffit de
la taper directement :
>>> x = 10
>>> x
10
>>> x * 2
20
Cette possibilité n’est disponible qu’auprès de l’interprète interactif ; toutefois,

lorsque vous exécutez un programme, il est nécessaire d’utiliser explicitement print.
Remarque : Dans Python 2.x, print était une instruction (Statement), et il n’était donc pas
nécessaire de mettre les paramètres entre parenthèses. Omettre des parenthèses dans Python
3.x (où il s’agit d’une fonction) renvoie une erreur de syntaxe. Dans Python 2.x, il est
possible d’utiliser from __future__ import print_function pour rendre print une fonction
comme dans Python 3.
16
5.2. Input
La fonction input est utilisée pour permettre à l’utilisateur d’entrer les données du
clavier, qui seront ensuite utilisées par le programme. input accepte un seul argument
facultatif : une chaîne qui s’affiche à l’écran avant de lire la valeur tapée. Une fois que
l’utilisateur a tapé une valeur et appuyé sur la touche Entrée, il renvoie la valeur sous forme
de chaîne, comme le montre l’exemple suivant :
>>> name = input('Insert your name: ')

Insert your name: Dieudo
>>> name
'Dieudo'
Dans cet exemple, nous pouvons voir que :

1. La chaîne transmise à input pour vous demander d’entrer le nom s’affiche à l’écran ;
2. input attend que l’utilisateur tape le nom (Dieudo) et appuie sur Entrée ;
3. input renvoie le nom entré sous forme de chaîne ;
4. La chaîne renvoyée par input est affectée à la variable name ;
5. La variable name peut ensuite être utilisée pour accéder au nom saisi par l’utilisateur.
Si vous souhaitez entrer des types numériques ou autres, il est possible convertir la chaîne
renvoyée à l’aide de fonctions telles que int ou float :
>>> rayon = input('Insert rayon: ')

Insert rayon: 8.4
>>> r = float(rayon)
>>> rayon, r
('8.4', 8.4)
>>> print(Surface:', 3.14 * r**2)
Surface: 221.5584
>>> print('Circonference:', 2 * 3.14 * r)
Circonference: 52.752

input invite l’utilisateur à entrer un rayon qui sera affecté à la variable rayon ;
La fonction float est utilisée pour convertir rayon (qui est de type chaîne) en une
valeur numérique avec la virgule affectée à la variable r ;
Les deux variables (rayon et r) sont imprimées pour montrer que la première est une
chaîne (donc représentée entre guillements simples ‘...’) tandis que la seconde est un
nombre ;
17
r est ensuite utilisé pour calculer la Surface du cercle (** est l’opérateur d’élévation à la
puissance) et la fonction print est utilisée pour imprimer la chaîne Surface et le résultat
de l’expression 3.14 * r**2 ;
r est également utilisé pour calculer la circonférence et print pour imprimer la chaîne
Circonference et le résultat de l’expression 2 * 3.14 * r ;
Remarque : Dans Python 2.x, il y avait deux fonctions d’entrée différentes : raw_input et
input. La première est équivalente à input de Python 3.x, tandis que la seconde (qui
effectuait une étape supplémentaire de conversion d’entrée implicite) a été supprimé de
Python 3.x. Comme nous l’avons vu dans le deuxième exemple, dans Python 3.x, il est
possible convertir explicitement les valeurs reçues en input.
Chapitre 6. Indentation
Dans ce chapitre, nous verrons plus en détail l’un des aspects fondamentaux de la
programmation avec Python : l’indentation.
6.1. Indentation et blocs de code
Contrairement à d’autres langages qui délimitent des blocs de code avec des crochets
de graphe (tels que C, C ++ et Java) ou avec des mots réservés comme begin / end, Python
utilise l’indentation. Le retrait de code est une pratique courante dans tous les langages, car
il facilite la lecture du code et la compréhension de sa structure. Au lieu d’utiliser deux
mécanismes distincts pour les compilateurs/interpréteurs (parenthèses ou mots-clés) et les
personnes (indentation), python a choisi d’utiliser l’indentation pour les deux. Ce choix
comporte plusieurs aspects positifs, notamment :
1. le langage est plus clair et plus lisible ;

2. la structure du programme coïncide toujours avec celle de l’indentation ;
3. le style d’indentation est nécessairement uniforme dans n’importe quel répertoire.
Cela signifie que, dans Python, l’indentation est importante et qu’une indentation
incorrecte peut entraîner un comportement de programme incorrect ou des erreurs. Voyons
un exemple simple. Ci-dessous, nous utilisons la construction if , que nous approfondirons un
peu plus loin.
print("exécute toujours au début")

if condition:
print('exécute toujours au milieu si la condition est vrai')
print('execute toujours a la fin')
18
Dans ce script on peut faire ce constat :

1. Le premier print, la condition if et le dernier print ont le même niveau d’indentation ;
2. Après l’if, il y a un bloc de code avec un niveau majeur d’indentation, qui inclut trois
print ;
3. Si la condition de l’if est vérifiée (c’est-à-dire est vraie), les trois print viennent
exécutées ;
4. Si, par contre, la condition de l’if n’est pas vérifiée (c’est-à-dire est fausse), les trois
print ne viennent pas exécutées.
Il est donc très important de faire attention à l’indentation, car elle est toujours
évaluée dans le processus d’analyse du programme. Vous trouverez ci-dessous un exemple
d’erreur due à une indentation incorrecte :
6.2. Conventions
Pour avoir un code plus cohérent, la Python Software Foundation a mis à disposition
un document appelé PEP 8 (acronyme qui signifie Python Enhancement Proposal), qui
rassemble différentes conventions et directives. PEP 8 comprend également une section sur
l’indentation, qui suggère entre autres de :
- utiliser toujours 4 espaces par niveau d’indentation ;
- éviter l’utilisation de caractères de tabulation ;
- Ne jamais mélanger l’utilisation de tabulations et d’espaces.
Bien que PEP 8 suggère de suivre ces conventions, il est possible (bien que fortement
déconseillé) d’utiliser des tabulations ou un nombre différent d’espaces en lieu et place de 4.
Tant que les niveaux d’indentation sont cohérents, le programme fonctionnera toujours.
Il y a cependant quelques exceptions. Si vous travaillez sur un code qui utilise une
convention différente, il est préférable de vous y adapter ou, alternativement, d’adapter tout le
code existant à PEP 8. De plus, il est toujours possible (et parfois recommandé) d’utiliser
plus ou moins d’espaces pour aligner des éléments dans une liste, ou des arguments dans un
appel de fonction :
lista = [0, 1, 2, 3, 4,
19
5, 6, 7, 8, 9]
funzione(arg1, arg2,
arg3, arg4)
Chapitre 7. Variables et Commentaires en Python

7.1. Les Variables
Pour définir des variables en Python, il est suffisant d’utiliser l’opérateur d’affectation
(=) comme dans les exemples suivants :
nombre = 10
string = "Python"
liste = [1, 2, 3]
Comme vous pouvez le voir, en Python, il n’est pas nécessaire de définir des variables avant
de les utiliser, ni de spécifier leur type.
7.2. Différences avec d’autres langages
Dans les langages tels que C, les variables font référence à des emplacements de
mémoire spécifiques dont la taille dépend de leur type (pour cela, vous devez spécifier le type
lors de la déclaration d’une variable). En Python, en revanche, les objets ont un type
spécifique (nombre, chaîne, liste, etc.), et les variables ne sont que des « étiquettes » qui font
référence à un certain objet.
Pour mieux comprendre ce concept fondamental, nous pouvons le voir dans un
exemple simple :
/* Code C */
int x;
x = 10;
x = 20;
Dans ce code C :
1. Il y est définie une variable x de type int (c’est-à-dire suffisamment grand pour
contenir un nombre entier) ;
2. La valeur 10 est enregistrée dans l’emplacement mémoire associé à x ;
3. La valeur 20 est enregistrée dans l’emplacement de mémoire associé à x, en
remplaçant, par le même fait, le 10.
# code Python
x = 10
x = 20
20
Bien que ce code Python puisse sembler très similaire, ce qui se passe est différent :
1. L’objet 10 est créé et l’opération d’affectation fait de sorte que la variable x se réfère
à cet objet ;
2. L’objet 20 est créé et la variable/étiquette x est « déplacée » de 10 vers 20 ;
3. Comme il n’y a plus de variables qui référencent l’objet 10, le garbage collection1 le
supprimera automatiquement.
Dans ces deux exemples, la valeur finale associée à la variable x sera 20.
Comme nous l’avons dit précédemment, en Python, les variables n’ont pas de type et
peuvent faire référence à n’importe quel type d’objet. Le code suivant est donc parfaitement
valide en Python :
x = 10
x = "Python"
x = [1, 2, 3]
Dans cet exemple, la variable/étiquette x est « déplacée » de l’entier 10, vers la chaîne
“Python”, et enfin vers la liste [1, 2, 3].
Types de données
Python possède à la fois les types de données classiques, communs à la plupart des
langages de programmation, mais aussi plusieurs types plus puissants et flexibles. Voici un
tableau répertoriant certains des types de données les plus courants en Python :
Type de données Nom Description Exemples

Entier int Entier de taille arbitraire -42, 0 , 1200, 999999999999999999
Réel float Nombre à virgule 3.14, 1.23e-10,
flottante 4.0E210
Booléen bool Pour les valeurs true ou True,
false False
Nombres complexes 3+4j,
Complexe complex avec partie réelle et 5.0+4.1j,
imaginaire 3j
Chaine str Utilisé pour représenter ' ', 'Dieudo',
le texte "l'eau"
Octets bytes Utilisé pour représenter b'', b'\x00\x01\x02',
les octets b'Python'
Listes list Une séquence d’objets [], [1, 2, 3],
1 Pour la gestion de la mémoire, deux principes fondamentaux sont pris en compte par le garbage collection :
Rechercher des objets précédemment créés par un programme auquel vous n’avez plus besoin
d’accéder ;
Récupérez les ressources utilisées par ces objets.
21
modifiable ['Hello', 'World']

Tuple tuple Une séquence immuable (), (1, 2, 3),
d’objets ('Python', 3)
Ensemble set/frozens Un ensemble d’objets {1, 2, 3},
et uniques {'World', 'Hello'}
Une structure qui {},
Dictionnaires dict associe des clés à des {'nome': 'Ezio', 'cognome':
valeurs 'Melotti'}
Dans les prochaines leçons, nous aborderons plus en détail ces types de données et
verrons leurs caractéristiques.
7.3. Noms des variables

Rappelons que les règles à suivre dans le choix des noms de variables sont similaires
à celles des langages de programmation les plus courants, notamment :
1. Chaque nom de variable doit commencer par une lettre ou un trait de soulignement
communément appelé underscore (_), et peut être suivi de lettres, de chiffres ou de
traits de soulignement ;
2. il existe des mots réservés (mot-clé) qui ne peuvent pas être utilisés comme noms de
variables : False, None, True, and, as, assert, break, class, continue, def, del, elif,
else, except, finally, for, from, global, if, import, in, is, lambda, non, local, not, or,
pass, raise, return, try, while, with, yield ;
3. Python est un langage case-sensitive, qui distingue les noms de variables composés de
caractères minuscules et majuscules ;
4. En Python 3, il est possible (mais généralement non recommandé) d’utiliser des
caractères accentués ou d’autres alphabets dans les noms de variables, par exemple :
âge = 20.
PEP 8 comprend une section sur les conventions à utiliser avec les noms de variables.
7.4. Affectation multiple
Une possibilité unique offerte par Python est représentée par plusieurs affectations, ce
qui vous permet d’initialiser plusieurs variables directement sur la même ligne de code. Pour
comprendre ce dernier concept, il suffit de regarder l’exemple suivant :
>>> a, b, c = 2, 3, 5 # assignation multiple

>>> a * b + c
11
>>> a
2
>>> b
3
22
>>> c
5
7.5. Les Commentaires
En Python, vous pouvez utiliser le caractère dies (#) pour ajouter des commentaires à
votre code. Chaque ligne de commentaire doit être précédée d’un (#), et vous pouvez
également ajouter des commentaires à la suite des instructions comme dans les lignes
suivantes :
# Ce commentaire occupe plusieurs lignes, et chaque ligne

# est précédée d’un # pour indiquer à Python
# d’ignorer toutes les lignes
a = 3 # Ce commentaire vient après une instruction
Python ignorera automatiquement tout ce qui suit le caractère # jusqu’à la fin de la

ligne. PEP 8 comprend également une section de commentaires.
Chapitre 8. Les Nombres et les Opérateurs logiques en Python
Comme nous l’avons vu précédemment, en Python, il existe 4 types de données

numériques : les entiers (int), les rationnels (float), les complexes (complex) et les booléens
(bool).
Nous avons également vu qu’il est possible d’utiliser l’interpréteur interactif comme
calculatrice et comment convertir différents types de données. Vous pouvez également
définir des entiers à l’aide de notations binaires, octales et hexadécimales :
>>> 6 + 4*3
18
>>> 9 / 2 # la division entre deux nombres entiers renvoie un float
4.5
>>> 2j * 2j # multiplication entre les nombres complexes
(-4+0j)
>>> int(10.6) # conversion explicite à partir du type float vers le type int
10
>>> float(20) # conversion explicite à partir du type int vers le type float
20.0
>>> 0b11111111 # entier en notation binaire (préfixe 0b)
255
>>> 0o377 # entier en notation octale (préfixe 0o)
255
23
>>> 0xFF # entier en notation hexadécimale (préfixe 0x)

255
Remarque :
Dans Python 2, il y avait deux types d’entiers : int et long. Dans Python 3, ces deux
types ont été unifiés, et le type int de Python 3 est capable de représenter des entiers de taille
arbitraire (comme c’est le cas du type long de Python 2).
8.1. Les Opérateurs arithmétiques

Les opérations sur les types numériques sont les plus classiques :
Opérateur Descrizione Exemple

+ addition 10 + 12 → 22
– soustraction 5-1→4
* multiplication 10 * 12 → 120
/ division 9 / 4 → 2.25
// division entière 9 // 4 → 2
% modulo (reste de la division) 9%4→1
Remarque :
Dans Python 2, la division entre deux ints renvoyait un int, dans Python 3, elle
renvoyait un float. Dans Python 2, vous pouvez obtenir le même comportement que dans
Python 3 en ajoutant, au début du programme, la ligne from __future__ import division.
8.2. Opérateurs de comparaison
Python prend également en charge les opérateurs de comparaison, qui renvoient True
ou False :
Opérateur Description Exemples

== égal à 8 == 8 → True
3 == 5 → False
!= autre que (différent) 3 != 5 → True
8 != 8 → False
< Strictement inférieur à 3 < 5 → True
5 < 3 → False
<= inférieur ou égal à 3 <= 5 → True
8 <= 8 → True
> Strictement supérieur à 5 > 3 → True
3 > 5 → False
24
>= supérieur ou égal à 5 >= 3 → True

8 >= 8 → True
8.3. Opérateurs booléens
En Python, il existe également des opérateurs booléens and, or et not :

Opérateur Description
and Renvoie True si les deux opérandes sont vrais, sinon False
or Renvoie True si au moins un des opérandes est vrai, sinon False
not Renvoie True si l’opérande a la valeur false, False si l’opérande a la valeur true
En Python, chaque objet est soit true (nombres autres que 0, la constante True, ou
conteneurs contenant au moins un élément), soit false (c’est-à-dire le nombre 0, les
constantes False et None ou les conteneurs vides). Vous pouvez vérifier si un objet est vrai
ou faux à l’aide de bool(objet).
Comme dans d’autres langages de programmation, également en Python, les
opérateurs and et or travaillent de sorte que, si le premier opérande est suffisant pour
déterminer le résultat, le second n’est pas évalué. En d’autres termes, les deux opérateurs
renvoient toujours l’un des deux opérandes.
8.4. Opérateurs binaires
Ensuite, il y a les opérateurs binaires (ou bitwise) qui permettent de travailler au

niveau des bits individuels et sont utiles dans des circonstances particulières :
Opérateur Description
x << n Exécute un déplacement à gauche de n positions des bits de x
x >> n Exécute un déplacement à droite de n positions des bits de x
x&y exécute un and entre les bits de x et de y
x|y exécute un or entre les bits de x et de y
x^y exécute un or exclusif entre les bits de x et de y
~x inverse les bits de x
Chapitre 9. Les Chaines en Python

Dans ce chapitre, nous aborderons le traitement les chaînes en Python (string). Nous
avons déjà vu que pour déclarer une chaîne il suffit d’attribuer à une nouvelle variable un
texte entre guillemets : il est possible d’enfermer sa valeur indifféremment entre guillements
simples (’ ‘) ou doubles (” “).
Cela vous permet de surmonter facilement le problème de l’utilisation des caractères
susmentionnés dans la valeur de la chaîne elle-même, par exemple “l'eau” ou ‘Ils dirent :
25
“Eau”’. Vous pouvez également utiliser le caractère d’échappement \ avant ‘ ou “ : ‘Ils

dirent : “L\’Eau”’.
Les chaînes, ainsi que les listes ou les tuples, sont un type particulier de séquence et
prennent donc en charge toutes les opérations communes aux séquences. Voyons quelques-
uns d’entre eux.
9.1. Indexation et tranchage (Indexing e Slicing)
En Python, vous pouvez accéder aux éléments d’une séquence à l’aide de

sequence[indice]. Cela renverra l’élément en place (le premier élément a toujours un index
0). Vous pouvez également spécifier des indices négatifs qui commencent à partir de la fin de
la séquence (le dernier élément a un index -1, l’avant-dernier -2, etc.). C’est ce qu’on appelle
l’indexation (indexing).
>>> s = 'Python'
>>> s[0] # élément en position 0 (le premier)
'P'
>>> s[5] # élément en position 5 (le cinquième)
'n'
>>> s[-1] # élément en position -1 (le dernier)
'n'
>>> s[-4] # élément en position -4 (le quatrième élément en commençant par la fin)
't'
La syntaxe sequence[debut:fin] nous permet d’obtenir une nouvelle séquence du

même type qui inclut tous les éléments allant de l’index debut (inclus) à l’index fin (exclus).
Si debut est omis, les éléments seront pris depuis le début, si fin est omis, les éléments seront
pris jusqu’à la fin. Cette opération est appelée slicing (littéralement « tranchage »).
>>> s = 'Python'
>>> s[0:2] # sous-chaîne avec des éléments de 0 (inclus) à 2 (exclus)
'Py'
>>> s[:2] du début jusqu'à l'élément avec l'index 2 (exclus)
'Py'
>>> s[3:5] # de l'élément d'indice 3 (inclus) à 5 (exclus)
'ho'
>>> s[4:] # de l'élément avec l'indice 4 (inclus) jusqu'à la fin
'on'
>>> s[-2:] # de l'élément avec l'indice -2 (inclus) à la fin
'on'
26
9.2. Container
Les opérateurs in et not in peuvent être utilisés pour vérifier si un élément fait partie
d’une séquence ou non. Dans le cas des chaînes, vous pouvez également vérifier si une sous-
chaîne est contenue dans une chaîne
>>> s = "Python
>>> 'P' in s # vérifie si le caractère 'P' est contenu dans la chaîne s
True
>>> 'x' in s # le caractère 'x' n'est pas dans s, donc renvoie False
False
>>> 'x' not in s # "not in" effectue l'opération inverse
True
>>> 'Py' in s # vérifie si la sous-chaîne 'Py' est contenue dans la chaîne s
True
>>> 'py' in s # la vérification est sensible à la casse (case-sensitive), donc elle renvoie False
False
9.3. Enchaînement, répétition et longueur
Vous pouvez utiliser l’opérateur + pour concaténer les séquences et * pour répéter les
séquences :
>>> 'Py' + 'thon'

'Python'
>>> 'Py' * 2
'PyPy'
>>> 'Ba' + 'na' * 2
'Banana'
La fonction intégrée len() peut être utilisée pour obtenir le nombre d’éléments dans une
séquence :
>>> len('Python')
6
>>> s = 'Precipitevolissimevolmente'
>>> len(s)
26
9.4. Fonctions et méthodes
27
Avant de continuer, il est nécessaire de faire une brève parenthèse pour expliquer la
différence entre les fonctions et les méthodes.
Nous avons déjà vu certaines fonctions telles que len(). Les fonctions acceptent 0 ou
plusieurs arguments et peuvent être utilisées avec des objets de différents types, selon cette
syntaxe : fonction(arguments) :
>>> len('Python') # longueur d’une chaine

6
>>> len(['PyPy', 'Jython', 'IronPython']) # longueur d’une liste
3
>>> len({'a': 3, 'b': 5}) # longueur d’un dictionnaire
2
Les méthodes sont similaires aux fonctions mais sont liées au type de l’objet et ont
une syntaxe différente : objet.methode(arguments). En plus des fonctions, les méthodes
peuvent accepter 0 ou plusieurs arguments :
>>> s = 'Python'
>>> s.upper() # la méthode upper retourne une nouvelle ... tout en majuscules
'PYTHON'
>>> s.lower() # la méthode lower renvoie une nouvelle... tout en minuscules
'python'
Dans cet exemple, vous pouvez voir deux méthodes fournies par le type str, qui ne
sont pas disponibles pour d’autres types.
9.4. help() et dir()
Deux outils particulièrement utiles pour travailler avec des fonctions et des méthodes
sont les fonctions intégrées help et dir. help(objet) renvoie une brève explication de l’objet
passé en argument. dir(objet) renvoie une liste de méthodes et d’attributs d’objet.
>>> len # len est une fonction built-in (fonction intégrée)
<built-in function len>
>>> help(len) # on peut passer len à help() pour voir une brève explication
Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.
>>> dir(str) # restitue une liste de méthodes et attributs de str (càd chaine de caractères)
[..., 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs',
'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit',
'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper',
'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind',
'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',
'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
28
>>> str.upper # upper est une méthode de str

<method 'upper' of 'str' objects>
>>> help(str.upper) # peut être passé à help() pour voir une brève explication
Help on method_descriptor:
upper(...)
S.upper() -> str
Return a copy of S converted to uppercase.
Ces outils vous permettent d’explorer de manière interactive les fonctions et les
méthodes et de comprendre leur fonctionnement :
>>> help(str.replace) # visualise l'help par la méthode str.replace
Help on method_descriptor:
replace(...)
S.replace(old, new[, count]) -> str
Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
>>> 'Python'.replace('thon', 'Py') # remplace 'thon' par 'Py' in 'Python'
'PyPy'
>>> s = 'Python, Python, Python!'
>>> s.replace('thon', 'Py', 2) # comme au-dessus, mais maximum 2 remplacements
'PyPy, PyPy, Python!'
La documentation officielle de Python comprend une section sur les méthodes de

chaîne.
9.5. Mise en forme des chaînes
La plupart des méthodes de chaîne sont simples à comprendre. Il existe cependant une
méthode qui nécessite une explication plus détaillée : str.format(). Cette méthode vous
permet de mettre en forme des chaînes, c’est-à-dire d’insérer des valeurs de variable dans une
chaîne prédéfinie :
>>> rayon = 8.4
>>> surface = 3.14 * rayon**2
>>> circ = 2 * 3.14 * rayon
>>> s = "La surface est {}, la circonférence est {}."
>>> s.format(surface, circ)
"La surface est 221.5584, la circonférence est 52.752."

1. les variablies surface et circ sont définies à partir du rayon d’un cercle ;
2. la string (chaine) s est définie, et contient deux placeholder (“espaces réservés”) : {} ;
3. la méthode format est appelée sur la chaine (string) s et la surface et la circonférence
sont pris pour arguments ;
4. la méthode format remplace les deux placeholder avec la valeur des deux arguments
reçus et renvoie une nouvelle chaine (string) ;
29
En plus de convertir les arguments en chaîne et de les remplacer par des espaces
réservés, str.format(), vous permet de contrôler la sortie en spécifiant certaines options
(telles que le nombre de décimales, l’alignement, etc.) entre le {}. La documentation officielle
comprend une section avec de nombreux exemples d’utilisation de str.format().
9.6. Formatage « à l’ancienne »

Avant l’implémentation de str.format(), une autre méthode inspirée du formatage
effectué par la fonction printf de C a été utilisée. Cette méthode utilise l’opérateur % pour
séparer la chaîne de mise en forme des arguments, et bien qu’elle fonctionne de la même
manière que str.format(), cette méthode est moins flexible.
>>> rayon = 8.4
>>> surface = 3.14 * rayon**2
>>> circ = 2 * 3.14 * rayon
>>> s = "La surface est %f, la circonférence est %f."
>>> s % (surface, circ)
"La surface est 221.558400, la circonférence est 52.752000."
Vous remarquerez peut-être que cette méthode %f utilise comme espace réservé au
lieu de {}. En plus de (pour les float), il existe également d’autres types d’espaces réservés,
tels que pour les entiers ou les chaînes. La documentation officielle comprend une section qui
explique les différents types d’espaces réservés et les options supplémentaires.
Chapitre 10. Tuple

Python fournit un type intégré appelé tuple, qui est généralement utilisé pour
représenter une séquence immuable d’objets, généralement hétérogènes.
10.1. Définir des tuples
L’opérateur qui définit les tuples est la virgule (,) bien que pour éviter toute
ambiguïté, les séquences d’éléments soient souvent placées entre crochets ronds. Dans
certaines expressions, où les virgules ont déjà une signification différente (par exemple,
séparer les arguments d’une fonction), des parenthèses sont nécessaires.
>>> t = 'abc', 123, 45.67 # la virgule crée le tuple

>>> t # la représentation d’une tuple inclut toujours les ()
('abc', 123, 45.67)
>>> type(t)
<class 'tuple'>
>>> tp = ('abc', 123, 45.67) # les () évitent ambiguïté
>>> t == tp # le résultat est équivalent
True
30
>>> len((1, 'a', 2.3)) # dans ce cas les () sont nécessaires

3
>>> len(1, 'a', 2.3) # parce qu’ici la , sépare les arguments
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: len() takes exactly one argument (3 given)
Pour créer un tuple d’un élément, vous devez toujours utiliser une virgule, tandis que
pour créer un tuple vide, vous avez juste besoin de parenthèses :
>>> t = 'abc', # tuple d’un seul élément

>>> t
('abc',)
>>> tv = () # tuple vide, sans éléments
>>> tv
()
>>> type(tv) # vérifions si c’est un tuple
<class 'tuple'>
>>> len(tv) # vérifions s’il est vide, càd 0 élément
0
10.2. Utilisation de tuples
Les tuples sont un type de séquence (comme les strings) et prennent en charge les
opérations communes à toutes les séquences, telles que l’indexation, le tranchage, le
confinement (container), la concaténation et la répétition :
>>> t = ('abc', 123, 45.67)

>>> t[0] # les tuples supportent indexing
'abc'
>>> t[:2] # slicing
('abc', 123)
>>> 123 in t # les opérateurs de containero "in" et "not in"
True
>>> t + ('xyz', 890) # concaténation (retourne un nouveau tuple)
('abc', 123, 45.67, 'xyz', 890)
>>> t * 2 # répétition (retourne un nouveau tuple)
('abc', 123, 45.67, 'abc', 123, 45.67)
Les tuples sont immuables, donc une fois créés, vous ne pouvez pas ajouter,
supprimer ou modifier des éléments :
>>> t[0] = 'xyz' # Il n’est pas possible modifier les éléments

TypeError: 'tuple' object does not support item assignment
31
Vous pouvez également utiliser des fonctions et des méthodes communes à toutes les
séquences : len() pour compter les éléments, min() et max() pour trouver l’élément le plus
petit/le plus grand (tant que les types d’éléments sont comparables), index() pour trouver
l’index d’un élément, et count() pour compter combien de fois un élément est présent dans le
tuple :
>>> len(('abc', 123, 45.67, 'xyz', 890)) # nombre d’éléments

5
>>> min((4, 1, 7, 5)) # élément le plus petit
1
>>> max((4, 1, 7, 5)) # élément le plus grand
7
>>> t = ('a', 'b', 'c', 'b', 'a')
>>> t.index('c') # indice de l'élément 'c'
2
>>> t.count('c') # nombre d’occurrences de 'c'
1
>>> t.count('b') # nombre d’occurrences de 'b'
2
Dans la leçon suivante, nous verrons un autre type de séquence, la liste, et quelles sont les
différences entre les tuples et les listes.
Chapitre 11. Les Listes en Python

Python fournit également un type intégré appelé liste, qui est généralement utilisé
pour représenter une séquence d’objets mutables, généralement homogènes.
11.1. Définir des listes
Les listes sont définies en listant entre crochets ([]) une série d’objets séparés par des
virgules (,). Vous pouvez créer une liste vide en utilisant des crochets sans aucun élément à
l’intérieur.
>>> nums = [0, 1, 2, 3] # nouvelle liste de 4 éléments

>>> nums
[0, 1, 2, 3]
>>> type(nums) # Vérifions si c’est le type "list"
<class 'list'>
>>> empty = [] # nouvelle liste vide
>>> empty
[]
32
>>> one = ['Python'] # nouvelle liste avec un élément

>>> one
['Python']
11.2. Utiliser des listes
Comme les tuples et les chaînes, les listes sont également un type de séquence, et
prennent donc en charge les opérations communes à toutes les séquences, telles que
l’indexation, le découpage, le confinement, la concaténation et la répétition :
>>> letters = ['a', 'b', 'c', 'd', 'e']

>>> letters[0] # les listes supportent indexing
'a'
>>> letters[-1]
'e'
>>> letters[1:4] # slicing
['b', 'c', 'd']
>>> 'a' in letters # les opérateurs de container "in" et "not in"
True
>>> letters + ['f', 'g', 'h'] # concaténation (renvoie une nouvelle liste)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> [1, 2, 3] * 3 # répétition (renvoie une nouvelle liste)
[1, 2, 3, 1, 2, 3, 1, 2, 3]
Les listes prennent également en charge des fonctions et des méthodes communes à
d’autres séquences : len() pour compter les éléments, min() et max() pour trouver l’élément
le plus petit/le plus grand (tant que les types d’éléments sont comparables), .index() pour
trouver l’index d’un élément et .count() pour compter combien de fois un élément est présent
dans la liste :
>>> letters = ['a', 'b', 'c', 'b', 'a']
>>> len(letters) # nombre des éléments
5
>>> min(letters) # élément plus petit (alphabétiquement dans le cas de strings)
'a'
>>> max(letters) # élément plus grand
'c'
>>> letters.index('c') # indice de l’élément 'c'
2
>>> letters.count('c') # nombre d’occurrences de 'c'
1
>>> letters.count('b') # nombre d’occurrences de 'b'
2
33
Contrairement aux tuples et aux chaînes qui sont immuables, les listes peuvent être
modifiées. Vous pouvez ensuite attribuer une nouvelle valeur aux éléments, supprimer des
éléments à l’aide du mot clé del ou modifier les éléments à l’aide de l’une des méthodes
supplémentaires des listes :
- liste.append(elem) : ajoute elem à la fin de la liste ;
- liste.extend(seq) : étend, prolonge la liste en ajoutant à la fin les éléments de seq ;
- liste.insert(indice, elem) : ajoute elem à la liste dans la position indice ;
- liste.pop() : supprime et renvoie le dernier élement de la liste ;
- liste.remove(elem) : trouve et supprime elem de la liste ;
- liste.sort() : ordonne les éléments de la liste du plus petit au plus grand ;
- liste.reverse() : inverse l’ordre des éléments de la liste ;
- liste.copy() : crée et renvoie une copie de la liste ;
- liste.clear() : supprime tous les éléments de la liste ;
Voyons quelques exemples :
>>> letters = ['a', 'b', 'c']

>>> letters.append('d') # ajoute 'd' à la fin
>>> letters
['a', 'b', 'c', 'd']
>>> letters.extend(['e', 'f']) # ajoute 'e' et 'f' à la fin
>>> letters
['a', 'b', 'c', 'd', 'e', 'f']
>>> letters.append(['e', 'f']) # ajoute la liste comme élément à la fin
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', ['e', 'f']]
>>> letters.pop() # supprime et renvoie le dernier élément (la liste)
['e', 'f']
>>> letters.pop() # supprime et renvoie le dernier élément ('f')
'f'
>>> letters.pop(0) # supprime et renvoie l’élément en position 0 ('a')
'a'
>>> letters.remove('d') # supprime l’élément 'd'
>>> letters
['b', 'c', 'e']
>>> letters.reverse() # inverse l'ordre "sur le lieu" et ne renvoie rien
>>> letters # les éléments sont maintenant en ordre inverse
['e', 'c', 'b']
>>> letters[1] = 'x' # remplace l'élément en position 1 ('c') par 'x'
>>> letters
['e', 'x', 'b']
>>> del letters[1] # supprime l’élément en position 1 ('x')
>>> letters
34
['e', 'b']
>>> letters.clear() # supprime tous les éléments restés dans la liste
>>> letters
[]
Certaines de ces méthodes acceptent également des sujets supplémentaires que vous
pouvez voir en utilisant help(list.metodo) ou en consultant la documentation officielle sur
les listes.
11.3. Différences entre les tuples et les listes

Meme si à première vue les listes semblent être comme des « tuples mutables », en
réalité, elles sont utilisées dans différentes situations. Résumons, dans les lignes qui suivent,
les différences entre les tuples et les listes :
Tuples Listes
Mutabilité Immuable Muable
Longueur Fixe Variable
L’accès aux articles se fait via Indexation Itération
Ils contiennent généralement des objets Hétérogène Homogène
Similaire en C au type de données Struct Tableau
Comme les tuples sont immuables, leur longueur est fixe, et généralement chaque
élément du tuple a un rôle spécifique. Ces éléments, qui peuvent être de différents types, sont
généralement lus par indexation (tuple[indice]).
Les listes, en revanche, sont modifiables, de sorte que leur longueur est variable (des
éléments peuvent être ajoutés ou supprimés). Cela signifie que les éléments individuels n’ont
pas un rôle précis et sont généralement lus par itération (par exemple en utilisant un for), et
doivent donc également être du même type.
Une autre façon de comprendre la différence est de penser à un tableau d’une base de
données, telle que :
Prénom Nom Age
John Smith 20
Jane Johnson 30
Jack Williams 28
Mary Jones 25
Marc Brown 23
Chaque ligne du tableau peut être représentée par un tuple (par exemple (’John’,
‘Smith’, 20)) de 3 éléments hétérogènes (longueur fixe) (chaînes ou strings et entiers)
auxquels on peut accéder par indexation (par exemple t[1] pour le nom de famille). Chaque
colonne peut être représentée par une liste (par exemple ['John', 'Jane', 'Jack', ...]) de
longueur variable (les personnes peuvent être ajoutées ou supprimées) et d’éléments
homogènes (la colonne du nom n’a que des chaînes, celle de l’âge uniquement des nombres)
35
auxquels on accède par itération (par exemple imprimer la liste des noms de famille à l’aide
d’une boucle).
Vous pouvez également combiner les deux types et représenter le tableau entier sous la forme
d’une liste de tuples :
[('John', 'Smith', 20),
('Jane', 'Johnson', 30),
('Jack', 'Williams', 28),
...]
Dans le prochain chapitre, nous verrons un autre type de données intégrées : les
dictionnaires.
Chapitre 12. Les Dictionnaires

Les dictionnaires (dict) sont un type intégré, mutable et non ordonné qui contient des
éléments (items) formés par une clé (key) et une valeur (value). Une fois le dictionnaire créé
et amélioré avec un ensemble de paires <key, value>, il possible d’utiliser la clé (qui doit être
univoque) pour obtenir la valeur correspondante.dict
Les dictionnaires sont implémentés à l’aide de tables de hachage qui vous permettent
d’obtenir très efficacement la valeur correspondant à la clé, quel que soit le nombre
d’éléments dans le dictionnaire. La plupart des langages contiennent une structure de données
similaire, bien qu’appelée différemment : le type de hachage en Perl, Hashtable en Java ou
C#, les cartes MFC pour Visual C++, les tableaux (array) associatifs en PHP, etc.
12.1. Définir des dictionnaires
Les dictionnaires sont définis en listant entre accolades ({}) une série d’éléments
séparés par des virgules ( , ), où chaque élément se compose d’une clé et d’une valeur séparée
par un deux-points ( : ). Vous pouvez créer un dictionnaire vide à l’aide d’accolades sans
aucun élément à l’intérieur.
>>> d = {'a': 1, 'b': 2, 'c': 3} # nouveau dictionnaire de 3 éléments

>>> d
{'c': 3, 'a': 1, 'b': 2}
Dans cet exemple, nous pouvons voir qu’il s’agit d’un dictionnaire qui contient 3
éléments formés par une clé et une valeur. ‘a’, ‘b’ et ‘c’ sont les clés, tandis que 1, 2 et 3 sont
les valeurs. Nous pouvons également voir comment l’ordre des éléments est arbitraire,
puisque les dictionnaires ne sont pas ordonnés.
>>> d = {'a': 1} # dictionnaire d’un élément
36
>>> d
{'a': 1}
>>> type(d) # vérifions que le type soit "dict"
<class 'dict'>
>>> d = {} # dictionnaire vide
>>> d
{}
Les clés d’un dictionnaire sont généralement des chaînes (strings), mais vous pouvez
également utiliser d’autres types, à condition qu’elles soient « hashables » (les types
immuables le sont généralement). Les valeurs peuvent être de n’importe quel type.
>>> d = {20: ['Jack', 'Jane'], 28: ['John', 'Mary']} # int comme clé, liste comme valeurs
>>> d
{28: ['John', 'Mary'], 20: ['Jack', 'Jane']}
>>> d = {[0, 10]: 'premier intervalle'} # les listes ne sont pas hashables, ne sont pas
# des clés valides
TypeError: unhashable type: 'list'
>>> d = {(0, 10):'premier intervalle'} # les tuples oui
>>> d
{(0, 10): 'premier intervalle'}
12.2. Utiliser des dictionnaires
Une fois qu’on a créé un dictionnaire, on peut obtenir la valeur associée à une clé à
l’aide de la syntaxe : dictionnaire[clé].
>>> d = {'a': 1, 'b': 2, 'c': 3}

>>> d['a'] # renvoie la valeur associée à la clé 'a'
1
>>> d['c'] # renvoie la valeur associée à la clé 'c'
3
Si une clé inexistante est spécifiée, Python renvoie un KeyError. Toutefois, il est
possible d’utiliser les opérateurs in (ou not in) pour vérifier si une clé est présente dans le
dictionnaire :
>>> d = {'a': 1, 'b': 2, 'c': 3}

>>> d['x'] # si la clé n’existe pas, renvoie un KeyError
37
KeyError: 'x'
>>> 'x' in d # la clé 'x' n’est pas présente dans d
False
>>> 'x' not in d # la clé 'x' n’est pas présente dans d
True
>>> 'b' in d # la clé 'b' est présente
True
>>> d['b'] # la valeur associée à la clé 'b' est 2
2
Il est possible ajouter ou modifier des éléments à l’aide de la syntaxe

dictionnaire[clé] = valeur et les supprimer à l’aide de la syntaxe del dictionnaire[clé] :
>>> d = {'a': 1, 'b': 2, 'c': 3}

>>> d['a'] = 10 # modifie la valeur associée à une clé existante
>>> d
{'c': 3, 'a': 10, 'b': 2}
>>> d['x'] = 123 # crée un nouvel élément, avec clé 'x' et valeur 123
>>> d
{'x': 123, 'c': 3, 'a': 10, 'b': 2}
>>> del d['x'] # supprime l'élément (clé et valeur) avec clé 'x'
>>> d
{'c': 3, 'a': 10, 'b': 2}
Les dictionnaires prennent également en charge plusieurs méthodes :

Méthode Description
d.items() Renvoie les éléments de d comme un ensemble des tuples
d.keys() Renvoie les clés de d
d.values() Renvoie les valeurs de d
d.get(clé, default) Renvoie la valeur correspondant à clé si celle-ci est présente.
Autrement, la valeur de default (None si ce n’est pas spécifié)
d.pop(clé, default) Supprime et renvoie la valeur correspondant à clé si celle-ci est
présente. Sinon, la valeur de default (si ce n’est pas spécifié, ça donne
KeyError
d.popitem() Supprime et renvoie arbitrairement un élément de d
d.update(d2) Ajoute les éléments du dictionnaire d2 à d
d.copy() Crée et renvoie une copie de d
d.clear() Supprime tous les éléments de d
>>> d = {'a': 1, 'b': 2, 'c': 3} # nouveau dictionnaire de 3 éléments

>>> len(d) # vérification pour savoir s’il y a 3 éléments
3
>>> d.items() # renvoie les éléments
dict_items([('c', 3), ('a', 1), ('b', 2)])
38
>>> d.keys() # renvoie les clés

dict_keys(['c', 'a', 'b'])
>>> d.values() # renvoie les valeurs
dict_values([3, 1, 2])
>>> d.get('c', 0) # renvoie la valeur correspondante à 'c'
3
>>> d.get('x', 0) # renvoie la valeur à défaut default 0 parce que 'x' n’est pas présent
0
>>> d # le dictionnaire contient encore tous les éléments
{'c': 3, 'a': 1, 'b': 2}
>>> d.pop('a', 0) # renvoie et supprime la valeur correspondante à 'a'
1
>>> d.pop('x', 0) # renvoie le default 0 parce que 'x' n’est pas présent
0
>>> d # l'élément avec clé 'a' a été supprimé
{'c': 3, 'b': 2}
>>> d.pop('x') # sans default et avec clé inexistante donne erreur
KeyError: 'x'
>>> d.popitem() # renvoie et supprime arbitrairement un élément
('c', 3)
>>> d # l'élément avec clé 'c' a été supprimé
{'b': 2}
>>> d.update({'a': 1, 'c': 3}) # ajoute de nouveau les éléments 'a' e 'c'
>>> d
{'c': 3, 'a': 1, 'b': 2}
>>> d.clear() # supprime tous les éléments
>>> d # En lançant un dictionnaire vide
{}
Il existe également d’autres méthodes qui sont utilisées plus rarement, et qui peuvent
être consultées en utilisant dir(dict) et help(dict.metodo) ou en consultant la documentation
officielle sur les dictionnaires.
Dans le chapitre suivant, nous verrons un autre type de données intégrées : les
ensembles.
Chapitre 13. Set et Frozenset
En plus des listes, des tuples et des dictionnaires, Python fournit deux autres
conteneurs intégrés : set et frozenset. Les set (collections) sont utilisés pour représenter un
39
ensemble non ordonné d’objets uniques. Cette séquence est mutable dans le cas des set, et
immuable dans le cas des frozenset (Collections ou Ensembles figés).
13.1. Définir des set (ensembles ou collections) et des frozenset
Les set (collections ou ensembles) sont définis en listant entre accolades ({}) une série
d’objets séparés par des virgules (,). Bien que les set et les dictionnaires utilisent des
accolades, Python est capable de les distinguer car les dictionnaires contiennent des clés et
des valeurs séparées par les deux points. Étant donné que la syntaxe est déjà utilisée pour
définir un dictionnaire vide, il n’y a pas de syntaxe disponible pour créer un set (ensemble)
vide, mais elle peut être définie à l’aide de set(). De plus, pour le frozenset, il n’y a pas de
syntaxe dédiée, mais il est possible d’utiliser frozenset(...).
>>> nums = {10, 20, 30, 40} # nouveau set de 4 éléments

>>> nums # les éléments du set ne sont pas ordonnés
{40, 10, 20, 30}
>>> type(nums) # vérifions si c’est le type "set"
<class 'set'>
>>> fnums = frozenset(nums) # nouveau frozenset à partir du set nums
>>> fnums
frozenset({40, 10, 20, 30})
>>> type(fnums) # vérifions que le type soit soit "frozenset"
<class 'frozenset'>
>>> {'Python'} # set d’un élément (une string ou chaine)
{'Python'}
>>> empty = set() # nouveau set vide
>>> empty
set()
>>> type({}) # {} crée un dict vide
<class 'dict'>
>>> type(set()) # set() crée un set vide
<class 'set'>
>>> type(frozenset()) # frozenset() crée un frozenset vide
<class 'frozenset'>
Nous avons vu que les éléments des set doivent être uniques : s’ils ne le sont pas,
Python supprimera automatiquement les doublons. Les éléments d’un set, ainsi que les clés
d’un dictionnaire, doivent également être hashables. En outre, set() et frozenset() ils
acceptent en entrée (input) tout ce qui est itérable (comme des chaînes ou des listes), et il est
possible ensuite de créer un nouveau set contenant les éléments uniques à partir d’un autre
objet.
>>> {1, 2, 3, 2, 1} # les éléments sont uniques, les doublures sont supprimées
{1, 2, 3}
>>> set('abracadabra') # trouve l'ensemble des lettres dans la string 'abracadabra'
{'d', 'b', 'a', 'c', 'r'}
>>> frozenset('abracadabra')
frozenset({'d', 'b', 'a', 'c', 'r'})
40
>>> {'a', 1, (3, 14)} # les éléments devraient être hashables

{1, 'a', (3, 14)}
>>> {'a', 1, (3, 14), [3, 2, 1]} # sinon, Python renvoie TypeError
TypeError: unhashable type: 'list'
13.1. Utilisation de set et de frozenset
set et frozenset prennent en charge certaines opérations de base :
>>> nums = {10, 20, 30, 40}

>>> len(nums) # nombre des éléments
4
>>> min(nums) # élément plus petit
10
>>> max(nums) # élément plus grand
40
>>> 10 in nums # contenu dans nums
True
>>> 50 not in nums
True
>>> 60 in nums
False
Les set prennent également en charge plusieurs méthodes :

- set.add(elem) : ajoute elem à set ;
- set.remove(elem) : supprime elem du set, renvoie un KeyError si l’élément n’est pas
présent ;
- set.discard(elem) : supprime elem du set s’il est présent ;
- set.pop() : supprime et renvoie un élément arbitraire du set ;
- set.copy() : crée et renvoie une copie du set ;
- set.clear() : supprime tous les éléments du set ;
Parmi ces méthodes, seule copy() est prise en charge par frozenset, puisque les autres
méthodes modifient le set.
>>> nums = {10, 20, 30, 40} # nouveau set de 4 éléments

>>> nums.add(50) # ajoute 50
>>> nums
{40, 10, 20, 50, 30}
>>> nums.remove(10) # supprime 10
>>> nums
{40, 20, 50, 30}
>>> nums.remove(10) # renvoie KeyError parce que 10 n’est plus présent
KeyError: 10
41
>>> nums.discard(20) # supprime 20

>>> nums
{40, 50, 30}
>>> nums.discard(20) # si l'élément n’est pas présent, discard ne donne pas erreur
>>> nums.pop() # supprime et renvoie un élément arbitraire
40
>>> nums
{50, 30}
>>> nums.clear() # supprime les éléments qui sont restés
>>> nums
set()
Les set prennent également en charge un certain nombre d’opérations d’ensemble

typiques. Certaines de ces opérations sont mises en œuvre à la fois par des méthodes (pour la
lisibilité) et par des opérateurs (pour plus de commodité) :
Opérateur Méthode Description
Renvoie True ssi les 2 set n’ont des

s1.isdisjoint(s2) éléments en commun
Renvoie True ssi s1 est un sous set

s1 <= s2 s1.issubset(s2) (sous-ensemble) de s2
Renvoie True ssi s1 est un sous-

s1 < s2 ensemble propre de s2
Renvoie True ssi s2 est un sous-

s1 >= s2 s1.issuperset(s2) ensemble propre de s1
s1 > s2 Renvoie True ssi s2 est un sous-

ensemble propre de s1
Renvoie l’union des ensembles (tous

s1 | s2 | ... s1.union(s2, ...) les éléments)
s1 & s2 & ... s1.intersection(s2, ...) Renvoie l’intersection des

ensembles (éléments en commun à
tous les set
Renvoie la différence entre tous les

s1 - s2 - ... s1.difference(s2, ...) ensembles (éléments de s1 qui ne
sont pas dans les autres set
Renvoie les éléments de deux

s1 ^ s2 s1.symmetric_difference(s2) ensembles sans ceux qui leur sont
communs
42
s1 |= s2 | ... s1.update(s2, ...) Ajoute à s1 les éléments des autres

ensembles
s1 &= s2 & s1.intersection_update(s2, ...) Ajourne s1 de sorte qu’il contienne

... seulement les éléments communs à
tous les set
s1 -= s2 | ... s1.difference_update(s2, ...) Supprime de s1 tous les éléments

contenus dans les autres set
Ajourne s1 de sorte qu’il contienne

s1 ^= s2 s1.symmetric_difference_update(s2) seulement les éléments non communs
aux 2 set
>>> {1, 2, 3}.isdisjoint({4, 5, 6}) # sont disjoints, ils n’ont pas d’éléments en commun
True
>>> {1, 2, 3}.isdisjoint({3, 4, 5}) # ont un élément en commun (le 3)
False
>>> {2, 4} >= {1, 2, 3, 4} # le premier est un sous-ensemble du second
True
>>> {2, 4} > {1, 2, 3, 4} # il est aussi un sous-ensemble propre
True
>>> {1, 2, 3} >= {1, 2, 3} # le premier est un sous-ensemble du second
True
>>> {1, 2, 3} > {1, 2, 3} # mais ce n’est pas un sous-ensemble propre
False
>>> {1, 2, 3} | {2, 3, 4} | {3, 4, 5} # union de tous les éléments
{1, 2, 3, 4, 5}
>>> {1, 2, 3} & {2, 3, 4} & {3, 4, 5} # intersection (éléments communs)
{3}
>>> {1, 2, 3, 4, 5} - {1, 2} - {2, 3} # différence
{4, 5}
>>> {1, 2, 3, 4} ^ {3, 4, 5, 6} # éléments non communs
{1, 2, 5, 6}
>>> s1 = {1, 2, 3}
>>> s1 |= {2, 3, 4} | {3, 4, 5} # ajoute à s1 les éléments des 2 autres set
>>> s1
{1, 2, 3, 4, 5}
Pour plus d’informations sur les set et les frozenset, il est possible consulter la
documentation officielle sur les set.
Chapitre 14. Types built-in (intégrés) : Résumé
43
Dans les précédents chapitres, nous avons vu plusieurs types intégrés disponibles dans
Python. Ces types seront très utiles dans diverses situations et il est donc essentiel
d’apprendre à les utiliser de la manière la plus appropriée. Dans ce chapitre, nous allons le
résumer, en offrant un aperçu de tous les types disponibles en Python.
14.1. Tableau récapitulatif
Types de Nom Description Exemples

données
Entier int Entier de taille arbitraire -42 , 0 , 1200 ,
9999999999999999
Réel float Nombre à virgule flottante 3.14 , 1.23e-10 ,
4.0E210
Boléen bool Pour les valeurs True ou False True , False
Complexe complex Nombre complexe avec partie 3 + 4j , 5.0 + 4.1j ,
réelle et imaginaire 3j
Chaine ou str Utiliser pour représenter le texte ‘ ‘ , ‘daniel’ ,
string “l’eau”
b” , b’\x00\x01\x02’
Octets bytes Utiliser pour représenter les octets ,
b’Python’
Listes list Séquence d’objets modifiable [ ] , [1, 2, 3] ,
['Hello', 'World']
Tuples tuple Séquence immuable d’objets ( ) , (1, 2, 3) ,
('Python', 3)
Ensembles Set , Ensemble d’objets uniques {1, 2, 3} ,
frozenset {'World', 'Hello'}
{},
Dictionnaires dict Structures associant des clés à des {'nome': 'Ezio',
valeurs 'cognome':
'Melotti'}
Dans les leçons précédentes, nous avons vu que les types de données peuvent être
immuables ou mutables. Les nombres (int , float , complex , bool), chaînes (str), les bystes
et les frozenset sont immuables ; les listes (list), les ensembles (set) et les dictionnaires
(dict) sont, par contre, modifiables.
La plupart de ces types peuvent être définis à l’aide de littéraux (en anglais literals),
c’est-à-dire d’une syntaxe dédiée qui peut être vue dans le tableau sous la colonne «
Exemples ». Cependant, il existe des exceptions : il n’y a pas de forme littérale pour définir
des set ou ensembles vides (vous pouvez utiliser set()) et frozenset (vous pouvez les créer à
partir d’autres types, tels que frozenset({1, 2, 3})).
Il est également possible de créer de nouveaux objets "en appelant" les types
répertoriés dans la deuxième colonne du tableau. Si aucun argument n’est passé pendant
l’appel, la valeur renvoyée sera 0 dans le cas de nombres ou un objet vide dans d’autres cas :
par exemple, float() renverra 0.0 et list() retournera [ ].
14.2. Conversion entre les types
44
Contrairement à d’autres langages tels que C, où le type de données est lié à la

variable qui le contient, en Python, le type est lié à l’objet lui-même et ne peut pas être
modifié. Cela signifie qu’il n’est pas possible de convertir (cast) une variable ou un objet
d’un type à un autre. Étant donné que le type d’un objet ne peut pas être modifié, en Python,
la conversion ne modifie pas l’objet d’origine, mais en crée de nouveaux à partir d’objets
existants.
Cette opération peut être effectuée en passant l’objet que nous voulons convertir au
type vers lequel nous voulons le convertir. Par exemple, si nous voulons convertir une liste en
un set (ensemble), nous pouvons utiliser : set(lista) :
>>> mylist = [1, 2, 3, 2, 1] # définit une liste

>>> myset = set(mylist) # crée un nouvel ensemble à partir de la liste
>>> myset # l'ensemble contient les mêmes éléments (sans duplicata)
{1, 2, 3}
>>> mylist # la liste originale existe encore
[1, 2, 3, 2, 1]
Si nous voulons, à la place, convertir une chaîne en nombre, nous pouvons procéder
comme suit :
>>> mystr = '3.14' # définit une string

>>> myfloat = float(mystr) # crée un nouveau float à partir de la string
>>> myfloat # le float correspond au nombre de la string
3.14
>>> mystr # la string originale existe encore
'3.14'
Il est également possible de convertir une liste de tuples en dictionnaire :
>>> mylist = [('a', 1), ('b', 2), ('c', 3)]

>>> mydict = dict(mylist)
>>> mydict
{'c': 3, 'a': 1, 'b': 2}
Chaque type accepte des différentes entrées input, mais ce ne sont pas toutes les
conversions qui sont possibles. Par exemple, il n’est pas de convertir une liste en entier int ou
un int en liste. Si nous passons un objet qui ne peut pas être converti, Python renverra un
message de type : TypeError ou ValueError.
>>> int('un milione') # str est un type valide, mais la valeur ne peut pas être converti
File "", line 1, in
45
ValueError: invalid literal for int() with base 10: 'un milione'
>>> int([1, 2, 3]) # list ne pas un type valide, donc un TypeError sera renvoyé
File "", line 1, in
TypeError: int() argument must be a string, a bytes-like object or a number, not 'list'
Vous pouvez également créer des copies d’un objet sans modifier son type. Par
exemple :
>>> mylist1 = [1, 2, 3] # crée une liste

>>> mylist2 = list(mylist1) # crée une nouvelle liste (une copie) en partant de mylist1
>>> mylist2 # la copie contient les mêmes éléments de l'originale
[1, 2, 3]
>>> mylist1.append(4) # peut modifier l'originale en ajoutant un élément
>>> mylist1 # l'élément 4 est ajouté à la liste originale
[1, 2, 3, 4]
>>> mylist2 # mais pas à la copie
[1, 2, 3]
14.3. Autres types de données
Tous les types répertoriés dans le tableau au début de ce chapitre sont intégrés, c’est-
à-dire qu’ils sont toujours disponibles sans qu’il soit nécessaire d’importer quoi que ce soit.
En plus de ces types de données intégrés, il existe également plusieurs autres types non
intégrés qui peuvent être importés à partir de modules de bibliothèque standard, notamment :
- le module decimal définit un type Decimal qui vous permet de travailler avec des
nombres à virgule flottante avec précision, en surmontant certaines limitations de
nombres float ;
- le module fractions définit un type Fraction qui vous permet de représenter et de

travailler avec des nombres rationnels à l’aide de fractions ;
-le module collections définit plusieurs types de conteneurs, notamment namedtuple

(un tuple qui permet d’accéder aux éléments par nom, plutôt que par emplacement),
OrderedDict (un dictionnaire qui maintient l’ordre dans lequel les éléments sont
insérés), defaultdict (un dictionnaire qui vous permet de spécifier une valeur par
défaut), Counter (un dictionnaire qui compte le nombre d’occurrences de chaque
élément).
Avant de pouvoir utiliser ces types, il est indispensable de les importer en utilisant import,
comme nous le verrons mieux dans l’un des prochains chapitres.
Chapitre 15. Instructions conditionnelles
46
Dans ce chapitre, nous verrons comment implémenter des instructions conditionnelles

en Python à l’aide du constructeur if-elif-else. Les instructions conditionnelles sont utilisées
lorsque nous voulons exécuter un bloc de code uniquement dans le cas où une condition est
vraie ou fausse.
15.1. Le construit if-elif-else
Le constructeur if-elif-else vous permet d’exécuter différentes instructions ou groupes
d’instructions en fonction de l’occurrence d’une ou plusieurs conditions. La forme la plus
simple implique l’utilisation d’un if suivi d’une condition et deux-points (:) et d’un bloc de
code en retrait qui ne s’exécute que si la condition est vraie :
if condition:
# groupe d’instructions exécutées
# si la condition est vraie
Par exemple, pour calculer la valeur absolue d’un nombre, nous pouvons procéder
comme suit :
n = int(input('Insérer un nombre: '))

if n < 0: # si le nombre est négatif
n = -n # rend-le positif
print('La valeur absolue est', n)
Dans ce cas, le bloc de code en retrait sous le if (c’est-à-dire n = -n) n’est exécuté que
si le nombre est négatif. Si le nombre est positif, le programme procède à l’exécution de
l’instruction qui suit le if, c’est-à-dire le print(). En ajoutant un else suivi de deux-points (:),
nous pouvons également spécifier un bloc de code exécuté lorsque la condition de l’if est
fausse (false) :
if condition:
# si la condition est vraie true
else:
# si la condition est fausse false
Dans ce cas, Python exécutera le premier bloc si la condition est vraie, ou le

deuxième bloc si la condition est false. Par exemple :
n = int(input('Insère un nombre: '))

if n < 0: # si le nombre est négatif
print(n, 'est négatif')
else: # sinon (si le nombre n’est pas négatif)
print(n, 'est positif')
47
Dans ce cas, le programme effectuera l’un des deux print() : le premier si le nombre
entré par l’utilisateur est négatif, le second s’il est positif.
Enfin, vous pouvez ajouter 1 ou plusieurs elif, chacun suivi d’une condition, deux-
points (:) et d’un bloc de code en retrait qui ne s’exécute que si la condition est vraie. Vous
pouvez également ajouter un simple else à la fin qui s’exécute ssi toutes les conditions ci-
dessus sont fausses :
if condition1:
# si la condition 1 est vraie
elif condition2:
# si la condition 2 est vraie
elif conditionN:
# si la conditionN est vraie
else:
# si les conditions sont fausses
Notez qu’un seul de ces blocs est exécuté : si l’une des conditions est vraie, le bloc
correspondant est exécuté ; si, en revanche, toutes les conditions sont fausses et que un else
est présent, seul le bloc de l’else est exécuté. Dans le cas où il y a plus de conditions vraies,
seul le bloc correspondant à la première condition vraie sera effectué.

if n < 0:
elif n > 0:
else:
print(n, 'est zero')
Ce programme utilise if et elif pour vérifier respectivement si le nombre entré par

l’utilisateur est négatif ou positif. Si les deux conditions sont fausses (c’est-à-dire lorsque le
nombre est égal à 0), l’else est exécuté.
15.2. Indentation
Dans l’une des leçons précédentes, nous avons vu que des langages comme C utilisent
des accolades ({}) pour délimiter des blocs de code, alors qu’en Python, il suffit d’utiliser
l’indentation, en ajoutant ou en supprimant 4 espaces pour chaque couche (niveau). Dans les
deux exemples suivants, nous verrons qu’un code apparemment similaire a des significations
différentes en fonction de l’indentation.
48
Dans ce premier exemple, le else a le même niveau d’indentation que le second if, et
est ensuite exécuté lorsque cond1 est vraie et cond2 est fausse :
if cond1:
print('cond1 est vraie)
if cond2:
print('cond1 est vraie, cond2 est vraie')
else:
print('cond1 est vraie, cond2 est fausse')
Dans cet autre exemple, le else a le même niveau d’indentation que le premier if, et il
est ensuite exécuté lorsque cond1 est fausse. Dans l’exemple suivant, voyons comment il est
possible d’utiliser plusieurs if-else pour obtenir le même résultat qu’un if-elif-else :
if n == 0:
# si le nombre est zéro
print(n, 'est zéro')
else:
# si le nombre n’est pas zéro
if n > 0:
else:
De ce qui précède, on peut donc noter ce qui suit :

- Le premier print est indenté (mis en retrait) sous l’if et donc il sera exécuté si la
condition n == 0 est vérifiée (c’est-à-dire est vraie),
- Le premier else a le même niveau d’indentation que le premier if. Par conséquent, il
est exécuté ssi la condition n == 0 n’est pas vérifiée (c’est-à-dire est fausse),
- Indenté sous le premier else, il y a un bloc de code de quatre lignes incluant un autre
if-else,
- Le second print() a deux niveaux d’indentation. Il est exécuté ssi la première
condition (n == 0) est fausse et la seconde, (n > 0), est vraie,
- Le second else a le même niveau indentation que le second if. Donc, il sera exécuté
seulement si la condition (n > 0) n’est pas vérifiée (c’est-à-dire est fausse),
- Le troisième et dernier print() a deux niveaux d’indentation. Il est exécuté ssi la
première condition (n == 0) et la seconde (n > 0) ne sont pas toutes vérifiées (c’est-à-
dire lorsqu’elles sont toutes fausses).
15.3. Remplacer le switch-case (boitier de commutation)
Une autre construction conditionnelle présente dans plusieurs autres langages est le
switch-case. Il vous permet de spécifier une variable, suivie de plusieurs cas qui seront
exécutés en fonction de la valeur de la variable. L’exemple suivant montre une partie d’un
programme en C qui exécute plusieurs blocs de code en fonction de la valeur de la variable
n:
// exemple en C
switch (n) {
49
case 0:
printf('zéro\n');
break;
case 1:
case 2:
printf('un o deux\n');
break;
case 3:
printf('trois\n');
break;
default:
printf('nombre différent de 0, 1, 2, 3\n');
break;
}
Ce programme C imprime sur le moniteur zéro si la valeur de n est 0, un ou deux si

la valeur de n est respectivement un ou deux, trois si la valeur est 3. Sinon, il imprime
numéro différent de 0, 1, 2, 3. En Python il n’y a pas de construction switch-case, mais il
est néanmoins possible d’obtenir le même résultat simplement en utilisant un if-elif-else.
# exemple en Python
if n == 0:
print('zéro')
elif n == 1 or n == 2:
print('un ou deux')
elif n == 3:
print('trois')
else:
print('nombre différent de 0, 1, 2, 3')
Il existe également un cas particulier d’utilisation de switch où pour chaque cas

d’utilisation correspond à un appel à une fonction. L’exemple suivant montre une partie d’un
programme en C qui convertit la variable num en binaire, octal ou hexadécimal en fonction
de la lettre indiquée par la variable conv :
// exemple en C
switch (conv) {
// binaire
case 'b':
res = bin(num);
break;
// octal
case 'o':
res = oct(num);
break;
50
// hexadécimal
case 'x':
res = hex(num);
break;
default:
printf('Conversion non valide');
break;
}
Un résultat similaire peut être obtenu en Python à l’aide de dictionnaires :

# exemple en Python
num = int(input('Insère un nombre: '))
conv = input('Insère type de conversion [b/o/x]: ')
funcs = dict(b=bin, o=oct, x=hex)
if conv in {'b', 'o', 'x'}:
func = funcs[conv]
res = func(num)
print('Le résultat de la conversion est:', res)
else:
print('Conversion non valide')
Cet exemple :
- Demande à l’utilisateur d’insérer num et conv,
- Définit un dictionnaire funcs qui mappe les lettres b/o/x aux fonctions de conversion
correspondante,
- Vérifie si la conversion spécifiée est valide ou non,
- Si c’est le cas, il obtient la fonction correspondant (func) à la lettre (conv) et l’utilise
pour convertir le nombre,
- Si ce n’est pas le cas, imprimez un message d’erreur.
Dans le chapitre suivant, nous verrons comiment utiliser les cycles.
Chapitre 16. Les Cycles for et while (pour et pendant)

En Python, il existe deux types de boucles (également appelées loop) :
- La boucle for : effectue une itération pour chaque élément d’un itérable ;
- Le cycle while : itera tant qu’une condition est vraie.
16.1. Le cycle ou boucle for
51
La boucle for nous permet d’itérer sur tous les éléments d’un itérable et d’exécuter
un certain bloc de code. Un itérable est tout objet qui peut renvoyer tous les éléments les uns
après les autres, tels que des listes, des tuples, des ensembles, des dictionnaires (clés de
retour), etc. Voyons un exemple simple d’un cycle for :
>>> # imprime le carré de chaque nombre de seq
>>> seq = [1, 2, 3, 4, 5]
>>> for n in seq:
... print('Le carré de', n, 'est', n**2)
...
Le carré de 1 est 1
On peut noter que :
52

Cours D'introduction À La Programmation II - 082952

Transféré par

Droits d'auteur :

Formats disponibles

Cours D'introduction À La Programmation II - 082952

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours D'introduction À La Programmation II - 082952

Transféré par

Droits d'auteur :

Formats disponibles

Institut Supérieur Technique du Sankuru

Cours d’Introduction à la Programmation II

Par Christophe LWANYI ASHIMALU,

Année Académique 2021 - 2022

Plan du Cours : Premiers pas avec le langage Python

Variables et types de données

Programmation avec Python

Programmation orientée objet avec Python

Interface Graphique avec Python

33. Python et Java

Chapitre 1. Introduction et un peu d’histoire

1.1. Différences entre Python 2 et Python 3

Chapitre 2. Pourquoi utiliser Python ?

2.1. Python : Les points forts

2.1.1. C’est gratuit

2.1.3. Il est portable

2.1.10. Programmation GUI

Chapitre 3. Installer Python sur Windows, Linus et Mac

Si la sortie inclut la chaîne C:\Python3X,vous pouvez démarrer Python en tapant

3.3. Démarrage de Python

Enfin, voyons comment installer Python en compilant les sources.

Il ne reste plus qu’à démarrer l’installation :

Remarque : Vous pouvez utiliser

Une fois ouvert le fichier, nous ajoutons la ligne suivante :

Chapitre 4. L’Interpréteur Python et l’IDLE

Exécution en ligne de commande

Revenons à l’accent mis sur le fonctionnement de base de l’interprète interactif.

4.1. Exécution de scripts .py

4.2. Utilisation d’IDLE

Commençons à nous familiariser avec cet outil.

4.3. Ouvrir et exécuter un fichier

4.4. Personnaliser l’IDE

Chapitre 5. Les fonctions print et input

Dans ce chapitre, nous apprendrons à connaître deux fonctions de base de Python :

Cette possibilité n’est disponible qu’auprès de l’interprète interactif ; toutefois,

>>> name = input('Insert your name: ')

Dans cet exemple, nous pouvons voir que :

>>> rayon = input('Insert rayon: ')

Dans cet exemple, nous pouvons voir que :

6.1. Indentation et blocs de code

1. le langage est plus clair et plus lisible ;

print("exécute toujours au début")

Dans ce script on peut faire ce constat :

Chapitre 7. Variables et Commentaires en Python

Type de données Nom Description Exemples

modifiable ['Hello', 'World']

7.3. Noms des variables

7.4. Affectation multiple

>>> a, b, c = 2, 3, 5 # assignation multiple

7.5. Les Commentaires

# Ce commentaire occupe plusieurs lignes, et chaque ligne

Python ignorera automatiquement tout ce qui suit le caractère # jusqu’à la fin de la

Chapitre 8. Les Nombres et les Opérateurs logiques en Python

Comme nous l’avons vu précédemment, en Python, il existe 4 types de données

>>> 0xFF # entier en notation hexadécimale (préfixe 0x)

8.1. Les Opérateurs arithmétiques

Opérateur Descrizione Exemple

8.2. Opérateurs de comparaison

Opérateur Description Exemples