Vous êtes sur la page 1sur 250

THON

GÈRE DANS:
GAGES DE PROGRAMMATION/
P Oui TH
P Oui THON
CR
R UNES SH CC O U
UNE URS
SE
UNE HANDS - ON, PROJET - BASED

INTRODUCTION AU PROGRAMME MING

ERICMATTHES

a
Cours intensif Python
Python
Cours intensif
une approche pratique, basée sur des projets
Introduction à la programmation

par Er ic Mat thes

San Francisco
Cours intensif Python. Copyright © 2016 par Eric Matthes.

Tous les droits sont réservés. Aucune partie de ce travail ne peut être reproduite ou transmise sous quelque forme ou par quelque moyen que ce soit,
électronique ou mécanique, y compris la photocopie, l'enregistrement, ou par tout système de stockage ou de récupération d'informations, sans l'autorisation
écrite préalable du titulaire du droit d'auteur et de l'éditeur.

Première impression

19 18 17 16 15 123456789

ISBN-10: 1-59327-603-6
ISBN-13: 978-1-59327-603-4

Éditeur: William Pollock


Éditeur de production: Riley Hoffman Illustration
de la couverture: Josh Ellingson Design
d'intérieur: Octopod Studios
Rédacteurs en développement: William Pollock, Liz Chadwick et Leslie Shen Réviseur
technique: Kenneth Love
Rédacteur: Anne Marie Walker
Compositeur: Riley Hoffman
Correcteur: James Fraleigh

Pour plus d'informations sur la distribution, les traductions ou les ventes en gros, veuillez contacter No Starch Press, Inc. directement:

Pas de Starch Press, Inc.


245 8th Street, San Francisco, CA 94103 téléphone:
415.863.9900; info@nostarch.com
www.nostarch.com

Données de catalogage avant publication de la Bibliothèque du Congrès

Matthes, Eric, 1972-


Cours accéléré Python: une introduction pratique à la programmation par projet / par Eric Matthes.
pages cm
Comprend un index.

Résumé: "Une introduction à la programmation en Python basée sur des projets, avec des exercices. Couvre les concepts généraux de programmation,
les principes de base de Python et la résolution de problèmes. Comprend trois projets: comment créer un jeu vidéo simple, utiliser des techniques de
visualisation de données pour créer des graphiques et des graphiques, et créer une application Web interactive "- Fourni par l'éditeur.

ISBN 978-1-59327-603-4 - ISBN 1-59327-603-6


1. Python (langage de programme informatique) I. Titre. QA76.73.P98M38
2015
005.13'3 - dc23
2015018135

No Starch Press et le logo No Starch Press sont des marques déposées de No Starch Press, Inc. Les autres noms de produits et de sociétés
mentionnés dans le présent document peuvent être des marques de commerce de leurs propriétaires respectifs. Plutôt que d'utiliser un symbole de
marque à chaque occurrence d'un nom de marque, nous n'utilisons les noms que de manière éditoriale et au profit du propriétaire de la marque,
sans intention de contrefaçon de la marque.

Les informations contenues dans ce manuel sont distribuées «telles quelles», sans garantie. Bien que toutes les précautions aient été prises dans la
préparation de ce travail, ni l'auteur ni No Starch Press, Inc. ne pourront être tenus responsables envers toute personne ou entité en ce qui concerne toute
perte ou dommage causé ou prétendument causé directement ou indirectement par le les informations qu'il contient.
A propos de l'auteur

Eric Matthes est un professeur de sciences et de mathématiques au lycée vivant en Alaska, où il


enseigne un cours d'introduction à Python. Il écrit des programmes depuis l'âge de cinq ans. Eric se
concentre actuellement sur l'écriture de logiciels qui abordent les inefficacités dans l'éducation et
apportent les avantages des logiciels open source au domaine de l'éducation. Dans ses temps libres, il
aime escalader les montagnes et passer du temps avec sa famille.

à propos du réviseur technique


Kenneth Love est programmeur et enseignant Python depuis de nombreuses années. Il a donné des
conférences et des tutoriels lors de conférences, fait des formations professionnelles, a été pigiste Python
et Django, et enseigne maintenant pour une entreprise d'éducation en ligne. Kenneth est également le
co-créateur du paquet django-braces, qui fournit plusieurs mixins pratiques pour les vues basées sur les
classes de Django. Vous pouvez le suivre sur Twitter à @kennethlove.
Pour mon père, qui a toujours pris le temps de répondre à
mes questions sur la programmation, et pour Ever, qui
commence tout juste à me poser
ses questions
Contenu Br I ef

Remerciements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxvii Introduction. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxix

Partie I: BasICs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Chapitre 1: Mise en route. . . . . . . . Chapitre 2: ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3

Variables et données simples Chapitre 3: Les types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Présentation des listes. . . . . . . . Chapitre 4: ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Utilisation des listes. . . . . . Chapitre 5: ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

déclarations if. . . . . . . . . . Chapitre 6: ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

Dictionnaires. . . . . . . . . . . Chapitre 7: Entrée ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

utilisateur et boucles while Chapitre 8: Fonctions. ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

. . . . . . . . . . . Chapitre 9: Classes. . . . . . . . . . . . . ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

. Chapitre 10: Fichiers et exceptions. . . . Chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

11: Test de votre code. . . . . ..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

Partie II: ProjeCts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

Projet 1: Invasion extraterrestre

Chapitre 12: Un navire qui tire des balles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Chapitre 13:

Extraterrestres! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 Chapitre 14: Notation. . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
Projet 2: Visualisation des données

Chapitre 15: Génération de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 Chapitre 16:

Téléchargement de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 Chapitre 17: Utilisation des API.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

Projet 3: Applications Web

Chapitre 18: Premiers pas avec Django. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397 Chapitre 19: Comptes

utilisateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 Chapitre 20: Stylisation et déploiement d'une

application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455

Postface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483

Annexe A: Installation de Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485 Annexe B: Éditeurs de

texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491 Annexe C: Obtention d'aide. . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . 499 Annexe D: Utilisation de Git pour le contrôle de version. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . 505

Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515

X Sommaire bref
Contenu s In De ta I l

Remerciements xxvii

Introduction xxix
Pour qui est ce livre? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxx Que pouvez-vous vous
attendre à apprendre? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxx Pourquoi Python? . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xxxi

Partie I: BasICs 1

1
commencer 3
Configuration de votre environnement de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..3

Python 2 et Python 3. . . . . . . . Exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..4

d'extraits de code Python Hello World! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..4

. . . . . . . Python sur différents systèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..4

d'exploitation .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..5

Python sur Linux. . . . . . . . . . . . . Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..5

sur OS X. . . . . . . . . . . . Python sous . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..8

Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dix

Dépannage des problèmes d'installation. . . . . . Exécution de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15


programmes Python à partir d'un terminal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Sous Linux et OS X. . . . . . . . . . Sous . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Exercice 1-1: python.org. . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1-2: Hello World Typos. Exercice 1-3: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Compétences infinies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2
VarIaBles et types de données simPle 19
Que se passe-t-il vraiment lorsque vous exécutez hello_world .py. . . . . . . . . . . . . . . . . . . . . . . . . 19
Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Nommer et utiliser des variables. . . . . . . . . . . . Éviter les erreurs . . . . . . . . . . . . . . . . . . . . . . . 21
de nom lors de l'utilisation de variables . . . . . . . . . . . . . . . . . . . . . . . 21
Exercice 2-1: Message simple. . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . 23
2-2: Messages simples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Cordes. ................................. . . . . . . . . . . . . . . . . . . . . . . . 23
Changer la casse dans une chaîne avec des méthodes. . . . Combinaison . . . . . . . . . . . . . . . . . . . . . 24
. . ou

concaténation de chaînes. . . . . . . Ajout d'espaces blancs à des chaînes . . . . . . . . . . . . . . . . . . . . . 25


. .avec

des tabulations ou des retours à la ligne supprimant les espaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26


. . . . . . . . . . Éviter les erreurs de syntaxe avec les chaînes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Impression en Python 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
. . . . . . . . . . . . . . . . . . 29
Exercice 2-3: Message personnel. . . . . . . . . . . . . . . Exercice 2-4: . . . . . . . . . . . . . . . . . . 29
Nommer des cas. . . . . . . . . . . . . . . . . . . Exercice 2-5: Citation . . . . . . . . . . . . . . . . . . 29
célèbre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Exercice 2-6: Citation célèbre 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Exercice 2-7:
Suppression de noms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Entiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 flotteurs. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 Éviter les erreurs de type avec la fonction str (). . . . . . . .
. . . . . . . . . . . . . . . . . 31 Entiers en Python 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Exercice 2-8: Numéro huit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 Exercice 2-9: Numéro


préféré. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Comment rédigez-vous des commentaires? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 Quel genre de
commentaires devez-vous rédiger? . . . . . . . . . . . . . . . . . . . . . . . . 33
Exercice 2-10: Ajouter des commentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Le Zen de Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Exercice 2-11: Zen de Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3
LISTES DE PRÉSENTATION 37
Qu'est-ce qu'une liste? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Accès aux éléments d'une liste. . . . . Les positions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
d'index commencent à 0, pas à 1. . Utilisation de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
individuelles à partir d'une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Exercice 3-1: Noms. . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3-2: Salutations. . . . . . . . Exercice 3-3: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Votre propre liste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Modification, ajout et suppression d'éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Modifier des éléments dans une liste. . . . . Ajout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
d'éléments à une liste. . . . . . . Suppression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
d'éléments d'une liste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Exercice 3-4: Liste des invités. . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3-5: Modification de la liste des invités. Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3-6: Plus d'invités. . . . . . Exercice 3-7: Réduire la . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
liste des invités. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Organisation d'une liste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Trier une liste de manière permanente avec la méthode sort (). Tri . . . . . . . . . . . . . . . . . . . . . 47
Fonction
temporaire d'une liste avec le trié () Impression d'une liste dans l'ordre . . . . . . . . . . . . . . . . . . . . 48
inverse. . . . . . . . . . . . . Recherche de la longueur d'une liste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
.. ...... . . . . . . . . . . . . . . . . . . . . 49
Exercice 3-8: Voir le monde. . . . . . . . . . . . . Exercice 3-9: . . . . . . . . . . . . . . . . . . . . . 50
Invités au dîner. . . . . . . . . . Exercice 3-10: Chaque . . . . . . . . . . . . . . . . . . . . . . . . . . 50
fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Éviter les erreurs d'index lors de l'utilisation de listes. . . ...... . . . . . . . . . . . . . . . . . . . . 50
Exercice 3-11: Erreur intentionnelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...... . . . . . . . . . . . . . . . . . . . . 52

4
TRAVAIL AVEC LES LISTES 53
Boucle sur une liste entière. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Un regard plus attentif sur le bouclage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 Faire plus de
travail dans une boucle for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Faire quelque chose après une boucle
for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

xii Contenu en détail


Éviter les erreurs d'indentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Oublier de mettre en retrait. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Oublier de mettre en retrait des lignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
supplémentaires. . Indentation inutile. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Mise en retrait inutile après la boucle. Oublier le . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
colon. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Exercice 4-1: Pizzas. . . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4-2: Animaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Faire des listes numériques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Utilisation de la fonction range (). . . . . . . . . Utilisation de . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
range () pour créer une liste de nombres Statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
simples avec une liste de listes de nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Compréhensions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Exercice 4-3: Compter jusqu'à vingt. . . . Exercice. . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4-4: Un million. . . . . . . . . . . Exercice 4-5: . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Additionner un million. . . . . Exercice 4-6: . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Nombres impairs. . . . . . . . . Exercice 4-7: Trois. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
. . . . . . . . . . Exercice 4-8: Cubes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Exercice 4-9: Compréhension du cube. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Travailler avec une partie d'une liste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Trancher une liste. . . . . . . . . . . . . . . . . . . Boucle à . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
travers une tranche. . . . . . . . . . . Copie d'une liste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
............... . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
. . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Exercice 4-10: tranches. . . . . . . . . . . . . . Exercice
4-11: Mes pizzas, vos pizzas. Exercice 4-12: Plus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
de boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Tuples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Définition d'un tuple. . . . . . . . . . . . . . . . . Bouclage . . . . . . . . . . . . . . . . . . . . . . . . . . . 69


de toutes les valeurs dans un tuple. Écriture sur un . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
tuple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Exercice 4-13: Buffet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Styliser votre code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Le guide de style. . . . . . . . . . . . . . . . Indentation. . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
. . . . . . . . . . . . . . . . . . Longueur de la ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
. . . . . . . . . . . . . Lignes vierges. . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
. . . . Autres directives de style. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Exercice 4-14: PEP 8. . . . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4-15: Révision du code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

5
Si les déclarations 75
Un exemple simple. . . . . . . . . . . . . . . . . . Tests ...... . . . . . . . . . . . . . . . . . . . . . . . . . 76
conditionnels. . . . . . . . . . . . . . . . . . . ...... . . . . . . . . . . . . . . . . . . . . . . . . . 76
Vérifier l'égalité. . . . . . . . . Ignorer la casse lors
. . . . .de
. la . . . . . . . . . . . . . . . . . . . . . . . . . 76
vérification des inégalités. . . . . . . . Comparaisons
Égalité . . . . . . . . . . . . . . . . . . . . . . . . . 77
numériques. . . . . . . Vérification de plusieurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
conditions. . . . Vérifier si une valeur est dans
. . .une
... . . . . . . . . . . . . . . . . . . . . . . . . . 78
liste. . . . ...... . . . . . . . . . . . . . . . . . . . . . . . . . 79
. . . . . . . . . . . . . . . . . . . . . . . . . 80

Contenu en détail xiii


Vérifier si une valeur n'est pas dans des une liste . . . . . . . . . . . . . . . . . . . . . . . . . . 81
expressions booléennes. . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Exercice 5-1: Tests conditionnels. . . . Exercice .... . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5-2: Plus de tests conditionnels .... . . . . . . . . . . . . . . . . . . . . . . . . . . 82
if Déclarations. . . . . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Instructions if simples. . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Instructions if-else. . . . . . . . . . . . . . La .... . . . . . . . . . . . . . . . . . . . . . . . . . . 83
chaîne if-elif-else. . . . . . . . . . . Utilisation de .... . . . . . . . . . . . . . . . . . . . . . . . . . . 84
plusieurs blocs elif. . . . . . . . Omettre le bloc .... . . . . . . . . . . . . . . . . . . . . . . . . . . 86
else. . . . . . . . . Test de plusieurs conditions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
..... .... . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Exercice 5-3: Couleurs extraterrestres # 1. . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Exercice 5-4: Couleurs extraterrestres # 2. . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Exercice 5-5: Couleurs extraterrestres # 3. . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Exercice 5-6: Les étapes de la vie. . . . . . . Exercice 5-7: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Fruit préféré. . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Utilisation d'instructions if avec des listes. . . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Vérification des articles spéciaux. . . . . . . Vérifier .... . . . . . . . . . . . . . . . . . . . . . . . . . . 90
qu'une liste n'est pas vide. . Utilisation de .... . . . . . . . . . . . . . . . . . . . . . . . . . . 91
plusieurs listes. . . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Exercice 5-8: Bonjour Admin. . . . . . . Exercice 5-9: .... . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Aucun utilisateur. . . . . . . . . Exercice 5-10: .... . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Vérification des noms d'utilisateur Exercice 5-11: .... . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Nombres ordinaux. . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Style de vos déclarations if. . . . . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Exercice 5-12: Styliser les instructions if. .... . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Exercice 5-13: Vos idées. . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6
dICtIonarIes 95
Un dictionnaire simple. . . . . . . . . . . . . . . . Travailler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

avec des dictionnaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

Accès aux valeurs dans un dictionnaire Ajout de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97


nouvelles paires clé-valeur. . . À partir d'un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

dictionnaire vide Modification des valeurs dans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

un dictionnaire Suppression des paires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

clé-valeur. . . . . Un dictionnaire d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100


similaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Exercice 6-1: Personne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Exercice 6-2: Numéros préférés. Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6-3: Glossaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Boucle dans un dictionnaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Boucle sur toutes les paires clé-valeur Boucle sur
. .toutes
. . . les
. . . . . . . . . . . . . . . . . . . . . . . . 103
clés d'un dictionnaire Boucle sur les clés d'un dictionnaire . . . . . . . . . . . . . . . . . . . . . . . 104
dans l'ordre Boucle sur toutes les valeurs d'un dictionnaire. . . . . . . . . . . . . . . . . . . . . . . 106
. . . . . . . . . . . . . . . . . . . . . . . 107
Exercice 6-4: Glossaire 2. . . . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . 108
6-5: Rivières. . . . . . . . . . . . . . . . . . Exercice 6-6: . . . . . . . . . . . . . . . . . . . . . . . 108
Sondage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Nesting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Une liste de dictionnaires. . . . . . . . . . . . . . . . . Une liste dans . . . . . . . . . . . . . . . . . . . . . . . 109
un dictionnaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

xiv Contenu en détail


Un dictionnaire dans un dictionnaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
.
Exercice 6-7: Personnes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Exercice 6-8: Animaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Exercice 6-9: Lieux préférés. . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6-10: Numéros préférés Exercice 6-11: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Villes. . . . . . . . . Exercice 6-12: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Extensions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

7
InPut utilisateur et looPs whIle 117
Fonctionnement de la fonction input (). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Ecrire des invites claires. . . . . . . . . . . Utilisation de . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
int () pour accepter une entrée numérique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
L'opérateur Modulo. . . . . . . . . . . Accepter l'entrée . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
en Python 2 .7. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Exercice 7-1: Location de voitures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Exercice 7-2: Assises du restaurant. . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7-3: Multiples de dix. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Présentation des boucles while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
La boucle while en action. . . . . . . . . Laisser . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
l'utilisateur choisir quand arrêter d'utiliser un . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
indicateur. . . . . . . . . . . . . . . . . . Utiliser break pour . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
quitter une boucle. . . . . . . . Utilisation de continuer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
dans une boucle. . . . . . . . . Éviter les boucles infinies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
......... . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Exercice 7-4: Garnitures de pizza. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Exercice 7-5: Billets de cinéma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Exercice 7-6: Trois sorties. . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
7-7: Infini. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Utilisation d'une boucle while avec listes et dictionnaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Déplacement d'éléments d'une liste à une autre. Suppression de toutes
. . . les
. . . . . . . . . . . . . . . . . . . . . . . . 128
instances de valeurs spécifiques du remplissage d'un dictionnaire avec une une liste . . . . . . . . . . . . . . . . . . 129
entrée utilisateur. . . . . . . . .... . . . . . . . . . . . . . . . . . . 130
Exercice 7-8: Deli. . . . . . . . . . . . . . . . . . . . Exercice 7-9: .... . . . . . . . . . . . . . . . . . . 131
Pas de pastrami. . . . . . . . . . . . . . Exercice 7-10: .... . . . . . . . . . . . . . . . . . . 131
Vacances de rêve. . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . 131
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . 131

8
les fonctions 133
Définition d'une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Passer des informations à une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Arguments et paramètres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Exercice 8-1: Message. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Exercice 8-2: Livre préféré. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Passer des arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Arguments de position. . . . . . . . . Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
de mot-clé. . . . . . . . . Les valeurs par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
............. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

Contenu en détail xv
Appels de fonction équivalents. Éviter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
les erreurs d'argument . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Exercice 8-3: T-shirt. . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
8-4: Grandes chemises. Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
8-5: Villes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Valeurs de retour. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Renvoyer une valeur simple. Rendre un. argument
facultatif Renvoyer un dictionnaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Utilisation d'une fonction avec une boucle while
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Exercice 8-6: Noms de villes. . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
8-7: Album. . . . . . . . . . . Exercice 8-8: Albums . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
d'utilisateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Passer une liste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Modifier une liste dans une fonction. . . . Empêcher
une fonction de se modifier une liste . . . . . . . . . . . . . . . . . . . . . . . . 149
Exercice 8-9: Magiciens. . . . . . . . . . Exercice .... . . . . . . . . . . . . . . . . . . . . . . . . 150
8-10: Grands magiciens. . . . Exercice 8-11: .... . . . . . . . . . . . . . . . . . . . . . . . . 150
Magiciens inchangés .... . . . . . . . . . . . . . . . . . . . . . . . . 150
Passer un nombre arbitraire d'arguments. . . .... . . . . . . . . . . . . . . . . . . . . . . . . 151
Mélange d'arguments positionnels et arbitraires à l'aide . . . . . . . . . . . . . . . . . . . . . . . . 152
d'arguments de mots-clés arbitraires. .... . . . . . . . . . . . . . . . . . . . . . . . . 152
Exercice 8-12: Sandwichs. . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . 154
8-13: Profil utilisateur. . . . . . . . Exercice 8-14: .... . . . . . . . . . . . . . . . . . . . . . . . . 154
Voitures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Stockage de vos fonctions dans des modules. . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . 154
Importer un module entier. . . . . . . . . . Importation de . . . . . . . . . . . . . . . . . . . . . . . . . 154
fonctions spécifiques. . . . . . . Utiliser as pour attribuer un. . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
alias à une fonction. . . . Utiliser as pour attribuer un alias à un . . . . . . . . . . . . . . . . . . . . . . . . . 156
module. Importation de toutes les fonctions d'un module.. .. . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Fonctions de style. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
.... . . . . . . . . . . . . . . . . . . . . . . . . 158
Exercice 8-15: Impression de modèles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Exercice 8-16: Importations. . . . . . . . . . . Exercice 8-17:
.... . . . . . . . . . . . . . . . . . . . . . . . . 159
Fonctions de style. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . . . 159

9
Des classes 161
Créer et utiliser une classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
Création de la classe de chien. . . . . . . Créer une . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
instance à partir d'une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Exercice 9-1: Restaurant. . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
9-2: Trois restaurants. . Exercice 9-3: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Utilisateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Travailler avec des classes et des instances. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
La classe de voiture. . . . . . . . . . . . . . Définition d'une
valeur par défaut pour un attribut Modification des valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
d'attribut. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Exercice 9-4: Nombre servi. . . . . . . Exercice 9-5: . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Tentatives de connexion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

xvi Contenu en détail


L'héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
La méthode __init __ () pour une classe enfant. . . . . . . . . Héritage . . . . . . . . . . . . . . . . . . 172
en Python 2 .7. . . . . . . . . . . . . . . . . . . Définition d'attributs et de . . . . . . . . . . . . . . . . . . 173
méthodes pour la classe enfant Remplaçant les méthodes de la . . . . . . . . . . . . . . . . . . 174
classe parent. . . . . . . Instances en tant qu'attributs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
. . . . . . . Modélisation d'objets du monde réel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
. . . . . . . . . . . . . . . . . . 177
Exercice 9-6: Stand de crème glacée. . . . . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . 178
9-7: Admin. . . . . . . . . . . . . . . . . . . . . . Exercice 9-8: Privilèges. . . . . . . . . . . . . . . . . . . . . . 178
. . . . . . . . . . . . . . . . Exercice 9-9: Mise à niveau de la batterie. . . . . . . . . . . . . . . . . . . . . . 178
........... . . . . . . . . . . . . . . . . . . 178
Importer des classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
Importer une seule classe. . . . . . . . . . . . . . . . . . . Stockage de . . . . . . . . . . . . . . . . . . 179
plusieurs classes dans un module. . . . . . . . . . . Importation de . . . . . . . . . . . . . . . . . . 180
plusieurs classes à partir d'un module. . . . . . . Importer un module . . . . . . . . . . . . . . . . . . 181
entier. . . . . . . . . . . . . . . . . Importation de toutes les classes à partir . . . . . . . . . . . . . . . . . . 182
d'un module. . . . . . . . . . . Importation d'un module dans un module. . . . . . . . . . . . . . . . . . . . . . 182
. . . . . . . . Trouver votre propre flux de travail. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
. . . . . . . . . . . . . . . . . . 184
Exercice 9-10: Restaurant importé. . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . 184
9-11: Admin importé. . . . . . . . . . . . . . . Exercice 9-12: . . . . . . . . . . . . . . . . . . 184
Modules multiples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
La bibliothèque standard Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Exercice 9-13: OrderedDict Rewrite. . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . 186
9-14: Dés. . . . . . . . . . . . . . . . . . . . . . . Exercice 9-15: Module . . . . . . . . . . . . . . . . . . 186
Python de la semaine. . . . . . . . . . . . . . . . . . . . . . . . 186
Classes de style. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Résumé . . . . . . . . . . . . . . . . . . . . . . . . . 186
............................. . . . . . . . . . . . . . . . . . . 187

dix
fIles et exCePtIons 189
Lecture à partir d'un fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Lire un fichier entier. . . . . . . . Chemins de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
fichiers. . . . . . . . . . . . . . . . . Lecture ligne par . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
ligne. . . . . . . . . Création d'une liste de lignes à . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
partir d'un fichier Utilisation du contenu d'un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
fichier. . Fichiers volumineux: un million de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
chiffres. . Votre anniversaire est-il contenu dans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Pi? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Exercice 10-1: Apprendre Python. . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
10-2: Apprentissage C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Ecrire dans un fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Ecrire dans un fichier vide. . . . . . Écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
de plusieurs lignes. . . . . . . . Ajout à un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Exercice 10-3: Invité. . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
10-4: Livre d'or. . . . . Exercice 10-5: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Programmation d'un sondage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Gestion de l'exception ZeroDivisionError à l'aide de blocs . . . . . . . . . . . . . . . . . . . . . . . . . 200
try-except. . . . . . . . . . . . . Utilisation d'exceptions pour . . . . . . . . . . . . . . . . . . . . . . . . . 200
éviter les plantages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201

Contenu en détail xvii


Le bloc else. . . . . . . . . . . . . . . . . . . . Gestion de . . . . . . . . . . . . . . . . . . . . . . . . . 202
l'exception FileNotFoundError Analyse du texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
. . . . . . . . . . . . . . Travailler avec plusieurs fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
. . . . . . . Échouer silencieusement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
. . . . Décider des erreurs à signaler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
. . . . . . . . . . . . . . . . . . . . . . . . . 207
Exercice 10-6: Addition. . . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . 207
10-7: Calculateur d'addition. . . . . Exercice 10-8: . . . . . . . . . . . . . . . . . . . . . . . . . 208
Chats et chiens. . . . . . . . Exercice 10-9: Chats et . . . . . . . . . . . . . . . . . . . . . . . . . 208
chiens silencieux. . . . Exercice 10-10: Mots . . . . . . . . . . . . . . . . . . . . . . . . . 208
courants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Stocker des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Utilisation de json .dump () et json .load (). . . . . . Sauvegarde et . . . . . . . . . . . . . . . . . . . . . . . . . 209
lecture de la refactorisation des données générées par l'utilisateur. . . . . . . . . . . . . . . . . . . . . . . . . . 210
..................... . . . . . . . . . . . . . . . . . . . . . . . . . 212
. . . . . . . . . . . . . . . . . . . . . . . . . 214
Exercice 10-11: Numéro préféré. . . . . . Exercice 10-12:
Numéro préféré mémorisé Exercice 10-13: Vérifier . . . . . . . . . . . . . . . . . . . . . 214
l'utilisateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214

11
tester votre code 215
Tester une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Tests unitaires et cas de test. . Un test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
de réussite. . . . . . . . . Un test qui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
échoue. . . . . . . . . . Répondre à un test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
échoué en ajoutant de nouveaux tests. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
..... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Exercice 11-1: Ville, pays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Exercice 11-2: Population. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Tester une classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Une variété de méthodes d'assert Une . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
classe à tester. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Test de la classe AnonymousSurvey La . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
méthode setUp (). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Exercice 11-3: Employé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

PARTIE II: PROJETS 231

ProjeCt 1: invasIon alIen

12
UN NAVIRE QUI FIBRE DES BULLES 235
Planifiez votre projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 Installation de Pygame. . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Installer des packages Python avec pip. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 Installation de
Pygame sous Linux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238

xviii Contenu en détail


Installation de Pygame sur OS X. . . . . .............. .... . . . . . . . . . . . . . 239
Installation de Pygame sur Windows. . .............. .... . . . . . . . . . . . . . 240
Démarrage du projet de jeu. . . . . . . . . . . . .............. .... . . . . . . . . . . . . . 240
Création d'une fenêtre Pygame et définition de la Répondre à l'utilisateur Saisir . . . . . . . . . . . . . 241
couleur d'arrière-plan. . . Création d'une classe de . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 242
paramètres. . . . . . .............. .... . . . . . . . . . . . . . 243
Ajout de l'image du navire. . . . . . . . . . . . . . .............. .... . . . . . . . . . . . . . 244
Création de la classe de navire. . . . . . . .............. .... . . . . . . . . . . . . . 245
Dessin du navire à l'écran. . .............. .... . . . . . . . . . . . . . 246
Refactoring: le module game_functions. . .............. .... . . . . . . . . . . . . . 247
La fonction check_events (). . . . La .............. .... . . . . . . . . . . . . . 247
fonction update_screen (). . . .............. .... . . . . . . . . . . . . . 248
Exercice 12-1: Blue Sky. . . . . . . Exercice . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 249
12-2: Personnage du jeu. .............. .... . . . . . . . . . . . . . 249
Piloter le navire. . . . . . . . . . . . . . . . . . . .............. .... . . . . . . . . . . . . . 249
Répondre à une pression sur une touche. . . . . .............. .... . . . . . . . . . . . . . 249
Permettre un mouvement continu. Déplacement à . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 250
la fois à gauche et à droite. . . . . Ajuster la vitesse . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 252
du navire. . . . . Limiter la portée du navire. . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 253
Refactorisation de check_events (). . . . . .............. .... . . . . . . . . . . . . . 255
.............. .... . . . . . . . . . . . . . 255
Un bref récapitulatif. . . . . . . . . . . . . . . . . . . .............. .... . . . . . . . . . . . . . 256
alien_invasion .py. . . . . . . . . . . .............. .... . . . . . . . . . . . . . 256
paramètres .py. . . . . . . . . . . . . . . . .............. .... . . . . . . . . . . . . . 256
game_functions .py. . . . . . . . . . navire .............. .... . . . . . . . . . . . . . 256
.py. . . . . . . . . . . . . . . . . . .............. .... . . . . . . . . . . . . . 257
Exercice 12-3: Rocket. . . . . . . . .............. .... . . . . . . . . . . . . . 257
Exercice 12-4: Clés. . . . . . . . . . .............. .... . . . . . . . . . . . . . 257
Tir de balles. . . . . . . . . . . . . . . . . . . .............. .... . . . . . . . . . . . . . 257
Ajout des paramètres de puce. . . . . . Création . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 257
de la classe Bullet. . . . . . Stockage de puces .............. .... . . . . . . . . . . . . . 258
dans un groupe. . . . . Tirer des balles. . . . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 259
. . . . . . . Suppression d'anciennes puces. . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 260
. . . . Limitation du nombre de balles. . . .............. .... . . . . . . . . . . . . . 261
.............. .... . . . . . . . . . . . . . 262
Création de la fonction update_bullets (). . . . . . . . . . . Création de .... . . . . . . . . . . . . . 263
la fonction fire_bullet (). . . . . . . . . . . . . . .... . . . . . . . . . . . . . 264
Exercice 12-5: Tir latéral. . . . . . . . . . . . . . .... . . . . . . . . . . . . . 264
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . 264

13
extraterrestres! 265
Examen de votre projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

Création du premier extraterrestre. . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . . . . . . . . . . . 266


Création de la classe extraterrestre. . . . . . . . Créer ..... . . . . . . . . . . . . . . . . . . . . . . . . 267
une instance de l'extraterrestre. . Faire apparaître ..... . . . . . . . . . . . . . . . . . . . . . . . . 268
l'extraterrestre à l'écran ..... . . . . . . . . . . . . . . . . . . . . . . . . 268
Construire la flotte extraterrestre. . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . . . . . . . . . . . 269
Déterminer combien d'étrangers correspondent à la une rangée . . . . . . . . . . . . . . . . . . . . . . . . 269
création de rangées d'étrangers. . . . . . . . . Création de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
la flotte. . . . . . . . . . . . . ..... . . . . . . . . . . . . . . . . . . . . . . . . 271

Contenu en détail xix


Refactorisation de create_fleet (). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
Ajout de lignes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
Exercice 13-1: Étoiles. . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
13-2: De meilleures étoiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Faire bouger la flotte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Déplacer les étrangers à droite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
. . . .si . . . . . . . . . . . . . . . . . . . . . . . . . 277
Création de paramètres pour la direction de la flotte. Vérifier
un extraterrestre a frappé en abandonnant la flotte et en le bord . . . . . . . . . . . . . . . . . . 278
changeant de direction ....... . . . . . . . . . . . . . . . . . 278
Exercice 13-3: Gouttes de pluie. . . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . 279
13-4: Pluie régulière. . . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . 279
Tir extraterrestres. . . . . . . . . . . . . . . . . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . 280
Détecter les collisions de balles. . . . . . . . . . . . . Faire de . . . . . . . . . . . . . . . . . . . . . . . . 280
plus grosses balles pour les tests. . . . . . . . Repeupler la . . . . . . . . . . . . . . . . . . . . . . . . 281
flotte. . . . . . . . . . . . . . . Accélérer les balles. . . . . . . . . . ....... . . . . . . . . . . . . . . . . . 282
. . . . Refactorisation de update_bullets (). . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . 283
....... . . . . . . . . . . . . . . . . . 283
Exercice 13-5: Attrapez. . . . . . . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . 284
Mettre fin au jeu. . . . . . . . . . . . . . . . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . 284
Détection des collisions extraterrestres. . . . . . . . . Répondre . . . . . . . . . . . . . . . . . . . . . . . . 284
aux collisions extraterrestres. . . . . . Les extraterrestres qui ....... . . . . . . . . . . . . . . . . . 285
atteignent le bas de l'écran. Jeu terminé! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
. . . Identifier quand certaines parties du jeu doivent être ....... . . . . . . . . . . . . . . . . . 288
exécutées. . . ....... . . . . . . . . . . . . . . . . . 289
Exercice 13-6: Game Over. . . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . 290
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . 290

14
sCoring 291
Ajout du bouton de lecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Création d'une classe de boutons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Dessiner le bouton sur l'écran de démarrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
du jeu. . . . . . . . . . . Réinitialiser le jeu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
. . . . Désactivation du bouton de lecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Masquer le curseur de la souris. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Exercice 14-1: Appuyez sur P pour jouer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Exercice 14-2: Entraînement à la cible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Mise à niveau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Modification des paramètres de vitesse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Réinitialisation de la vitesse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
Exercice 14-3: Entraînement à la cible difficile. . . . . . . . . . . . . . . . . . . . . . . . . 301
Notation. ........................ ....... . . . . . . . . . . . . . . . . . . . . . . . . 301
Affichage du score. . . . . . . . . . . . . . . . Faire un . . . . . . . . . . . . . . . . . . . . . . . . 301
tableau de bord. . . . . . . . ....... . . . . . . . . . . . . . . . . . . . . . . . . 303
Mise à jour du score lorsque les extraterrestres sont abattus en s'assurant . . . . . . . . . . . . . . . . . . . . . . . 304
de marquer tous les coups. . . ........ . . . . . . . . . . . . . . . . . . . . . . . 305
Augmentation des valeurs de point. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Arrondir le score. . . . . . . . . . ........ . . . . . . . . . . . . . . . . . . . . . . . 307
Scores élevés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

xx Contenu en détail
Affichage du niveau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 Affichage du nombre de
navires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
Exercice 14-4: Meilleur score de tous les temps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 Exercice 14-5:
Refactoring. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 Exercice 14-6: Expansion de l'invasion
extraterrestre. . . . . . . . . . . . . . . . . . . . . . . . . . 317
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

ProjeCt 2: VISUALISATION DES DONNÉES

15
Générer des données 321
Installation de matplotlib. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Sur Linux. . . . . . . . . Sur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
OS X. . . . . . . . . Sous . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Windows. . . . . . Test de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
matplotlib. . . La galerie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
Tracer un graphique linéaire simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Modification du type d'étiquette et épaisseur du graphique . . . . . . . . . . . . . . . . . . . . . 324
Correction du tracé. . . . . ................ . . . . . . . . . . . . . . . . . . . . . 326
Tracer et styliser des points individuels avec scatter () Tracer une . . . . . . . . . . . . . . . . . . . . 326
série de points avec scatter (). ...... . . . . . . . . . . . . . . . . . . . . . 328
Calcul automatique des données. . . . . . . . . . . . . Suppression des . . . . . . . . . . . . . . . . . . . . 328
contours des points de données. . ...... . . . . . . . . . . . . . . . . . . . . . 329
Définition de couleurs personnalisées. . . . . . . . . . . . . . . . . . Utilisation d'une . . . . . . . . . . . . . . . . . . . . 330
palette de couleurs. . . . . . . . . . . . . . . ...... . . . . . . . . . . . . . . . . . . . . . 330
Sauvegarde automatique de vos tracés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Exercice 15-1: Cubes. . . . . . . . . . . . . ...... . . . . . . . . . . . . . . . . . . . . . 331
Exercice 15-2: Cubes colorés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Promenades aléatoires. . . . . . . . . . . . . . . . . . . . . . . ...... . . . . . . . . . . . . . . . . . . . . . 331
Création de la classe RandomWalk (). . . . . . . . . . . Choisir . . . . . . . . . . . . . . . . . . . . 332
les directions. . . . . . . . . . . . . ...... . . . . . . . . . . . . . . . . . . . . . 332
Tracer la marche aléatoire. . . . . . . . . . . . . . . . Génération de . . . . . . . . . . . . . . . . . . . . 333
plusieurs parcours aléatoires. . ...... . . . . . . . . . . . . . . . . . . . . . 334
Styliser la promenade. . . . . . . . . . . . . . . . . . . . . . . Coloration . . . . . . . . . . . . . . . . . . . . 335
des points. . . . . . . . . . . . . . ...... . . . . . . . . . . . . . . . . . . . . . 335
Tracer les points de départ et d'arrivée. . . . . . . . Nettoyer . . . . . . . . . . . . . . . . . . . . 336
les haches. . . . . . . . . . . . ...... . . . . . . . . . . . . . . . . . . . . . 337
Ajout de points de tracé. . . . . . . . . . . . . . . . . . . . . . Modification de la . . . . . . . . . . . . . . . . . . . . 337
taille pour remplir l'écran. . . . ...... . . . . . . . . . . . . . . . . . . . . . 338
Exercice 15-3: Mouvement moléculaire. . . . . . . . . . . Exercice 15-4: . . . . . . . . . . . . . . . . . . . . 339
Balades aléatoires modifiées ..... . . . . . . . . . . . . . . . . . . . . . 339
Exercice 15-5: Refactoring. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Lancer des dés avec Pygal. . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . . . . . . . . 339
Installation de Pygal. . . . . . . . . . . . . . . . . . . . . . . . La galerie . . . . . . . . . . . . . . . . . . . . 340
Pygal. . . . . . . . . . . . . . . . Création de la classe Die.. . .. .. .. . . . .. . . . . . . . . . . . . . . . . . . . . 340
. . . . . . . . . . . Rouler le dé. . . . . . . . . . . . . . . . . . Analyse . . . . . . . . . . . . . . . . . . . . 340
des résultats. . . . . . . . . . . . . . . . . . . . ..... . . . . . . . . . . . . . . . . . . . . . 341
. . . . . . . . . . . . . . . . . . . . 341

Contenu en détail xxi


Créer un histogramme. . . . . . . . Lancer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
deux dés. . . . . . . . . . . Lancer des dés de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
différentes tailles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Exercice 15-6: Étiquettes automatiques . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . 346
. .
Exercice 15-7: Deux D8. . . . . . Exercice 15-8: . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . 346
Trois dés. . . . Exercice 15-9: Multiplication.. .. . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . 346
Exercice 15-10: Pratiquer avec les deux . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . 346
Bibliothèques. . . . . . . . . . . . . . . . . . . . . . . 346
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . . . . . . 347

16
TÉLÉCHARGEMENT DE DONNÉES 349
Le format de fichier CSV. . . . . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Analyse des en-têtes de fichier CSV. ....... . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Impression des en-têtes et de leurs données Positions. . . . . . . . . . . . . . . . . . . . . . . . . . . 351
d'extraction et de lecture. Tracer des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
dans une température Le module datetime. . . Graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
. . . . Tracer les dates. . . . . . . . . . . . Tracer ....... . . . . . . . . . . . . . . . . . . . . . . . . . . 354
une période plus longue. . Tracer une ....... . . . . . . . . . . . . . . . . . . . . . . . . . . 355
deuxième série de données. Ombrage d'une . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
zone dans le graphique. Vérification des ....... . . . . . . . . . . . . . . . . . . . . . . . . . . 357
erreurs. . . . . . . . . . . ....... . . . . . . . . . . . . . . . . . . . . . . . . . . 358
....... . . . . . . . . . . . . . . . . . . . . . . . . . . 359
Exercice 16-1: San Francisco. . . . . .
....... . . . . . . . . . . . . . . . . . . . . . 362
Exercice 16-2: Comparaison Sitka-Death Valley . . . . . . . . . . . . . . . . . . . . . . 362
Exercice 16-3: Pluie. . . . . . . . . . . . . . . . . Exercice 16-4: . . . . . . . . . . . . . . . . . . . . . . 362
Explorez. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Mappage des ensembles de données globaux: format JSON. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Téléchargement des données sur la population mondiale. . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Extraction des données pertinentes. . . . . . . . . . . . . . . Conversion . . . . . . . . . . . . . . . . . . . . . . 363
de chaînes en valeurs numériques. . . . Obtention des codes de . . . . . . . . . . . . . . . . . . . . . . 364
pays à deux chiffres. . . . . . . Construire une carte du monde. . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
. . . . . . . . . . . Tracer des données numériques sur une carte du . . . . . . . . . . . . . . . . . . . . . . 367
monde. . . Tracer une carte complète de la population. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Regroupement des pays par population. . . . . . . . . Styliser les . . . . . . . . . . . . . . . . . . . . . . 369
cartes du monde dans Pygal. . . . . . . . . . . . Éclaircir le thème de . . . . . . . . . . . . . . . . . . . . . . 371
couleur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
. . . . . . . . . . . . . . . . . . . . . . 374
Exercice 16-5: Tous les pays. . . . . . . . . . . . . Exercice 16-6:. . . . . . . . . . . . . . . . . . . . . . 375
Produit intérieur brut. . . . . Exercice 16-7: Choisissez vos . . . . . . . . . . . . . . . . . . . . . . 375
propres données. . . . . Exercice 16-8: Test du module . . . . . . . . . . . . . . . . . . . . . . 375
country_codes . . . . . . . . . . . . . . . . . . . . 375
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375

17
TRAVAILLER AVEC LES API 377
Utilisation d'une API Web. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Git et GitHub. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 Demande de données à
l'aide d'un appel API. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 Requêtes d'installation. . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 379

xxii Contenu en détail


Traitement d'une réponse API. . . . . . . . Utilisation du . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
dictionnaire des réponses. Résumé des principaux . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
référentiels. . . . Surveillance des limites de débit de l'API. . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
. . . . . . . . Visualisation des référentiels à l'aide de Pygal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
....... . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
Affiner les graphiques Pygal. . . . . . . . . . . . Ajout . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
d'infobulles personnalisées. . . . . . . . . . . Tracer les . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
données. . . . . . . . . . . . . . . . Ajout de liens cliquables à . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
notre graphique. L'API Hacker News. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
.... . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
Exercice 17-1: Autres langues. . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
17-2: Discussions actives. . . . Exercice 17-3: . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Test de python_repos.py . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393

ProjeCt 3: APPLICATIONS WEB

18
commencer avec django 397
Configurer un projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
Rédaction d'une spécification. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
Créer un environnement virtuel. . Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
de virtualenv. . . . . . . . . . Activation de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
l'environnement virtuel Installation de Django. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
. . . . . . . . . . Créer un projet dans Django. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
Création de la base de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
Affichage du projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Exercice 18-1: Nouveaux projets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
Démarrer une application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Définition de modèles. . . . . . . . . . . . Activation des
modèles. . . . . . . . . . . Le site d'administration de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Django. . . . . . . Définition du modèle d'entrée. . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Migration du modèle d'entrée. . . . . Enregistrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
. de

. . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
l'entrée sur le site d'administration. Le Django Shell.
........... . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Exercice 18-2: Entrées courtes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Exercice 18-3: l'API Django. . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
18-4: Pizzeria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Créer des pages: la page d'accueil du journal d'apprentissage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Mappage d'une URL. . . . . . . . . . . . . . . Ecrire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
une vue. . . . . . . . . . . . . . . Rédaction d'un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
modèle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Exercice 18-5: Planificateur de repas. . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
18-6: Page d'accueil de Pizzeria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Création de pages supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Héritage de modèle. . . . . . . . . . . . La page des . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
sujets. . . . . . . . . . . . . . Pages thématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
individuelles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421

Contenu en détail xxiii


Exercice 18-7: Documentation du modèle. . . . . . . . . . . . . . . . . . . . . . . . . . . 424 Exercice 18-8:
Pages de pizzeria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425

19
comptes utilisateur 427
Permettre aux utilisateurs de saisir des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
Ajouter de nouveaux sujets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
Ajouter de nouvelles entrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Modification des entrées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
Exercice 19-1: Blog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Configuration des comptes utilisateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439
L'application des utilisateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439
La page de connexion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Déconnecter . . . . . La page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
d'inscription . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
Exercice 19-2: Comptes de blog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
Permettre aux utilisateurs de posséder leurs données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
Restreindre l'accès avec @login_required. Connexion des . . . . . . . . . . . . . . . . . . . . . . . . . . 447
. . . . . . . . . . . . . . . . . . . . . . . . . . 448
données à certains utilisateurs. . . . . Restreindre l'accès aux
rubriques aux utilisateurs appropriés Protéger les rubriques d'un . . . . . . . . . . . . . . . . . . . . . . 451
utilisateur. . . . . . . . . . Protéger la page edit_entry. . . . . . . .. .. ... . . . . . . . . . . . . . . . . . . . . . . . . 451
Associer de nouveaux sujets à l'actuel . . . . . . . . . . . . . . . . . . . . . . 452
Utilisateur. . . . . . . . . . . . . . . . . . . . . . 453
Exercice 19-3: Refactoring. . . . . . . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . 454
19-4: Protéger new_entry. . . Exercice 19-5: Blog. . . . . . . . . . . . . . . . . . . . . . . . . . 454
protégé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . .... . . . . . . . . . . . . . . . . . . . . . . 454

20
styling et développement d'un apP 455
Journal d'apprentissage de style. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
L'application django-bootstrap3. . . . . . . . . . Utilisation de . . . . . . . . . . . . . . . . . . . . . . . . . 456
Bootstrap pour styliser le journal d'apprentissage. . . Modification . . . . . . . . . . . . . . . . . . . . . . . . . 457
du fichier .html de base. . . . . . . . . . . . . . . Mise en forme de la . . . . . . . . . . . . . . . . . . . . . . . . . 458
page d'accueil à l'aide d'un Jumbotron Mise en forme de la page . . . . . . . . . . . . . . . . . . . . . . . . . 461
de connexion. . . . . . . . . . . . . . Stylisation de la page new_topic. . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
. . . . . . . . Style de la page des sujets. . . . . . . . . . . . . Stylisation . . . . . . . . . . . . . . . . . . . . . . . . . 463
des entrées sur la page de rubrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
. . . . . . . . . . . . . . . . . . . . . . . . . 464
Exercice 20-1: Autres formulaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
Exercice 20-2: Blog élégant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
Déploiement du journal d'apprentissage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
. .à . . . . . . . . . . . . . . . . . . . . . . . 466
Créer un compte Heroku. . . . . . . . . . . Installation de la ceinture
outils Heroku. . . . . . . . . Installation des packages requis. . . . .. . . . .. . . . . . . . . . . . . . . . . . . . . . . 466
Création d'une liste de packages avec un .txt des exigences . . . . . . . . . . . . . . . . . . . . . . . . . 466
Spécification du Runtime Python. . . . . . . . . . . . Modification des Déposer
. . . . . . . . . . . . . . . . . . 467
paramètres .py pour Heroku. . . . . . . . . . Créer un fichier de ... . . . . . . . . . . . . . . . . . . 468
processus pour démarrer les processus. . . . . . . . Modification de ... . . . . . . . . . . . . . . . . . . 468
wsgi .py pour Heroku. . . . . . . . . . . . ... . . . . . . . . . . . . . . . . . . 469
... . . . . . . . . . . . . . . . . . . 470

xxiv Contenu en détail


Créer un répertoire pour les fichiers statiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
Utilisation locale du serveur gunicorn. . Utilisation de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
Git pour suivre les fichiers du projet transmis à . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Heroku. . . . . . . . . . . . . Configuration de la base de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
données sur Heroku. Affiner le déploiement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
d'Heroku. . . Sécurisation du projet en direct. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
. Valider et pousser les changements. . Création de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
pages d'erreur personnalisées. . . . . Développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
en cours. . . . . . . . . . Le paramètre SECRET_KEY. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
. . . . . . Suppression d'un projet sur Heroku. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
Exercice 20-3: Blog en direct. . . . . . . . . Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
20-4: Plus de 404. . . . . . . Exercice 20-5: Journal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
d'apprentissage étendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482

épilogue 483

une

Installer Python 485


Python sur Linux. . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
Recherche de la version installée. . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Installation de Python 3 sur Linux. . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Python sur OS X. . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Recherche de la version installée. . . . Utilisation de .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Homebrew pour installer Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Python sous Windows. . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
. . de. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
Installation de Python 3 sur Windows. Recherche
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
l'interpréteur Python. . . Ajout de Python à votre variable
de chemin. Mots-clés Python et fonctions intégrées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
Mots-clés Python. . . . . . . . . . . . . . Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
intégrées Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490

B
éditeurs de texte 491
Geany. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
Installation de Geany sur Linux. . . . . . . . Installation de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
Geany sur Windows. . . . . Exécution de programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
Python dans Geany. Personnalisation des paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
Geany. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
Texte sublime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Installation de Sublime Text sur OS X. . . Installation de . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Sublime Text sur Linux. . . . Installation de Sublime Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
sur Windows Exécution de programmes Python dans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
Sublime Configuration de Sublime Text. . . . . . . . Texte . . . . . . . . . . . . . . . . . . . . . . . . . . 495
Personnalisation des paramètres de texte sublime. . .... . . . . . . . . . . . . . . . . . . . . . . . . . 495
.... . . . . . . . . . . . . . . . . . . . . . . . . . 496

Contenu en détail xxv


INACTIF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Installation d'IDLE sur Linux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496 Installation d'IDLE
sur OS X. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496 Installation d'IDLE sous Windows. . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . 497 Personnalisation des paramètres IDLE. . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . 497 Emacs et vim. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497

C
obtenir de l'aide 499
Premiers pas . . . . . . . . . . . . . ........ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Essaye encore . . . . . Prendre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
une pause . . . . ........ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
Reportez-vous à ce livre Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
Recherche en ligne. . . . . . . . ........ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
Débordement de pile. . . ........ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
Le Python officiel Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
Documentation officielle de la bibliothèque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
r / learnpython. . . . . . . . . . . . Articles .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
de blog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
IRC (Internet Relay Chat). . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
Créez un compte IRC. . . . . . Chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
à rejoindre. . . . . . . . . . Culture IRC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
........... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503


utilisation de gIt pour VersIon Control 505
Installer Git. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
Installation de Git sur Linux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
Installation de Git sur OS X. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
Installation de Git sur Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
Configuration de Git. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
Faire un projet. . . . . . . . . . . . . Ignorer les . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
fichiers. . . . . . . . . . . . . . . . Initialisation d'un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
référentiel. . . . . . . . . Vérification de l'état. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
. . . . . . Ajout de fichiers au référentiel. . . . Faire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
un engagement. . . . . . . . . . . . Vérification du . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
journal. . . . . . . . . . . . . Le deuxième . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
engagement. . . . . . . . . . . Annulation d'un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
changement. . . . . . . . . . . Récupération des . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
validations précédentes. . Suppression du . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
référentiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513

Indice 515

xxvi Contenu en détail


REMERCIEMENTS

Ce livre n'aurait pas été possible sans le personnel formidable et extrêmement professionnel de No
Starch Press. Bill Pollock m'a invité à écrire un livre d'introduction et j'apprécie profondément cette
offre originale. Tyler Ortman a contribué à façonner ma pensée dans les premières étapes de la
rédaction. Les premiers commentaires de Liz Chadwick et Leslie Shen sur chaque chapitre ont été
inestimables, et Anne Marie Walker a aidé à clarifier de nombreuses parties du livre. Riley Hoffman a
répondu à toutes les questions que j'avais sur le processus d'assemblage d'un livre complet et a
patiemment transformé mon travail en un beau produit fini.

Je tiens à remercier Kenneth Love, le réviseur technique pour Cours intensif Python. J'ai
rencontré Kenneth à PyCon un an, et son enthousiasme pour le langage et la communauté Python a
été une source constante d'inspiration professionnelle depuis. Kenneth est allé au-delà de la simple
vérification des faits et a révisé le livre dans le but d'aider les programmeurs débutants à développer
une solide compréhension du langage Python et de la programmation en général. Cela dit, toutes les
inexactitudes qui subsistent sont entièrement les miennes.

Je tiens à remercier mon père de m'avoir initié à la programmation à un jeune âge et


de ne pas avoir eu peur de casser son équipement. Je tiens à remercier ma femme, Erin,
de m'avoir soutenu et encouragé à travers l'écriture de ce livre, et je tiens à remercier mon
fils, Ever, dont la curiosité m'inspire chaque jour.
Introduction

Chaque programmeur raconte comment il a appris à écrire


son premier programme. J'ai commencé à apprendre quand j'étais
enfant lorsque mon père travaillait pour Digital Equipment
Corporation, l'une des entreprises pionnières de l'ère informatique
moderne. J'ai écrit mon premier programme sur un

kit informatique que mon père avait assemblé dans notre sous-sol. L'ordinateur se composait de
rien de plus qu'une carte mère nue connectée à un clavier sans boîtier, et il avait un tube à rayons
cathodiques nu pour un moniteur. Mon programme initial était un simple jeu de devinettes de
nombres, qui ressemblait à ceci:

Je pense à un certain nombre! Essayez de deviner le nombre auquel je pense: 25


Trop bas! Devine encore: 50
Trop haut! Devine encore: 42
C'est tout! Voulez-vous rejouer? (Oui Non) non
Merci d'avoir joué!
Je me souviendrai toujours à quel point je me suis senti satisfait de regarder ma famille jouer à un jeu que j'ai créé et
qui a fonctionné comme je l'avais prévu.
Cette première expérience a eu un impact durable. Il y a une réelle satisfaction à construire quelque
chose avec un but, quelque chose qui résout un problème. Le logiciel que j'écris maintenant répond à un besoin
plus important que les efforts de mon enfance, mais le sentiment de satisfaction que j'éprouve à créer un
programme qui fonctionne est encore largement le même.

Pour qui est ce livre?


L'objectif de ce livre est de vous familiariser le plus rapidement possible avec Python afin que vous puissiez
créer des programmes qui fonctionnent (jeux, visualisations de données et applications Web) tout en
développant une base de programmation qui vous servira bien pour le reste de ta vie. Cours intensif Python est
écrit pour les personnes de tout âge qui n'ont jamais programmé en Python auparavant ou qui n'ont jamais
programmé du tout. Si vous souhaitez apprendre rapidement les bases de la programmation afin de pouvoir
vous concentrer sur des projets intéressants et que vous aimez tester votre compréhension de nouveaux
concepts en résolvant des problèmes significatifs, ce livre est pour vous. Cours intensif Python est également
parfait pour les enseignants des collèges et lycées qui souhaitent offrir à leurs élèves une introduction à la
programmation basée sur des projets.

que pouvez-vous espérer apprendre?

Le but de ce livre est de faire de vous un bon programmeur en général et un bon programmeur Python en
particulier. Vous apprendrez efficacement et adopterez de bonnes habitudes car je vous fournirai une
base solide dans les concepts généraux de programmation. Après avoir travaillé votre chemin à travers Cours
accéléré Python,
vous devriez être prêt à passer à des techniques Python plus avancées, et votre prochain langage de
programmation sera encore plus facile à comprendre.
Dans la première partie de ce livre, vous apprendrez les concepts de base de la programmation que vous devez
connaître pour écrire des programmes Python. Ces concepts sont les mêmes que ceux que vous apprendrez en débutant
dans presque tous les langages de programmation. Vous découvrirez différents types de données et la manière dont vous
pouvez stocker des données dans des listes et des dictionnaires au sein de vos programmes. Vous apprendrez à créer
des collections de données et à travailler sur ces collections de manière efficace. Vous apprendrez à utiliser tandis que et si boucles
pour tester certaines conditions afin que vous puissiez exécuter des sections spécifiques de code alors que ces conditions
sont vraies et exécuter d'autres sections lorsqu'elles ne le sont pas - une technique qui aide grandement à automatiser les
processus.

Vous apprendrez à accepter les entrées des utilisateurs pour rendre vos programmes interactifs et maintenir
vos programmes en cours d'exécution tant que l'utilisateur est actif. Vous découvrirez comment écrire des fonctions
pour rendre des parties de votre programme réutilisables, de sorte que vous n'aurez qu'à écrire des blocs de code qui
exécutent certaines

xxx introduction
actions une fois, que vous pouvez ensuite utiliser autant de fois que vous le souhaitez. Vous étendrez ensuite ce
concept à des comportements plus compliqués avec des classes, ce qui permettra à des programmes assez simples
de répondre à une variété de situations. Vous apprendrez à écrire des programmes qui gèrent les erreurs courantes
avec élégance. Après avoir parcouru chacun de ces concepts de base, vous allez écrire quelques programmes
courts qui résolvent des problèmes bien définis. Enfin, vous ferez votre premier pas vers la programmation
intermédiaire en apprenant à écrire des tests pour votre code afin de pouvoir développer davantage vos
programmes sans vous soucier d'introduire des bogues. Toutes les informations de la partie I vous prépareront à
entreprendre des projets plus vastes et plus complexes.

Dans la partie II, vous appliquerez ce que vous avez appris dans la partie I à trois projets. Vous
pouvez réaliser tout ou partie de ces projets dans l’ordre qui vous convient le mieux. Dans le premier
projet (chapitres 12 à 14), vous allez créer un jeu de tir de style Space Invaders appelé Alien Invasion,
qui comprend des niveaux de difficulté croissante. Une fois ce projet terminé, vous devriez être sur la
bonne voie pour pouvoir développer vos propres jeux 2D.

Le deuxième projet (chapitres 15 à 17) vous présente la visualisation des données. Les scientifiques des données
visent à donner un sens à la grande quantité d'informations dont ils disposent grâce à une variété de techniques de
visualisation. Vous travaillerez avec des ensembles de données que vous générez via du code, des ensembles de
données téléchargés à partir de sources en ligne et des ensembles de données que vos programmes téléchargent
automatiquement. Une fois ce projet terminé, vous serez en mesure d'écrire des programmes qui parcourent de grands
ensembles de données et de faire des représentations visuelles de ces informations stockées.

Dans le troisième projet (chapitres 18 à 20), vous allez créer une petite application Web appelée Learning
Log. Ce projet vous permet de tenir un journal des idées et des concepts que vous avez appris sur un sujet
spécifique. Vous pourrez conserver des journaux séparés pour différents sujets et permettre à d'autres de créer
un compte et de créer leurs propres journaux. Vous apprendrez également à déployer votre projet afin que tout le
monde puisse y accéder en ligne de n'importe où.

pourquoi Python?

Chaque année, je réfléchis à l'opportunité de continuer à utiliser Python ou de passer à un autre langage -
peut-être un langage plus récent dans le monde de la programmation. Mais je continue à me concentrer sur
Python pour de nombreuses raisons. Python est un langage incroyablement efficace: vos programmes en
feront plus en moins de lignes de code que ce que de nombreux autres langages exigeraient. La syntaxe de
Python vous aidera également à écrire du code «propre». Votre code sera facile à lire, facile à déboguer et
facile à étendre et à construire par rapport à d'autres langages.

Les gens utilisent Python à de nombreuses fins: créer des jeux, créer des applications Web, résoudre des problèmes

commerciaux et développer des outils internes dans toutes sortes d'entreprises intéressantes. Python est également

largement utilisé dans les domaines scientifiques pour la recherche académique et les travaux appliqués.

introduction xxxi
L'une des raisons les plus importantes pour lesquelles je continue à utiliser Python est la communauté
Python, qui comprend un groupe de personnes incroyablement diversifié et accueillant. La communauté est
essentielle pour les programmeurs car la programmation n'est pas une poursuite solitaire. La plupart d'entre
nous, même les programmeurs les plus expérimentés, devons demander conseil à d'autres qui ont déjà
résolu des problèmes similaires. Avoir une communauté bien connectée et solidaire est essentiel pour vous
aider à résoudre les problèmes, et la communauté Python soutient pleinement les personnes comme vous
qui apprennent Python comme premier langage de programmation.

Python est un excellent langage à apprendre, alors commençons!

xxxii introduction
Partie I
CI Bas

La partie I de ce livre vous enseigne les concepts de base dont vous aurez

besoin pour écrire des programmes Python. Beaucoup de ces concepts sont

communs à tous les langages de programmation, ils vous seront donc utiles tout

au long de votre vie de programmeur.

Dans Chapitre 1 vous allez installer Python sur votre ordinateur et exécuter votre premier programme, qui
imprime le message Bonjour le monde! à l'écran.
Dans Chapitre 2 vous apprendrez à stocker des informations dans des variables et à travailler avec du texte et

des valeurs numériques.

Chapitres 3 et 4 introduire des listes. Les listes peuvent stocker autant d'informations que vous le souhaitez dans

une variable, ce qui vous permet de travailler efficacement avec ces données. Vous pourrez travailler avec des centaines,

des milliers et même des millions de valeurs en seulement quelques lignes de code.

Dans Chapitre 5 vous utiliserez si instructions pour écrire du code qui répond d'une manière si certaines
conditions sont vraies, et qui répond d'une manière différente si ces conditions ne sont pas vraies.

Chapitre 6 vous montre comment utiliser les dictionnaires Python, qui vous permettent d'établir des
liens entre différentes informations. Tout comme les listes, les dictionnaires peuvent contenir autant
d'informations que vous en avez besoin.
Dans Chapitre 7 vous apprendrez à accepter les commentaires des utilisateurs pour rendre vos programmes

interactifs. Vous en apprendrez également sur tandis que boucles, qui exécutent des blocs de code à plusieurs reprises tant

que certaines conditions restent vraies.

Dans Chapitre 8 vous écrirez des fonctions, qui sont des blocs de code nommés qui exécutent une tâche

spécifique et peuvent être exécutées chaque fois que vous en avez besoin.
Chapitre 9 introduit des classes, qui vous permettent de modéliser des objets du monde réel, tels que des

chiens, des chats, des personnes, des voitures, des fusées et bien plus encore, afin que votre code puisse représenter

tout ce qui est réel ou abstrait.

Chapitre 10 vous montre comment travailler avec des fichiers et gérer les erreurs afin que vos programmes ne se
bloquent pas de manière inattendue. Vous stockerez les données avant la fermeture de votre programme et vous les relirez
lorsque le programme s'exécutera à nouveau. Vous découvrirez les exceptions de Python, qui vous permettent d'anticiper
les erreurs et de permettre à vos programmes de gérer ces erreurs avec élégance.

Dans Chapitre 11 vous apprendrez à écrire des tests pour votre code afin de vérifier que vos
programmes fonctionnent comme vous le souhaitez. En conséquence, vous pourrez étendre vos programmes
sans vous soucier d'introduire de nouveaux bogues. Tester votre code est l'une des premières compétences
qui vous aideront à passer du programmeur débutant à intermédiaire.

2 Partie I
1
commencer

Dans ce chapitre, vous exécuterez votre premier programme Python, hello_world.py.

Tout d'abord, vous devrez vérifier si Python est installé sur votre ordinateur; si ce

n'est pas le cas, vous l'installerez. Vous installerez également un éditeur de texte

pour travailler avec vos programmes Python. Les éditeurs de texte reconnaissent

le code Python et mettent en évidence les sections au fur et à mesure que vous

écrivez, ce qui facilite la compréhension de la structure de votre code.

configuration de votre environnement de programmation

Python diffère légèrement selon les systèmes d'exploitation, vous devrez donc garder quelques considérations
à l'esprit. Ici, nous allons examiner les deux versions principales de Python actuellement utilisées et décrire les
étapes pour configurer Python sur votre système.
Python 2 et Python 3
Aujourd'hui, deux versions de Python sont disponibles: Python 2 et le plus récent Python 3. Chaque langage de
programmation évolue à mesure que de nouvelles idées et technologies émergent, et les développeurs de Python
ont continuellement rendu le langage plus polyvalent et plus puissant. La plupart des changements sont
incrémentiels et à peine perceptibles, mais dans certains cas, le code écrit pour Python 2 peut ne pas fonctionner
correctement sur les systèmes sur lesquels Python 3 est installé. Tout au long de ce livre, je vais souligner les
domaines de différence significative entre Python 2 et Python 3, donc quelle que soit la version que vous utilisez,
vous serez en mesure de suivre les instructions.

Si les deux versions sont installées sur votre système ou si vous devez installer Python, utilisez
Python 3. Si Python 2 est la seule version de votre système et que vous préférez vous lancer dans
l'écriture de code au lieu d'installer Python, vous pouvez commencer avec Python 2 Mais plus tôt vous
mettrez à niveau vers Python 3, mieux ce sera, vous travaillerez donc avec la version la plus récente.

Exécution d'extraits de code Python

Python est livré avec un interpréteur qui s'exécute dans une fenêtre de terminal, vous permettant d'essayer
des bits de Python sans avoir à enregistrer et exécuter un programme entier.

Tout au long de ce livre, vous verrez des extraits qui ressemblent à ceci:

u >>> print ("Bonjour l'interpréteur Python!")


Bonjour interprète Python!

Le texte en gras est ce que vous tapez puis exécutez en appuyant sur
Entrer. La plupart des exemples du livre sont de petits programmes autonomes que vous exécuterez à partir de
votre éditeur, car c'est ainsi que vous écrirez la plupart de votre code. Mais parfois, des concepts de base seront
affichés dans une série d'extraits de code exécutés dans une session de terminal Python pour démontrer plus
efficacement des concepts isolés. Chaque fois que vous voyez les trois crochets angulaires dans une liste de
codes u,
vous regardez la sortie d'une session de terminal. Nous essaierons de coder dans l'interpréteur de votre
système dans un instant.

Bonjour le monde!

Une croyance de longue date dans le monde de la programmation a été que l'impression d'un
Bonjour le monde! message à l'écran car votre premier programme dans une nouvelle langue vous portera chance.

En Python, vous pouvez écrire le Bonjour le monde programme en une seule ligne:

print ("Bonjour tout le monde!")

Un programme aussi simple sert un objectif très réel. S'il fonctionne correctement sur votre système, tout
programme Python que vous écrivez devrait également fonctionner. Nous examinerons l'écriture de ce
programme sur votre système particulier dans un instant.

4 Chapitre 1
Python sur différents systèmes d'exploitation
Python est un langage de programmation multiplateforme, ce qui signifie qu'il fonctionne sur tous les principaux systèmes
d'exploitation. Tout programme Python que vous écrivez doit s'exécuter sur n'importe quel ordinateur moderne sur lequel
Python est installé. Cependant, les méthodes de configuration de Python sur différents systèmes d'exploitation varient
légèrement.
Dans cette section, vous apprendrez à configurer Python et à exécuter le Bonjour le monde
programme sur votre propre système. Vous allez d'abord vérifier si Python est installé sur votre système et l'installer
si ce n'est pas le cas. Ensuite, vous allez installer un simple éditeur de texte et enregistrer un fichier Python vide
appelé hello_world.py. Enfin, vous exécuterez le Bonjour le monde programme et dépanner tout ce qui n'a pas
fonctionné. Je vais vous guider à travers ce processus pour chaque système d'exploitation, afin que vous disposiez
d'un environnement de programmation Python convivial pour les débutants.

Python sur Linux

Les systèmes Linux sont conçus pour la programmation, donc Python est déjà installé sur la plupart des ordinateurs
Linux. Les personnes qui écrivent et maintiennent Linux s'attendent à ce que vous fassiez votre propre
programmation à un moment donné et vous encouragent à le faire. Pour cette raison, vous devez installer très peu
de choses et très peu de paramètres à modifier pour commencer la programmation.

Vérification de votre version de Python

Ouvrez une fenêtre de terminal en exécutant l'application Terminal sur votre système (dans Ubuntu, vous
pouvez appuyer sur ctrl-alt- T). Pour savoir si Python est installé, entrez python avec une minuscule p. Vous
devriez voir une sortie vous indiquant quelle version de Python est installée et une invite >>> où vous
pouvez commencer à entrer des commandes Python, comme ceci:

$ python
Python 2.7.6 (par défaut, 22 mars 2014, 22:59:38) [GCC 4.8.2] sur
linux2
Tapez "aide", "copyright", "crédits" ou "licence" pour plus d'informations.
>>>

Cette sortie vous indique que Python 2.7.6 est actuellement la version par défaut de Python installée
sur cet ordinateur. Lorsque vous avez vu cette sortie, appuyez sur
ctrl- D ou entrez sortir() pour quitter l'invite Python et revenir à une invite de terminal.

Pour vérifier Python 3, vous devrez peut-être spécifier cette version; donc même si la sortie affiche
Python 2.7 comme version par défaut, essayez la commande
python3:

$ python3
Python 3.5.0 (par défaut, 17 septembre 2015, 13:05:18) [GCC 4.8.4]
sous Linux
Tapez "aide", "copyright", "crédits" ou "licence" pour plus d'informations.
>>>

Commencer 5
Cette sortie signifie que Python 3 est également installé, vous pourrez donc utiliser l'une ou l'autre des
versions. Chaque fois que vous voyez le python commande dans ce livre, entrez python3 au lieu. La plupart des
distributions Linux ont déjà Python installé, mais si pour une raison quelconque le vôtre ne l'a pas fait ou si votre
système est livré avec Python 2 et que vous souhaitez installer Python 3, reportez-vous à l'annexe A.

Installer un éditeur de texte

Geany est un simple éditeur de texte: il est facile à installer, vous permettra d'exécuter presque tous vos programmes
directement depuis l'éditeur plutôt que via un terminal, utilise la coloration syntaxique pour colorer votre code et
exécute votre code dans une fenêtre de terminal afin que vous Habituez-vous à utiliser des terminaux. L'annexe B
fournit des informations sur d'autres éditeurs de texte, mais je recommande d'utiliser Geany à moins que vous n'ayez
une bonne raison d'utiliser un autre éditeur.

Vous pouvez installer Geany en une seule ligne sur la plupart des systèmes Linux:

$ sudo apt-get install geany

Si cela ne fonctionne pas, consultez les instructions sur http://geany.org/Download/ ThirdPartyPackages


/.

exécuter le programme Hello World

Pour démarrer votre premier programme, ouvrez Geany. Appuyez sur la touche Super (souvent appelée touche Windows) et
recherchez Geany sur votre système. Créez un raccourci en faisant glisser l'icône vers votre barre des tâches ou votre
bureau. Ensuite, créez un dossier quelque part sur votre système pour vos projets et appelez-le python_work. ( Il est
préférable d'utiliser des lettres minuscules et des traits de soulignement pour les espaces dans les noms de fichiers et de
dossiers car ce sont des conventions de dénomination Python.) Revenez à Geany et enregistrez un fichier Python vide ( Déposer
4 Enregistrer sous) appelé bonjour_world.py dans votre python_ travail dossier. L'extension . py indique à Geany que votre
fichier contiendra un programme Python. Il indique également à Geany comment exécuter votre programme et mettre en
évidence le texte de manière utile.

Après avoir enregistré votre fichier, entrez la ligne suivante:

print ("Bonjour le monde Python!")

Si plusieurs versions de Python sont installées sur votre système, vous devez vous assurer que Geany est
configuré pour utiliser la bonne version. Aller à Construire 4 Définissez les commandes de construction. Tu devrais
voir les mots Compiler et Exécuter avec une commande à côté de chacun. Geany suppose que la commande correcte
pour chacun est python,
mais si votre système utilise le python3 commande, vous devrez changer cela.
Si la commande python3 a travaillé dans une session de terminal, changez les commandes
Compile et Execute pour que Geany utilise l'interpréteur Python 3. Votre commande Compile
devrait ressembler à ceci:

python3 -m py_compile "% f"

6 Chapitre 1
Vous devez taper cette commande exactement comme indiqué. Assurez-vous que les espaces et les
majuscules correspondent à ce qui est montré ici.
Votre commande Execute devrait ressembler à ceci:

python3 "% f"

Encore une fois, assurez-vous que l'espacement et la capitalisation correspondent à ce qui est montré ici. La

Figure 1-1 montre à quoi ces commandes doivent ressembler dans le menu de configuration de Geany.

Figure 1-1: Ici, Geany est configuré pour utiliser Python 3 sous Linux.

Maintenant, cours bonjour_world.py en sélectionnant Construire 4 Exécuter dans le menu, en cliquant sur
l'icône Exécuter (qui montre un ensemble d'engrenages), ou en appuyant sur F5. Une fenêtre de terminal devrait
apparaître avec la sortie suivante:

Bonjour le monde Python!

------------------
(programme terminé avec le code: 0) Appuyez
sur retour pour continuer

Si vous ne voyez pas cela, vérifiez chaque caractère sur la ligne que vous avez entrée. Avez-vous
accidentellement capitalisé impression? Avez-vous oublié un ou les deux guillemets ou parenthèses? Les langages de
programmation attendent une syntaxe très spécifique, et si vous ne fournissez pas cela, vous obtiendrez des erreurs. Si
vous ne parvenez pas à exécuter le programme, reportez-vous à la section «Dépannage des problèmes d’installation» à
la page 15.

Commencer 7
exécution de Python dans une session de terminal

Vous pouvez essayer d'exécuter des extraits de code Python en ouvrant un terminal et en tapant python ou python3, comme
vous l'avez fait lors de la vérification de votre version. Répétez l'opération, mais cette fois, entrez la ligne suivante
dans la session de terminal:

>>> print ("Bonjour l'interpréteur Python!")


Bonjour interprète Python!
>>>

Vous devriez voir votre message imprimé directement dans la fenêtre actuelle du terminal. N'oubliez
pas que vous pouvez fermer l'interpréteur Python en appuyant sur
ctrl- D ou en tapant la commande sortir().

Python sur OS X

Python est déjà installé sur la plupart des systèmes OS X. Une fois que vous connaissez Python
est installé, vous devrez installer un éditeur de texte et vous assurer qu'il est correctement configuré.

Vérifier si Python est installé

Ouvrez une fenêtre de terminal en accédant à Applications 4 Utilitaires 4 Terminal.


Vous pouvez également appuyer sur commander- barre d'espace, tapez Terminal, puis appuyez sur Entrer.

Pour savoir si Python est installé, entrez python avec une minuscule p. Vous devriez voir une sortie vous
indiquant quelle version de Python est installée sur votre système et une invite >>> où vous pouvez
commencer à entrer des commandes Python, comme ceci:

$ python
Python 2.7.5 (par défaut, 9 mars 2014, 22:15:05)
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)] sur darwin
Tapez "aide", "copyright", "crédits" ou "licence" pour plus d'informations.
>>>

Cette sortie vous indique que Python 2.7.5 est actuellement la version par défaut installée sur
cet ordinateur. Lorsque vous avez vu cette sortie, appuyez sur ctrl- D ou entrez sortir() pour quitter
l'invite Python et revenir à une invite de terminal.

Pour vérifier Python 3, essayez la commande python3. Vous pouvez recevoir un message d'erreur, mais
si le résultat indique que Python 3 est installé, vous pourrez utiliser Python 3 sans avoir à l'installer. Si python3 fonctionne
sur votre système, chaque fois que vous voyez le python commande dans ce livre, assurez-vous d'utiliser python3

au lieu. Si, pour une raison quelconque, votre système n'est pas fourni avec Python ou si vous n'avez que Python 2 et
que vous souhaitez installer Python 3 maintenant, consultez l'annexe A.

8 Chapitre 1
exécution de Python dans une session de terminal

Vous pouvez essayer d'exécuter des extraits de code Python en ouvrant un terminal et en tapant python ou python3, comme
vous l'avez fait lors de la vérification de votre version. Répétez l'opération, mais cette fois, entrez la ligne suivante
dans la session de terminal:

>>> print ("Bonjour l'interpréteur Python!")


Bonjour interprète Python!
>>>

Vous devriez voir votre message imprimé directement dans la fenêtre actuelle du terminal. N'oubliez
pas que vous pouvez fermer l'interpréteur Python en appuyant sur
ctrl- D ou en tapant la commande sortir().

Installer un éditeur de texte

Sublime Text est un simple éditeur de texte: il est facile à installer sur OS X, vous permettra d'exécuter presque
tous vos programmes directement depuis l'éditeur plutôt que via un terminal, utilise la coloration syntaxique
pour colorer votre code et exécute votre code dans un terminal session intégrée dans la fenêtre Sublime Text
pour faciliter la visualisation de la sortie. L'annexe B fournit des informations sur d'autres éditeurs de texte, mais
je recommande d'utiliser Sublime Text à moins que vous n'ayez une bonne raison d'utiliser un autre éditeur.

Vous pouvez télécharger un programme d'installation pour Sublime Text à partir de http: // sublimetext

. com / 3. Cliquez sur le lien de téléchargement et recherchez un programme d'installation pour OS X. Sublime Text a
une politique de licence très libérale: vous pouvez utiliser l'éditeur gratuitement aussi longtemps que vous le souhaitez,
mais l'auteur vous demande d'acheter une licence si vous l'aimez et le souhaitez utilisation continue. Une fois le
programme d'installation téléchargé, ouvrez-le, puis faites glisser l'icône Sublime Text dans votre Applications dossier.

Configurer Sublime Text pour Python 3

Si vous utilisez une commande autre que python pour démarrer une session de terminal Python, vous devrez
configurer Sublime Text afin qu'il sache où trouver la version correcte de Python sur votre système.
Exécutez la commande suivante pour connaître le chemin complet de votre interpréteur Python:

$ type -a python3
python3 est / usr / local / bin / python3

Ouvrez maintenant Sublime Text et accédez à Outils 4 Construire le système 4 Nouveau système de

construction, qui ouvrira un nouveau fichier de configuration pour vous. Supprimez ce que vous voyez et entrez ce qui

suit:

Python3 {
. construction sublime "cmd": ["/ usr / local / bin / python3", "-u", "$ fichier"],
}

Commencer 9
Ce code indique à Sublime Text d'utiliser votre système python3 commande lors de l'exécution du fichier
actuellement ouvert. Assurez-vous d'utiliser le chemin que vous avez trouvé lors de l'exécution de la commande type
-a python3 à l'étape précédente. Enregistrez le fichier sous Python3.sublime-build dans le répertoire par défaut que
Sublime Text ouvre lorsque vous choisissez Enregistrer.

exécuter le programme Hello World

Pour démarrer votre premier programme, lancez Sublime Text en ouvrant le


Applications dossier et double-cliquez sur l'icône Sublime Text. Vous pouvez également appuyer sur commander-
barre d'espace et entrez texte sublime dans la barre de recherche qui apparaît.

Créer un dossier appelé python_work quelque part sur votre système pour vos projets. (Il est préférable d'utiliser des

lettres minuscules et des traits de soulignement pour les espaces dans les noms de fichiers et de dossiers, car ce sont des

conventions de dénomination Python.) Enregistrez un fichier Python vide ( Déposer 4 Enregistrer sous) appelé bonjour_world.py

dans votre python_work

dossier. L'extension . py indique à Sublime Text que votre fichier contiendra un programme Python et lui
indique comment exécuter votre programme et mettre le texte en surbrillance de manière utile.

Après avoir enregistré votre fichier, entrez la ligne suivante:

print ("Bonjour le monde Python!")

Si la commande python fonctionne sur votre système, vous pouvez exécuter votre programme en sélectionnant
Outils 4 Construire dans le menu ou en appuyant sur ctrl- B. Si vous avez configuré Sublime Text pour utiliser une
commande autre que python, sélectionner
Outils 4 Construire le système puis sélectionnez Python 3. Cela définit Python 3 comme version par défaut de Python, et

vous pourrez sélectionner Outils 4 Construire ou appuyez simplement sur commander- B pour exécuter vos programmes à

partir de maintenant.

Un écran de terminal devrait apparaître au bas de la fenêtre Sublime Text, affichant la


sortie suivante:

Bonjour le monde Python!


[Terminé en 0,1 s]

Si vous ne voyez pas cela, vérifiez chaque caractère sur la ligne que vous avez entrée. Avez-vous accidentellement
capitalisé impression? Avez-vous oublié un ou les deux guillemets ou parenthèses? Les langages de programmation
attendent une syntaxe très spécifique, et si vous ne fournissez pas cela, vous obtiendrez des erreurs. Si vous ne parvenez
pas à exécuter le programme, reportez-vous à la section «Dépannage des problèmes d’installation» à la page 15.

Python sous Windows

Windows n'est pas toujours fourni avec Python, vous devrez donc probablement le télécharger et
l'installer, puis télécharger et installer un éditeur de texte.

dix Chapitre 1
Installer Python

Tout d'abord, vérifiez si Python est installé sur votre système. Ouvrez une fenêtre de commande en entrant commander
dans le menu Démarrer ou en maintenant la touche
décalage tout en cliquant avec le bouton droit sur votre bureau et en sélectionnant Ouvrez la fenêtre de commande ici.
Dans la fenêtre du terminal, saisissez python en minuscules. Si vous obtenez une invite Python (>>>), Python est
installé sur votre système. Cependant, vous verrez probablement un message d'erreur vous indiquant que python n'est
pas une commande reconnue.

Dans ce cas, téléchargez un programme d'installation Python pour Windows. Aller à http: //
python.org/downloads/. Vous devriez voir deux boutons, un pour télécharger Python 3 et un pour télécharger
Python 2. Cliquez sur le bouton Python 3, qui devrait automatiquement démarrer le téléchargement du
programme d'installation approprié pour votre système. Après avoir téléchargé le fichier, exécutez le
programme d'installation. Assurez-vous de cocher l'option Ajouter Python à PATH, ce qui facilitera la
configuration correcte de votre système. La figure 1-2 montre cette option cochée.

Figure 1-2: Assurez-vous de cocher la case intitulée Ajouter Python à PATH.

Démarrer une session de terminal Python

La configuration de votre éditeur de texte sera simple si vous configurez d'abord votre système pour exécuter
Python dans une session de terminal. Ouvrez une fenêtre de commande et entrez python en minuscules. Si vous
obtenez une invite Python (>>>), Windows a trouvé la version de Python que vous venez d'installer:

C: \> python
Python 3.5.0 (v3.5.0: 374f501f4567, 13 septembre 2015, 22:15:05) [MSC v.1900 32 bit (Intel)] sur win32

Tapez "aide", "copyright", "crédits" ou "licence" pour plus d'informations.


>>>

Commencer 11
Si cela a fonctionné, vous pouvez passer à la section suivante, «Exécution de Python dans une session de
terminal».
Cependant, vous pouvez voir une sortie qui ressemble plus à ceci:

C: \> python
'python' n'est pas reconnu comme une commande interne ou externe, un programme utilisable ou un fichier de
commandes.

Dans ce cas, vous devez indiquer à Windows comment trouver la version Python que vous venez d'installer. Votre
système python la commande est généralement enregistrée dans votre C

lecteur, alors ouvrez l'Explorateur Windows et ouvrez votre C conduire. Recherchez un dossier commençant par
le nom Python, ouvrez ce dossier et recherchez le python fichier (en minuscules). Par exemple, j'ai un Python35 dossier
avec un fichier nommé python
à l'intérieur, donc le chemin vers le python la commande sur mon système est C: \ Python35 \ python. Sinon, saisissez
python dans la zone de recherche de l'Explorateur Windows pour vous montrer exactement où le python La commande
est stockée sur votre système.
Lorsque vous pensez connaître le chemin, testez-le en entrant ce chemin dans une fenêtre de terminal. Ouvrez
une fenêtre de commande et entrez le chemin complet que vous venez de trouver:

C: \> C: \ Python35 \ python


Python 3.5.0 (v3.5.0: 374f501f4567, 13 septembre 2015, 22:15:05) [MSC v.1900 32 bit (Intel)] sur win32

Tapez "aide", "copyright", "crédits" ou "licence" pour plus d'informations.


>>>

Si cela a fonctionné, vous savez comment accéder à Python sur votre système.

exécution de Python dans une session de terminal

Entrez la ligne suivante dans votre session Python et assurez-vous de voir la sortie Bonjour le monde
Python!

>>> print ("Bonjour le monde Python!")


Bonjour le monde Python!
>>>

Chaque fois que vous souhaitez exécuter un extrait de code Python, ouvrez une fenêtre de commande et
démarrez une session de terminal Python. Pour fermer la session de terminal, appuyez sur ctrl- Z puis appuyez sur Entrer,
ou entrez la commande sortir().

Installer un éditeur de texte

Geany est un éditeur de texte simple: il est facile à installer, vous permettra d'exécuter presque tous vos programmes
directement à partir de l'éditeur au lieu de passer par un terminal, utilise la coloration syntaxique pour colorer votre code
et exécute votre code dans une fenêtre de terminal afin que vous '' Je vais m'habituer à utiliser des terminaux. L'annexe
B fournit des informations sur d'autres éditeurs de texte, mais je recommande d'utiliser Geany à moins que vous n'ayez
une bonne raison d'utiliser un autre éditeur.

12 Chapitre 1
Vous pouvez télécharger un programme d'installation Windows pour Geany à partir de http://geany.org/.

Cliquez sur Communiqués dans le menu Télécharger et recherchez le geany-1.25_ setup.exe installateur ou quelque

chose de similaire. Exécutez le programme d'installation et acceptez toutes les valeurs par défaut.

Pour démarrer votre premier programme, ouvrez Geany: appuyez sur la touche Windows et recherchez Geany sur
votre système. Vous devez créer un raccourci en faisant glisser l'icône sur votre barre des tâches ou sur votre bureau.
Créer un dossier appelé python_work quelque part sur votre système pour vos projets. (Il est préférable d'utiliser des lettres
minuscules et des traits de soulignement pour les espaces dans les noms de fichiers et de dossiers, car ce sont des
conventions de dénomination Python.) Revenez à Geany et enregistrez un fichier Python vide ( Déposer 4 Enregistrer sous)
appelé bonjour_world.py dans votre python_work dossier. L'extension . py indique à Geany que votre fichier contiendra un
programme Python. Il indique également à Geany comment exécuter votre programme et mettre en évidence le texte d'une
manière utile.

Après avoir enregistré votre fichier, tapez la ligne suivante:

print ("Bonjour le monde Python!")

Si la commande python travaillé sur votre système, vous n'aurez pas à configurer Geany; ignorez la
section suivante et passez à «Exécution du programme Hello World» à la page 14. Si vous deviez entrer
un chemin comme C: \ Python35 \ python
pour démarrer un interpréteur Python, suivez les instructions de la section suivante pour configurer Geany
pour votre système.

Configurer Geany

Pour configurer Geany, accédez à Construire 4 Définissez les commandes de construction. Tu devrais voir les
mots Compiler et Exécuter avec une commande à côté de chacun. Les commandes Compile et Execute
commencent par python en minuscules, mais Geany ne sait pas où votre système a stocké le python commander. Vous
devez ajouter le chemin que vous avez utilisé dans la session de terminal.

Dans les commandes Compile et Execute, ajoutez le lecteur python


la commande est activée et le dossier dans lequel python la commande est stockée. Votre
commande Compile devrait ressembler à ceci:

C: \ Python35 \ python -m py_compile "% f"

Votre chemin peut être un peu différent, mais assurez-vous que les espaces et les majuscules
correspondent à ce qui est montré ici.
Votre commande Execute devrait ressembler à ceci:

C: \ Python35 \ python "% f"

Encore une fois, assurez-vous que l'espacement et les majuscules dans votre commande Exécuter correspondent
à ce qui est montré ici. La Figure 1-3 montre à quoi ces commandes doivent ressembler dans le menu de configuration
de Geany.

Commencer 13
Figure 1-3: Ici, Geany est configuré pour utiliser Python 3 sous Windows.

Une fois que vous avez correctement défini ces commandes, cliquez sur D'ACCORD.

exécuter le programme Hello World

Vous devriez maintenant pouvoir exécuter votre programme avec succès. Courir bonjour_world.py

en sélectionnant Construire 4 Exécuter dans le menu, en cliquant sur l'icône Exécuter (qui montre un ensemble
d'engrenages), ou en appuyant sur F5. Une fenêtre de terminal devrait apparaître avec la sortie suivante:

Bonjour le monde Python!

------------------
(programme terminé avec le code: 0) Appuyez
sur retour pour continuer

Si vous ne voyez pas cela, vérifiez chaque caractère sur la ligne que vous avez entrée. Avez-vous accidentellement
capitalisé impression? Avez-vous oublié un ou les deux guillemets ou parenthèses? Les langages de programmation
attendent une syntaxe très spécifique, et si vous ne fournissez pas cela, vous obtiendrez des erreurs. Si vous ne parvenez
pas à exécuter le programme, consultez la section suivante pour obtenir de l'aide.

14 Chapitre 1
dépannage des problèmes d'installation

J'espère que la configuration de votre environnement de programmation a réussi, mais si vous n'avez pas pu
exécuter bonjour_world.py, voici quelques remèdes que vous pouvez essayer:

• Lorsqu'un programme contient une erreur significative, Python affiche un traceback. Python
examine le fichier et essaie de signaler le problème. Le traçage peut vous donner une idée du
problème qui empêche le programme de s'exécuter.

• Éloignez-vous de votre ordinateur, faites une courte pause, puis réessayez. N'oubliez pas que la
syntaxe est très importante dans la programmation, de sorte que même un deux-points manquant, un
guillemet incohérent ou des parenthèses incohérentes peuvent empêcher un programme de s'exécuter
correctement. Relisez les parties pertinentes de ce chapitre, regardez ce que vous avez fait et voyez si
vous pouvez trouver l'erreur.

• Recommencer à nouveau. Vous n'avez probablement rien à désinstaller, mais il peut être judicieux de
supprimer votre bonjour_world.py fichier et créez-le à nouveau à partir de zéro.

• Demandez à quelqu'un d'autre de suivre les étapes de ce chapitre, sur votre ordinateur ou sur un
autre, et observez attentivement ce qu'il fait. Vous avez peut-être manqué une petite étape que
quelqu'un d'autre arrive à franchir.

• Trouvez quelqu'un qui connaît Python et demandez-lui de vous aider à vous installer. Si vous demandez autour de

vous, vous constaterez peut-être que vous connaissez quelqu'un qui utilise Python.

• Les instructions de configuration de ce chapitre sont également disponibles en ligne, via


https://www.nostarch.com/pythoncrashcourse/. La version en ligne de ces instructions peut mieux
fonctionner pour vous.

• Demandez de l'aide en ligne. L'annexe C fournit un certain nombre de ressources et de domaines en ligne, comme
des forums et des sites de chat en direct, où vous pouvez demander des solutions à des personnes qui ont déjà
travaillé sur le problème auquel vous êtes actuellement confronté.

Ne vous inquiétez pas de déranger les programmeurs expérimentés. Chaque programmeur a été bloqué
à un moment donné, et la plupart des programmeurs sont heureux de vous aider à configurer correctement
votre système. Tant que vous pouvez indiquer clairement ce que vous essayez de faire, ce que vous avez déjà
essayé et les résultats que vous obtenez, il y a de fortes chances que quelqu'un puisse vous aider. Comme
mentionné dans l'introduction, la communauté Python est très conviviale pour les débutants.

Python devrait bien fonctionner sur n'importe quel ordinateur moderne, alors trouvez un moyen de demander de l'aide

si vous rencontrez des problèmes jusqu'à présent. Les premiers problèmes peuvent être frustrants, mais ils méritent d'être

résolus. Une fois que vous obtenez bonjour_world.py en cours d'exécution, vous pouvez commencer à apprendre Python et

votre travail de programmation deviendra plus intéressant et satisfaisant.

Commencer 15
exécution de programmes Python à partir d'un terminal

La plupart des programmes que vous écrivez dans votre éditeur de texte seront exécutés directement à partir de
l'éditeur, mais il est parfois utile d'exécuter des programmes à partir d'un terminal à la place. Par exemple, vous
souhaiterez peut-être exécuter un programme existant sans l'ouvrir pour le modifier.

Vous pouvez le faire sur n'importe quel système avec Python installé si vous savez comment accéder au
répertoire dans lequel vous avez stocké votre fichier programme. Pour essayer ceci, assurez-vous d'avoir enregistré le bonjour_world.py
fichier dans le python_work dossier sur votre bureau.

Sous Linux et OS X

L'exécution d'un programme Python à partir d'une session de terminal est la même sous Linux et OS X. La
commande terminal CD, pour changer de répertoire, est utilisé pour naviguer dans votre système de fichiers dans
une session de terminal. La commande ls, pour
liste, vous montre tous les fichiers non cachés qui existent dans le répertoire courant.
Ouvrez une nouvelle fenêtre de terminal et exécutez les commandes suivantes
hello_world.py:

u ~ $ Bureau cd / python_work /
v ~ / Bureau / python_work $ ls
bonjour_world.py
w ~ / Bureau / python_work $ python hello_world.py
Bonjour le monde Python!

À u nous utilisons le CD commande pour accéder au python_work dossier, qui se trouve dans le Bureau dossier.
Ensuite, nous utilisons le ls commande pour s'assurer
bonjour_world.py est dans ce dossier v. Ensuite, nous exécutons le fichier à l'aide de la commande
python hello_world.py w.
C'est si simple. Vous utilisez simplement le python ( ou python3) commande pour exécuter des programmes Python.

Sous Windows

La commande de terminal CD, pour changer de répertoire, est utilisé pour naviguer dans votre système de fichiers
dans une fenêtre de commande. La commande dir, pour annuaire,
vous montre tous les fichiers qui existent dans le répertoire courant.
Ouvrez une nouvelle fenêtre de terminal et exécutez les commandes suivantes
hello_world.py:

u C: \> Bureau cd \ python_work


v C: \ Desktop \ python_work> dir
bonjour_world.py
w C: \ Desktop \ python_work> python hello_world.py
Bonjour le monde Python!

À u nous utilisons le CD commande pour accéder au python_work dossier, qui se trouve dans le Bureau dossier.
Ensuite, nous utilisons le dir commande pour s'assurer
bonjour_world.py est dans ce dossier v. Ensuite, nous exécutons le fichier à l'aide de la commande
python hello_world.py w.

16 Chapitre 1
Si vous n'avez pas configuré votre système pour utiliser la commande simple
python, vous devrez peut-être utiliser la version plus longue de cette commande:

C: \ $ Bureau cd \ python_work
C: \ Bureau \ python_work $ dir
bonjour_world.py
C: \ Bureau \ python_work $ C: \ Python35 \ python hello_world.py
Bonjour le monde Python!

La plupart de vos programmes fonctionneront correctement directement à partir de votre éditeur, mais à mesure
que votre travail deviendra plus complexe, vous pourriez écrire des programmes dont vous aurez besoin pour exécuter

à partir d'un terminal.

essayez-le vous-même

Les exercices de ce chapitre sont de nature exploratoire. À partir du chapitre 2, les défis que vous
résolvez seront basés sur ce que vous avez appris.

1-1. python.org: Explorez la page d'accueil de Python ( http://python.org/) pour trouver des sujets qui vous intéressent.

Au fur et à mesure que vous vous familiariserez avec Python, différentes parties du site vous seront plus utiles.

1-2. Hello World Typos: Ouvrez le bonjour_world.py fichier que vous venez de créer. Faites une faute de frappe quelque part

dans la ligne et exécutez à nouveau le programme. Pouvez-vous faire une faute de frappe qui génère une erreur?

Pouvez-vous comprendre le message d'erreur? Pouvez-vous faire une faute de frappe qui ne génère pas d'erreur? Pourquoi

pensez-vous que cela n'a pas fait d'erreur?

1-3. Compétences infinies: Si vous aviez des compétences en programmation infinies, que construiriez-vous? Vous êtes sur le point

d'apprendre à programmer. Si vous avez un objectif final en tête, vous aurez une utilisation immédiate de vos nouvelles

compétences; C'est le moment idéal pour rédiger des descriptions de ce que vous souhaitez créer. C'est une bonne habitude de

conserver un cahier «d'idées» auquel vous pouvez vous référer chaque fois que vous souhaitez démarrer un nouveau projet. Prenez

maintenant quelques minutes pour décrire trois programmes que vous souhaitez créer.

résumé
Dans ce chapitre, vous en avez appris un peu plus sur Python en général, et vous avez installé Python sur votre
système s'il n'y était pas déjà. Vous avez également installé un éditeur de texte pour faciliter l'écriture de code Python.
Vous avez appris à exécuter des extraits de code Python dans une session de terminal et vous avez exécuté votre
premier programme réel,
hello_world.py. Vous en avez probablement aussi appris un peu plus sur le dépannage.
Dans le chapitre suivant, vous découvrirez les différents types de données avec lesquelles vous pouvez travailler

dans vos programmes Python, et vous apprendrez également à utiliser des variables.

Commencer 17
2
Var I aBles et
s ImPLer les données t yPes

Dans ce chapitre, vous découvrirez les différents types de données

avec lesquelles vous pouvez travailler dans vos programmes Python. Vous

apprendrez également à stocker vos données dans des variables et à

utiliser ces variables dans vos programmes.

que se passe-t-il vraiment lorsque vous exécutez hello_world.py

Examinons de plus près ce que fait Python lorsque vous exécutez hello_world.py. En fin de compte,
Python fait beaucoup de travail, même lorsqu'il exécute un programme simple:

bonjour_world.py print ("Bonjour le monde Python!")


Lorsque vous exécutez ce code, vous devriez voir cette sortie:

Bonjour le monde Python!

Lorsque vous exécutez le fichier bonjour_world.py, la fin . py indique que le fichier est un
programme Python. Votre éditeur exécute ensuite le fichier via le
Interpréteur Python, qui lit le programme et détermine ce que signifie chaque mot du
programme. Par exemple, lorsque l'interprète voit le mot impression, il imprime à l'écran tout ce
qui se trouve à l'intérieur des parenthèses.
Au fur et à mesure que vous écrivez vos programmes, votre éditeur met en évidence différentes parties de
votre programme de différentes manières. Par exemple, il reconnaît que impression est le nom d'une fonction et
affiche ce mot en bleu. Il reconnaît que "Bonjour le monde Python!" n'est pas du code Python et affiche cette
phrase en orange. Cette fonction s'appelle coloration syntaxique et est très utile lorsque vous commencez à écrire
vos propres programmes.

Variables
Essayons d'utiliser une variable dans hello_world.py. Ajoutez une nouvelle ligne au début du fichier et
modifiez la deuxième ligne:

message = "Bonjour le monde Python!" imprimer


(message)

Exécutez ce programme pour voir ce qui se passe. Vous devriez voir la même sortie que vous avez vue

précédemment:

Bonjour le monde Python!

Nous avons ajouté un variable nommé un message. Chaque variable contient un évaluer, qui sont les
informations associées à cette variable. Dans ce cas, la valeur est le texte "Hello Python world!"

L'ajout d'une variable fait un peu plus de travail pour l'interpréteur Python. Lorsqu'il traite la
première ligne, il associe le texte "Hello Python world!" avec la variable un message. Lorsqu'il
atteint la deuxième ligne, il imprime la valeur associée à un message à l'écran.

Développons ce programme en modifiant bonjour_world.py pour imprimer un deuxième message. Ajouter


une ligne vide à bonjour_world.py, puis ajoutez deux nouvelles lignes de code:

message = "Bonjour le monde Python!" imprimer


(message)

message = "Bonjour le monde de Python Crash Course!" imprimer


(message)

20 Chapitre 2
Maintenant quand tu cours bonjour_world.py, vous devriez voir deux lignes de sortie:

Bonjour le monde Python!


Bonjour le monde du Python Crash Course!

Vous pouvez modifier la valeur d'une variable dans votre programme à tout moment, et Python
gardera toujours une trace de sa valeur actuelle.

Nommer et utiliser des variables

Lorsque vous utilisez des variables en Python, vous devez respecter quelques règles et directives. Le non-respect
de certaines de ces règles entraînera des erreurs; d'autres directives vous aident simplement à écrire un code plus
facile à lire et à comprendre. Assurez-vous de garder à l'esprit les règles de variables suivantes:

• Les noms de variable ne peuvent contenir que des lettres, des chiffres et des traits de soulignement. Ils peuvent

commencer par une lettre ou un trait de soulignement, mais pas par un chiffre. Par exemple, vous pouvez

appeler une variable message_1 mais non 1_message.

• Les espaces ne sont pas autorisés dans les noms de variables, mais des traits de soulignement peuvent être utilisés

pour séparer les mots dans les noms de variables. Par exemple, message d'accueil fonctionne, mais message

d'accueil causera des erreurs.

• Évitez d'utiliser des mots-clés Python et des noms de fonctions comme noms de variables; autrement
dit, n'utilisez pas de mots que Python a réservés pour un objectif programmatique particulier, tel que
le mot impression. ( Voir «Mots clés Python et fonctions intégrées» à la page 509.)

• Les noms de variables doivent être courts mais descriptifs. Par exemple, Nom est mieux que n,
nom_étudiant est mieux que s_n, et nom_longueur est mieux que length_of_persons_name.

• Soyez prudent lorsque vous utilisez la lettre minuscule l et la lettre majuscule O


car ils pourraient être confondus avec les chiffres 1 et 0.

Cela peut prendre un peu de pratique pour apprendre à créer de bons noms de variables, d'autant plus que
vos programmes deviennent plus intéressants et compliqués. Au fur et à mesure que vous écrivez plus de
programmes et que vous commencez à lire le code des autres, vous vous améliorerez pour trouver des noms
significatifs.

Remarque Les variables Python que vous utilisez à ce stade doivent être en minuscules. Vous n'obtiendrez pas d'erreurs si vous
utilisez des lettres majuscules, mais c'est une bonne idée d'éviter de les utiliser pour le moment.

Éviter les erreurs de nom lors de l'utilisation de variables

Chaque programmeur fait des erreurs et la plupart font des erreurs tous les jours. Bien que les bons
programmeurs puissent créer des erreurs, ils savent également comment y répondre efficacement.
Examinons une erreur que vous êtes susceptible de faire au début et apprenons à la corriger.

Variables et types de données simples 21


Nous écrirons du code qui génère une erreur exprès. Entrez le code suivant, y
compris le mot mal orthographié message affiché en gras:

message = "Bonjour lecteur Python Crash Course!" impression( message)

Lorsqu'une erreur se produit dans votre programme, l'interpréteur Python fait de son mieux pour vous aider à
déterminer où se situe le problème. L'interpréteur fournit une trace lorsqu'un programme ne peut pas s'exécuter
correctement. UNE retraçage est un enregistrement de l'endroit où l'interpréteur a rencontré des problèmes lors de la
tentative d'exécution de votre code. Voici un exemple du traçage fourni par Python après que vous avez
accidentellement mal orthographié le nom d'une variable:

Traceback (dernier appel le plus récent):


u Fichier "hello_world.py", ligne 2, dans <module>
v imprimer (message)

w NameError: le nom 'message' n'est pas défini

La sortie à u signale qu'une erreur s'est produite à la ligne 2 du fichier


hello_world.py. L'interprète montre cette ligne pour nous aider à repérer l'erreur rapidement v et nous dit
quel genre d'erreur il a trouvé w. Dans ce cas, il a trouvé un
erreur de nom et signale que la variable en cours d'impression, message, n'a pas été défini. Python ne peut pas
identifier le nom de variable fourni. Une erreur de nom signifie généralement que nous avons oublié de définir la
valeur d'une variable avant de l'utiliser, ou que nous avons fait une faute d'orthographe lors de la saisie du nom de
la variable.
Bien sûr, dans cet exemple, nous avons omis la lettre s dans le nom de la variable
un message dans la deuxième ligne. L'interpréteur Python ne vérifie pas l'orthographe de votre code, mais il garantit que
les noms de variables sont orthographiés de manière cohérente. Par exemple, regardez ce qui se passe lorsque nous
épelons un message incorrectement à un autre endroit du code également:

mesage = "Bonjour lecteur Python Crash Course!"


imprimer (message)

Dans ce cas, le programme s'exécute avec succès!

Bonjour lecteur Python Crash Course!

Les ordinateurs sont stricts, mais ils ignorent la bonne et la mauvaise orthographe. Par conséquent, vous n'avez pas

besoin de prendre en compte les règles d'orthographe et de grammaire en anglais lorsque vous essayez de créer des noms

de variables et d'écrire du code.

De nombreuses erreurs de programmation sont de simples fautes de frappe à un seul caractère sur une ligne
d'un programme. Si vous passez beaucoup de temps à rechercher l'une de ces erreurs, sachez que vous êtes en
bonne compagnie. De nombreux programmeurs expérimentés et talentueux passent des heures à traquer ce genre de
petites erreurs. Essayez d'en rire et passez à autre chose, sachant que cela se produira fréquemment tout au long de
votre vie de programmation.

22 Chapitre 2
Remarque La meilleure façon de comprendre les nouveaux concepts de programmation est d'essayer de les utiliser dans vos
programmes. Si vous êtes bloqué en travaillant sur un exercice de ce livre, essayez de faire autre chose pendant un
moment. Si vous êtes toujours bloqué, passez en revue la partie pertinente de ce chapitre. Si vous avez encore besoin
d'aide, consultez les suggestions de l'annexe C.

essayez-le vous-même

Rédigez un programme distinct pour accomplir chacun de ces exercices. Enregistrez chaque programme avec un

nom de fichier qui suit les conventions Python standard, en utilisant des lettres minuscules et des traits de

soulignement, tels que simple_message.py et

simple_messages.py.

2-1. Message simple: Stockez un message dans une variable, puis imprimez ce message.

2-2. Messages simples: Stockez un message dans une variable et imprimez ce message. Modifiez ensuite la

valeur de votre variable en un nouveau message et imprimez le nouveau message.

cordes
Étant donné que la plupart des programmes définissent et collectent une sorte de données, puis en font quelque chose
d'utile, cela permet de classer différents types de données. Le premier type de données que nous examinerons est la
chaîne. Les chaînes sont assez simples à première vue, mais vous pouvez les utiliser de différentes manières.

UNE chaîne de caractères est simplement une série de personnages. Tout ce qui se trouve entre guillemets est

considéré comme une chaîne en Python, et vous pouvez utiliser des guillemets simples ou doubles autour de vos chaînes

comme ceci:

"Ceci est une chaîne."


"C'est aussi une chaîne."

Cette flexibilité vous permet d'utiliser des guillemets et des apostrophes dans vos chaînes:

'J'ai dit à mon ami, "Python est ma langue préférée!"'


"Le langage 'Python' est nommé d'après Monty Python, pas le serpent." "L'une des forces de Python
est sa communauté diversifiée et solidaire."

Explorons quelques-unes des façons dont vous pouvez utiliser les chaînes.

Variables et types de données simples 23


Changer la casse dans une chaîne avec des méthodes

L'une des tâches les plus simples que vous pouvez effectuer avec des chaînes est de changer la casse des mots
d'une chaîne. Regardez le code suivant et essayez de déterminer ce qui se passe:

name.py name = "ada lovelace" print


(name.title ())

Enregistrez ce fichier sous name.py, puis exécutez-le. Vous devriez voir cette sortie:

Ada Lovelace

Dans cet exemple, la chaîne minuscule " ada lovelace " est stocké dans la variable Nom. La méthode Titre()
apparaît après la variable dans le impression() déclaration. UNE méthode est une action que Python peut
effectuer sur une donnée. Le point (.) Après Nom dans name.title () dit à Python de faire le Titre() méthode agir
sur la variable Nom. Chaque méthode est suivie d'un ensemble de parenthèses, car les méthodes ont
souvent besoin d'informations supplémentaires pour faire leur travail. Ces informations sont fournies
entre parenthèses. Le Titre() La fonction n'a pas besoin d'informations supplémentaires, donc ses
parenthèses sont vides.

Titre() affiche chaque mot en cas de titre, où chaque mot commence par une majuscule. Ceci est
utile car vous voudrez souvent considérer un nom comme une information. Par exemple, vous voudrez
peut-être que votre programme reconnaisse les valeurs d'entrée Ada, ADA, et ada sous le même nom et
affichez-les tous sous la forme Ada.

Plusieurs autres méthodes utiles sont également disponibles pour traiter les cas. Par exemple, vous
pouvez changer une chaîne en majuscules ou en minuscules comme ceci:

name = "Ada Lovelace"


imprimer (nom.upper ())
print (nom.lower ())

Cela affichera ce qui suit:

ADA LOVELACE
ada lovelace

Le plus bas() est particulièrement utile pour stocker des données. Souvent, vous ne voudrez pas faire
confiance à la capitalisation fournie par vos utilisateurs, vous allez donc convertir les chaînes en minuscules
avant de les stocker. Ensuite, lorsque vous souhaitez afficher les informations, vous utiliserez la casse qui a
le plus de sens pour chaque chaîne.

24 Chapitre 2
Combinaison ou concaténation de chaînes

Il est souvent utile de combiner des chaînes. Par exemple, vous souhaiterez peut-être stocker
un prénom et un nom de famille dans des variables séparées, puis les combiner lorsque vous souhaitez
afficher le nom complet d'une personne:

first_name = "ada"
last_name = "lovelace"
u full_name = first_name + "" + last_name

print (full_name)

Python utilise le symbole plus (+) pour combiner des chaînes. Dans cet exemple, nous utilisons + pour
créer un nom complet en combinant un Prénom, un espace, et un
nom de famille u, donnant ce résultat:

ada lovelace

Cette méthode de combinaison de chaînes est appelée enchaînement. Vous pouvez utiliser la concaténation pour
composer des messages complets en utilisant les informations que vous avez stockées dans une variable. Regardons un
exemple:

first_name = "ada"
last_name = "lovelace"
full_name = first_name + "" + last_name

u print ("Bonjour", + nom_titre.titre () + "!")

Ici, le nom complet est utilisé à u dans une phrase qui salue l'utilisateur, et le Titre() est utilisée pour
formater le nom de manière appropriée. Ce code renvoie un message d'accueil simple mais joliment
formaté:

Bonjour Ada Lovelace!

Vous pouvez utiliser la concaténation pour composer un message, puis stocker l'intégralité du message
dans une variable:

first_name = "ada"
last_name = "lovelace"
full_name = first_name + "" + last_name

u message = "Bonjour," + full_name.title () + "!"


v imprimer (message)

Ce code affiche le message "Bonjour Ada Lovelace!" également, mais en stockant le message
dans une variable à u fait la finale impression déclaration à v
beaucoup plus simple.

Variables et types de données simples 25


Ajout d'espaces blancs à des chaînes avec des tabulations ou des retours à la ligne

En programmation, espace blanc fait référence à tout caractère non imprimable, comme les espaces, les tabulations et

les symboles de fin de ligne. Vous pouvez utiliser des espaces pour organiser votre sortie afin qu'elle soit plus facile à

lire pour les utilisateurs.

Pour ajouter une tabulation à votre texte, utilisez la combinaison de caractères \ t comme indiqué à u:

>>> imprimer ("Python")


Python
u >>> print ("\ tPython")
Python

Pour ajouter une nouvelle ligne dans une chaîne, utilisez la combinaison de caractères \ n:

>>> print ("Langages: \ nPython \ nC \ nJavaScript")


Langues:
Python
C

JavaScript

Vous pouvez également combiner des tabulations et des retours à la ligne dans une seule chaîne. La ficelle

"\NT" dit à Python de passer à une nouvelle ligne et de commencer la ligne suivante avec un onglet. L'exemple
suivant montre comment utiliser une chaîne d'une ligne pour générer quatre lignes de sortie:

>>> print ("Langages: \ n \ tPython \ n \ tC \ n \ tJavaScript")


Langues:
Python
C

JavaScript

Les nouvelles lignes et les tabulations seront très utiles dans les deux prochains chapitres lorsque vous commencerez

à produire de nombreuses lignes de sortie à partir de quelques lignes de code seulement.

Décapage des espaces blancs

Les espaces blancs supplémentaires peuvent prêter à confusion dans vos programmes. Aux programmeurs

'python' et ' python ' ressemble à peu près au même. Mais pour un programme, ce sont deux chaînes différentes.
Python détecte l'espace supplémentaire dans ' python ' et le considère comme significatif, sauf indication
contraire de votre part.
Il est important de penser aux espaces, car vous voudrez souvent comparer deux chaînes pour déterminer si
elles sont identiques. Par exemple, un exemple important peut impliquer la vérification des noms d'utilisateur des
utilisateurs lorsqu'ils se connectent à un site Web. Les espaces blancs supplémentaires peuvent également prêter à
confusion dans des situations beaucoup plus simples. Heureusement, Python facilite l'élimination des espaces
superflus des données que les utilisateurs entrent.

Python peut rechercher des espaces supplémentaires sur les côtés droit et gauche d'une chaîne. Pour vous
assurer qu'aucun espace n'existe à l'extrémité droite d'une chaîne, utilisez le rstrip () méthode.

26 Chapitre 2
u >>> favorite_language = 'python'
v >>> favorite_language
«python»
w >>> favorite_language.rstrip ()
'python'
x >>> favorite_language
«python»

La valeur stockée dans favorite_language à u contient des espaces supplémentaires à la fin de la


chaîne. Lorsque vous demandez à Python cette valeur dans une session de terminal, vous pouvez voir
l'espace à la fin de la valeur v. Quand le rstrip ()
la méthode agit sur la variable favorite_language à w, cet espace supplémentaire est supprimé. Cependant, il n'est
supprimé que temporairement. Si vous demandez la valeur de favorite_language encore une fois, vous pouvez voir
que la chaîne a la même apparence que lorsqu'elle a été saisie, y compris l'espace blanc supplémentaire X.

Pour supprimer définitivement l'espace blanc de la chaîne, vous devez stocker la


valeur supprimée dans la variable:

>>> favorite_language = 'python'


u >>> favorite_language = favorite_language.rstrip ()
>>> favorite_language
'python'

Pour supprimer l'espace blanc de la chaîne, vous supprimez l'espace blanc du côté droit de la chaîne,
puis stockez cette valeur dans la variable d'origine, comme indiqué à u. La modification de la valeur d'une
variable, puis le stockage de la nouvelle valeur dans la variable d'origine se fait souvent en programmation.
C'est ainsi que la valeur d'une variable peut changer lors de l'exécution d'un programme ou en réponse à
une entrée utilisateur.

Vous pouvez également supprimer les espaces du côté gauche d'une chaîne en utilisant le

bande l () méthode ou supprimer les espaces des deux côtés à la fois en utilisant déshabiller():

u >>> favorite_language = 'python'


v >>> favorite_language.rstrip ()
«python»
w >>> favorite_language.lstrip ()
«python»
x >>> favorite_language.strip ()
'python'

Dans cet exemple, nous commençons avec une valeur qui a des espaces au début et à la fin u. Nous
supprimons ensuite l'espace supplémentaire du côté droit à v, du côté gauche à w, et des deux côtés à X. L'expérimentation
de ces fonctions de décapage peut vous aider à vous familiariser avec la manipulation de chaînes. Dans le
monde réel, ces fonctions de suppression sont utilisées le plus souvent pour nettoyer les entrées utilisateur avant
qu'elles ne soient stockées dans un programme.

Variables et types de données simples 27


Éviter les erreurs de syntaxe avec les chaînes

Un type d'erreur que vous pourriez voir avec une certaine régularité est une erreur de syntaxe. UNE erreur de
syntaxe se produit lorsque Python ne reconnaît pas une section de votre programme en tant que code Python
valide. Par exemple, si vous utilisez une apostrophe entre guillemets simples, vous produirez une erreur. Cela se
produit parce que Python interprète tout entre le premier guillemet simple et l'apostrophe comme une chaîne. Il
essaie ensuite d'interpréter le reste du texte comme du code Python, ce qui provoque des erreurs.

Voici comment utiliser correctement les guillemets simples et doubles. Enregistrez ce programme sous apostrophe.py puis

exécutez-le:

apostrophe.py message = "L'une des forces de Python est sa communauté diversifiée." imprimer (message)

L'apostrophe apparaît dans un ensemble de guillemets doubles, donc l'interpréteur Python n'a
aucun problème à lire correctement la chaîne:

L'une des forces de Python est sa communauté diversifiée.

Cependant, si vous utilisez des guillemets simples, Python ne peut pas identifier où la chaîne doit se terminer:

message = 'L'une des forces de Python est sa communauté diversifiée.'


imprimer (message)

Vous verrez la sortie suivante:

Fichier "apostrophe.py", ligne 1


message = 'L'une des forces de Python est sa communauté diversifiée.'
^u
ErreurDeSyntaxe: Syntaxe invalide

Dans la sortie, vous pouvez voir que l'erreur se produit à u juste après le deuxième guillemet simple. Ce erreur de
syntaxe indique que l'interpréteur ne reconnaît pas quelque chose dans le code comme du code Python valide. Les
erreurs peuvent provenir de diverses sources, et je vais en souligner quelques-unes les plus courantes lorsqu'elles
surviennent. Vous pouvez voir souvent des erreurs de syntaxe lorsque vous apprenez à écrire du code Python approprié.
Les erreurs de syntaxe sont également le type d'erreur le moins spécifique, de sorte qu'elles peuvent être difficiles et
frustrantes à identifier et à corriger. Si vous êtes bloqué sur une erreur particulièrement tenace, consultez les suggestions
de l'annexe C.

Remarque La fonction de coloration syntaxique de votre éditeur devrait vous aider à repérer rapidement certaines erreurs de
syntaxe lorsque vous écrivez vos programmes. Si vous voyez du code Python mis en surbrillance comme s'il s'agissait
de l'anglais ou de l'anglais surligné comme s'il s'agissait de code Python, vous avez probablement un guillemet
incohérent quelque part dans votre fichier.

28 Chapitre 2
Impression en Python 2

Le impression L'instruction a une syntaxe légèrement différente dans Python 2:

>>> python2.7
>>> print "Bonjour le monde Python 2.7!"
Bonjour le monde Python 2.7!

Les parenthèses ne sont pas nécessaires autour de la phrase que vous souhaitez imprimer en Python 2.
Techniquement, impression est une fonction en Python 3, c'est pourquoi elle a besoin de parenthèses. Certains
Python 2 impression les instructions incluent des parenthèses, mais le comportement peut être un peu différent de
ce que vous verrez dans Python 3. Fondamentalement, lorsque vous regardez du code écrit en Python 2,
attendez-vous à en voir impression les déclarations entre parenthèses et certaines sans.

essayez-le vous-même

Enregistrez chacun des exercices suivants dans un fichier séparé avec un nom tel que

name_cases.py. Si vous êtes bloqué, faites une pause ou consultez les suggestions de l'annexe C.

2-3. Message personnel: Stockez le nom d'une personne dans une variable et imprimez un message à cette

personne. Votre message doit être simple, par exemple: "Bonjour Eric, aimeriez-vous apprendre un peu de Python

aujourd'hui?"

2-4. Cas de nom: Stockez le nom d'une personne dans une variable, puis imprimez le nom de cette personne en

minuscules, majuscules et en majuscules.

2-5. Citation célèbre: Trouvez une citation d'une personne célèbre que vous admirez. Imprimez le
devis et le nom de son auteur. Votre sortie doit ressembler à ce qui suit, y compris les guillemets:

Albert Einstein a dit un jour: "Une personne qui n'a jamais commis d'erreur n'a jamais

rien essayé de nouveau."

2-6. Citation célèbre 2: Répétez l'exercice 2-5, mais cette fois, enregistrez le nom de la personne célèbre dans une variable

appelée personne célèbre . Ensuite, composez votre message et stockez-le dans une nouvelle variable appelée un

message . Imprimez votre message.

2-7. Décapage des noms: Enregistrez le nom d'une personne et incluez des espaces au début et à
la fin du nom. Assurez-vous d'utiliser chaque combinaison de caractères, "\ t " et "\ n ", au moins une
fois .
Imprimez le nom une fois, de sorte que les espaces autour du nom soient affichés. Puis imprimez le

nom en utilisant chacune des trois fonctions de décapage, lstrip (),

rstrip (), et déshabiller() .

Variables et types de données simples 29


Nombres
Les nombres sont assez souvent utilisés dans la programmation pour garder le score dans les jeux, représenter
des données dans des visualisations, stocker des informations dans des applications Web, etc. Python traite les
nombres de plusieurs manières différentes, en fonction de la manière dont ils sont utilisés. Voyons d'abord
comment Python gère les entiers, car ils sont les plus simples à utiliser.

Entiers
Vous pouvez ajouter (+), soustraire (-), multiplier (*) et diviser (/) des entiers en Python.

>>> 2+3
5
>>> 3-2
1
>>> 2*3
6
>>> 3/2
1,5

Dans une session de terminal, Python renvoie simplement le résultat de l'opération. Python utilise deux
symboles de multiplication pour représenter les exposants:

>>> 3 ** 2
9
>>> 3 ** 3
27
>>> 10 ** 6
1000000

Python prend également en charge l'ordre des opérations, vous pouvez donc utiliser plusieurs opérations dans
une seule expression. Vous pouvez également utiliser des parenthèses pour modifier l'ordre des opérations afin que
Python puisse évaluer votre expression dans l'ordre que vous spécifiez. Par exemple:

>>> 2+3*4
14
>>> (2 + 3) * 4
20

L'espacement dans ces exemples n'a aucun effet sur la façon dont Python évalue les
expressions; il vous aide simplement à repérer plus rapidement les opérations prioritaires
lorsque vous lisez le code.

Flotteurs

Python appelle n'importe quel nombre avec un point décimal a flotter. Ce terme est utilisé dans la plupart des langages
de programmation et fait référence au fait qu'un point décimal peut apparaître à n'importe quelle position dans un
nombre. Chaque langage de programmation doit

30 Chapitre 2
être soigneusement conçu pour gérer correctement les nombres décimaux afin que les nombres se comportent de
manière appropriée, peu importe où la virgule décimale apparaît.
Pour la plupart, vous pouvez utiliser des décimales sans vous soucier de leur comportement. Entrez
simplement les nombres que vous souhaitez utiliser, et Python fera très probablement ce que vous attendez:

>>> 0,1 + 0,1


0,2
>>> 0,2 + 0,2
0,4
>>> 2 * 0,1
0,2
>>> 2 * 0,2
0,4

Mais sachez que vous pouvez parfois obtenir un nombre arbitraire de décimales dans votre
réponse:

>>> 0,2 + 0,1


0,30000000000000004
>>> 3 * 0,1
0,30000000000000004

Cela se produit dans toutes les langues et est peu préoccupant. Python essaie de trouver un moyen de représenter le

résultat aussi précisément que possible, ce qui est parfois difficile étant donné la façon dont les ordinateurs doivent

représenter les nombres en interne. Ignorez simplement les décimales supplémentaires pour le moment; vous apprendrez

comment gérer les places supplémentaires lorsque vous en avez besoin dans les projets de la partie II.

Éviter les erreurs de type avec la fonction str ()

Souvent, vous souhaiterez utiliser la valeur d'une variable dans un message. Par exemple, disons que vous souhaitez

souhaiter un joyeux anniversaire à quelqu'un. Vous pourriez écrire un code comme celui-ci:

anniversaire.py âge = 23
message = "Joyeux" + âge + "e anniversaire!"

imprimer (message)

Vous pourriez vous attendre à ce que ce code imprime la simple salutation d'anniversaire, Joyeux 23e
anniversaire! Mais si vous exécutez ce code, vous verrez qu'il génère une erreur:

Traceback (dernier appel le plus récent):


Fichier "birthday.py", ligne 2, dans <module>
message = "Joyeux" + âge + "e anniversaire!"
u TypeError: Impossible de convertir l'objet 'int' en str implicitement

C'est un erreur-type. Cela signifie que Python ne peut pas reconnaître le type d'informations que
vous utilisez. Dans cet exemple, Python voit à u que vous utilisez une variable qui a une valeur entière ( int), mais
on ne sait pas comment interpréter ça

Variables et types de données simples 31


évaluer. Python sait que la variable peut représenter soit la valeur numérique 23, soit les caractères 2 et 3. Lorsque
vous utilisez des entiers dans des chaînes comme celle-ci, vous devez spécifier explicitement que vous
souhaitez que Python utilise l'entier comme une chaîne de caractères. Vous pouvez le faire en enveloppant la
variable dans le
str () function, qui indique à Python de représenter les valeurs non-chaîne sous forme de chaînes:

âge = 23
message = "Joyeux" + str (âge) + "e anniversaire!"

imprimer (message)

Python sait maintenant que vous souhaitez convertir la valeur numérique 23 en chaîne et afficher les
caractères 2 et 3 dans le cadre du message d'anniversaire. Vous obtenez maintenant le message que vous
attendiez, sans aucune erreur:

Joyeux 23e anniversaire!

Travailler avec des nombres en Python est la plupart du temps simple. Si vous obtenez des
résultats inattendus, vérifiez si Python interprète vos nombres comme vous le souhaitez, soit en tant
que valeur numérique, soit en tant que valeur de chaîne.

Entiers en Python 2

Python 2 renvoie un résultat légèrement différent lorsque vous divisez deux entiers:

>>> python2.7
>>> 3/2
1

Au lieu de 1,5, Retour de Python 1. La division d'entiers dans Python 2 donne un entier
dont le reste est tronqué. Notez que le résultat n'est pas un entier arrondi; le reste est
simplement omis.
Pour éviter ce comportement dans Python 2, assurez-vous qu'au moins un des nombres est un
flottant. Ce faisant, le résultat sera également un flotteur:

>>> 3/2
1
>>> 3,0 / 2
1,5
>>> 3 / 2.0
1,5
>>> 3,0 / 2,0
1,5

Ce comportement de division est une source courante de confusion lorsque les personnes habituées à Python 3

commencent à utiliser Python 2, ou vice versa. Si vous utilisez ou créez du code qui mélange des nombres entiers et des

flottants, faites attention aux comportements irréguliers.

32 Chapitre 2
essayez-le vous-même

2-8. Numéro huit: Écrivez les opérations d'addition, de soustraction, de multiplication et de division qui aboutissent

chacune au nombre 8. Assurez-vous de joindre vos opérations impression déclarations pour voir les résultats. Vous

devez créer quatre lignes qui ressemblent à ceci:

imprimer (5 + 3)

Votre sortie doit être simplement quatre lignes avec le numéro 8 apparaissant une fois sur chaque ligne.

2-9. Numéro préféré: Stockez votre numéro préféré dans une variable. Ensuite, en utilisant cette variable,

créez un message qui révèle votre numéro préféré. Imprimez ce message.

commentaires

Les commentaires sont une fonctionnalité extrêmement utile dans la plupart des langages de programmation. Tout ce que
vous avez écrit dans vos programmes jusqu'à présent est du code Python. Au fur et à mesure que vos programmes
deviennent plus longs et plus compliqués, vous devez ajouter des notes dans vos programmes qui décrivent votre approche
globale du problème que vous résolvez. UNE commenter vous permet d'écrire des notes en anglais dans vos programmes.

Comment rédigez-vous des commentaires?

En Python, le signe dièse (#) indique un commentaire. Tout ce qui suit une marque de hachage dans
votre code est ignoré par l'interpréteur Python. Par exemple:

comment.py # Dis bonjour à tout le monde.


print ("Bonjour les gens de Python!")

Python ignore la première ligne et exécute la deuxième ligne.

Bonjour les gens de Python!

Quel genre de commentaires devez-vous rédiger?

La principale raison d'écrire des commentaires est d'expliquer ce que votre code est censé faire et comment
vous le faites fonctionner. Lorsque vous êtes en train de travailler sur un projet, vous comprenez comment toutes
les pièces s'emboîtent. Mais lorsque vous revenez à un projet après un certain temps d'absence, vous aurez
probablement oublié certains détails. Vous pouvez toujours étudier votre code pendant un certain temps et
comprendre comment les segments étaient censés fonctionner, mais écrire de bons commentaires peut vous
faire gagner du temps en résumant votre approche globale en anglais clair.

Variables et types de données simples 33


Si vous souhaitez devenir un programmeur professionnel ou collaborer avec d'autres programmeurs, vous devez

écrire des commentaires significatifs. Aujourd'hui, la plupart des logiciels sont écrits en collaboration, que ce soit par un

groupe d'employés d'une entreprise ou par un groupe de personnes travaillant ensemble sur un projet open source. Les

programmeurs expérimentés s'attendent à voir des commentaires dans le code, il est donc préférable de commencer à

ajouter des commentaires descriptifs à vos programmes dès maintenant. Écrire des commentaires clairs et concis dans

votre code est l'une des habitudes les plus bénéfiques que vous puissiez adopter en tant que nouveau programmeur.

Lorsque vous décidez d'écrire un commentaire, demandez-vous si vous deviez envisager plusieurs approches
avant de trouver un moyen raisonnable de faire fonctionner quelque chose; si tel est le cas, écrivez un commentaire sur
votre solution. Il est beaucoup plus facile de supprimer des commentaires supplémentaires plus tard que de revenir en
arrière et d'écrire des commentaires pour un programme peu commenté. À partir de maintenant, j'utiliserai des
commentaires dans des exemples tout au long de ce livre pour aider à expliquer des sections de code.

essayez-le vous-même

2-10. Ajout de commentaires: Choisissez deux des programmes que vous avez écrits et ajoutez au moins un

commentaire à chacun. Si vous n'avez rien de spécifique à écrire parce que vos programmes sont trop simples

à ce stade, ajoutez simplement votre nom et la date du jour en haut de chaque fichier programme. Ensuite,

écrivez une phrase décrivant ce que fait le programme.

le zen de Python
Pendant longtemps, le langage de programmation Perl a été le pilier d'Internet. La plupart des sites
Web interactifs au début étaient alimentés par des scripts Perl. À l'époque, la devise de la communauté
Perl était: «Il y a plus d'une façon de le faire.» Les gens ont aimé cet état d'esprit pendant un certain
temps, car la flexibilité écrite dans la langue permettait de résoudre la plupart des problèmes de
différentes manières. Cette approche était acceptable lorsque vous travailliez sur vos propres projets,
mais les gens ont finalement réalisé que l'accent mis sur la flexibilité rendait difficile le maintien de
grands projets sur de longues périodes. Il était difficile, fastidieux et long de réviser le code et d'essayer
de comprendre ce que quelqu'un d'autre pensait quand il résolvait un problème complexe.

Les programmeurs Python expérimentés vous encourageront à éviter la complexité et à viser la


simplicité chaque fois que possible. La philosophie de la communauté Python est contenue dans «The
Zen of Python» de Tim Peters. Vous pouvez accéder à ce bref ensemble de principes pour écrire un bon
code Python en entrant importer ceci dans votre interprète. Je ne reproduirai pas l'intégralité du «Zen de

34 Chapitre 2
Python »ici, mais je vais partager quelques lignes pour vous aider à comprendre pourquoi elles devraient être
importantes pour vous en tant que programmeur Python débutant.

>>> importer ceci


Le Zen de Python, par Tim Peters

Beau est mieux que laid.

Les programmeurs Python acceptent l'idée que le code peut être beau et élégant. En programmation, les
gens résolvent des problèmes. Les programmeurs ont toujours respecté des solutions bien conçues, efficaces et
même belles aux problèmes. Au fur et à mesure que vous en apprenez davantage sur Python et que vous
l'utilisez pour écrire plus de code, quelqu'un pourrait un jour regarder par-dessus votre épaule et dire: "Wow,
c'est du beau code!"

Le simple vaut mieux que le complexe.

Si vous avez le choix entre une solution simple et une solution complexe, et que les deux fonctionnent,
utilisez la solution simple. Votre code sera plus facile à maintenir, et il sera plus facile pour vous et les autres de
construire sur ce code plus tard.

Complexe vaut mieux que compliqué.

La vraie vie est compliquée, et parfois une solution simple à un problème est impossible à atteindre. Dans ce
cas, utilisez la solution la plus simple qui fonctionne.

La lisibilité compte.

Même lorsque votre code est complexe, essayez de le rendre lisible. Lorsque vous travaillez sur un projet qui
implique un codage complexe, concentrez-vous sur la rédaction de commentaires informatifs pour ce code.

Il devrait y avoir une - et de préférence une seule - façon évidente de le faire.

Si deux programmeurs Python sont invités à résoudre le même problème, ils devraient proposer des
solutions assez compatibles. Cela ne veut pas dire qu'il n'y a pas de place pour la créativité dans la
programmation. Au contraire! Mais une grande partie de la programmation consiste à utiliser de petites
approches communes à des situations simples dans un projet plus vaste et plus créatif. Les détails de vos
programmes devraient avoir un sens pour les autres programmeurs Python.

C'est mieux que jamais.

Vous pourriez passer le reste de votre vie à apprendre toutes les subtilités de Python et de la
programmation en général, mais vous ne termineriez jamais aucun projet. N'essayez pas d'écrire un code
parfait; écrivez du code qui fonctionne, puis décidez s'il faut améliorer votre code pour ce projet ou passer
à quelque chose de nouveau.

Variables et types de données simples 35


Au fur et à mesure que vous passez au chapitre suivant et que vous commencez à creuser des sujets plus
complexes, essayez de garder à l'esprit cette philosophie de simplicité et de clarté. Les programmeurs expérimentés
respecteront davantage votre code et se feront un plaisir de vous faire part de vos commentaires et de collaborer
avec vous sur des projets intéressants.

essayez-le vous-même

2-11. Zen de Python: Entrer importer ceci dans une session de terminal Python et parcourez les principes

supplémentaires.

résumé
Dans ce chapitre, vous avez appris à travailler avec des variables. Vous avez appris à utiliser des noms de
variables descriptifs et à résoudre les erreurs de nom et de syntaxe lorsqu'elles surviennent. Vous avez appris ce
que sont les chaînes et comment afficher des chaînes en minuscules, majuscules et titlecase. Vous avez
commencé à utiliser des espaces pour organiser proprement la sortie et vous avez appris à supprimer les espaces
inutiles des différentes parties d'une chaîne. Vous avez commencé à travailler avec des entiers et des flottants, et
vous avez lu des informations sur certains comportements inattendus à surveiller lorsque vous travaillez avec des
données numériques. Vous avez également appris à rédiger des commentaires explicatifs pour rendre votre code
plus facile à lire pour vous et les autres. Enfin, vous lisez la philosophie de garder votre code aussi simple que
possible, dans la mesure du possible.

Dans le chapitre 3, vous apprendrez à stocker des collections d'informations dans des variables appelées listes. Vous
apprendrez à travailler sur une liste, en manipulant toutes les informations de cette liste.

36 Chapitre 2
3
IntroDuCing l I st s

Dans ce chapitre et le suivant, vous apprendrez ce que sont les listes

et comment commencer à travailler avec les éléments d'une liste. Les listes vous

permettent de stocker des ensembles d'informations en un seul endroit, que vous

ne disposiez que de quelques éléments ou de millions d'éléments. Les listes sont

l'une des fonctionnalités les plus puissantes de Python facilement accessibles aux

nouveaux programmeurs, et elles relient de nombreux concepts importants de la

programmation.

qu'est-ce qu'une liste?

UNE liste est une collection d'articles dans un ordre particulier. Vous pouvez créer une liste qui comprend
les lettres de l'alphabet, les chiffres de 0 à 9 ou les noms de
tous les membres de votre famille. Vous pouvez mettre tout ce que vous voulez dans une liste, et
les éléments de votre liste n'ont pas à être liés d'une manière particulière. Étant donné qu'une liste
contient généralement plus d'un élément, il est judicieux de rendre le nom de votre liste au pluriel, tel
que lettres, chiffres, ou noms.
En Python, les crochets ([]) indiquent une liste et les éléments individuels de la liste sont
séparés par des virgules. Voici un exemple simple de liste contenant quelques types de vélos:

bicycles.py bicycles = ['trek', 'cannondale', 'redline', 'specialized'] print (bicyclettes)

Si vous demandez à Python d'imprimer une liste, Python renvoie sa représentation de la liste, y
compris les crochets:

['trek', 'cannondale', 'redline', 'spécialisé']

Comme ce n'est pas la sortie que vous voulez que vos utilisateurs voient, apprenons comment accéder aux
éléments individuels d'une liste.

Accéder aux éléments d'une liste

Les listes sont des collections ordonnées, vous pouvez donc accéder à n'importe quel élément d'une liste
en indiquant à Python la position, ou indice, de l'élément souhaité. Pour accéder à un élément d'une liste,
écrivez le nom de la liste suivi de l'index de l'élément entre crochets.

Par exemple, sortons le premier vélo de la liste Vélos:

bicycles = ['trek', 'cannondale', 'redline', 'spécialisé']


u imprimer (bicyclettes [0])

La syntaxe pour cela est indiquée à u. Lorsque nous demandons un seul élément d'une liste,
Python renvoie uniquement cet élément sans crochets ni guillemets:

randonnée

C'est le résultat que vous voulez que vos utilisateurs voient: une sortie propre et bien formatée.

Vous pouvez également utiliser les méthodes de chaîne du chapitre 2 sur n'importe quel élément d'une liste. Par

exemple, vous pouvez mettre en forme l'élément ' randonnée' plus proprement en utilisant le Titre() méthode:

bicycles = ['trek', 'cannondale', 'redline', 'spécialisé']


imprimer (bicyclettes [0] .title ())

Cet exemple produit la même sortie que l'exemple précédent sauf ' Randonnée' est en
majuscule.

38 chapitre 3
Les positions d'index commencent à 0, pas à 1

Python considère que le premier élément d'une liste est à la position 0, pas à la position 1. Cela est vrai pour
la plupart des langages de programmation, et la raison est liée à la manière dont les opérations de liste sont
implémentées à un niveau inférieur. Si vous recevez des résultats inattendus, déterminez si vous faites une
simple erreur ponctuelle.

Le deuxième élément d'une liste a un index de 1. En utilisant ce système de comptage simple, vous pouvez
obtenir n'importe quel élément que vous voulez d'une liste en soustrayant un de sa position dans la liste. Par
exemple, pour accéder au quatrième élément d'une liste, vous demandez l'élément à l'index 3.

Ce qui suit demande les vélos à l'index 1 et index 3:

bicycles = ['trek', 'cannondale', 'redline', 'spécialisé']


imprimer (bicyclettes [1])
imprimer (bicyclettes [3])

Ce code renvoie les deuxième et quatrième vélos de la liste:

cannondale
spécialisé

Python a une syntaxe spéciale pour accéder au dernier élément d'une liste. En demandant l'article à
l'index - 1, Python renvoie toujours le dernier élément de la liste:

bicycles = ['trek', 'cannondale', 'redline', 'spécialisé']


imprimer (bicyclettes [-1])

Ce code renvoie la valeur ' spécialisé'. Cette syntaxe est assez utile, car vous voudrez souvent accéder
aux derniers éléments d'une liste sans savoir exactement quelle est la longueur de la liste. Cette
convention s'étend également à d'autres valeurs d'indice négatives. L'index - 2 renvoie le deuxième
élément de la fin de la liste, l'index - 3 renvoie le troisième élément à partir de la fin, et ainsi de suite.

Utilisation de valeurs individuelles à partir d'une liste

Vous pouvez utiliser des valeurs individuelles d'une liste comme vous le feriez pour n'importe quelle autre variable. Par

exemple, vous pouvez utiliser la concaténation pour créer un message basé sur une valeur d'une liste.

Essayons de retirer le premier vélo de la liste et de composer un message en utilisant cette valeur.

bicycles = ['trek', 'cannondale', 'redline', 'spécialisé']


u message = "Mon premier vélo était un" + vélos [0] .title () + "."

imprimer (message)

Présentation des listes 39


À u, nous construisons une phrase en utilisant la valeur à vélos [0] et stockez-le dans la variable un
message. Le résultat est une phrase simple sur le premier vélo de la liste:

Mon premier vélo était un Trek.

essayez-le vous-même

Essayez ces programmes courts pour obtenir une expérience de première main avec les listes de Python. Vous voudrez

peut-être créer un nouveau dossier pour les exercices de chaque chapitre afin de les garder organisés.

3-1. Noms: Stockez les noms de quelques-uns de vos amis dans une liste appelée noms . Imprimez le nom de chaque

personne en accédant à chaque élément de la liste, un à la fois.

3-2. Les salutations: Commencez par la liste que vous avez utilisée dans l'exercice 3-1, mais au lieu de simplement

imprimer le nom de chaque personne, imprimez-leur un message. Le texte de chaque message doit être le même, mais

chaque message doit être personnalisé avec le nom de la personne.

3-3. Votre propre liste: Pensez à votre mode de transport préféré, comme une moto ou une voiture, et
faites une liste qui contient plusieurs exemples. Utilisez votre liste pour imprimer une série d'énoncés sur
ces éléments, tels que «Je souhaite posséder une moto Honda».

Modification, ajout et suppression d'éléments


La plupart des listes que vous créez seront dynamiques, ce qui signifie que vous construirez une liste, puis y
ajouterez et en supprimerez des éléments au fur et à mesure que votre programme exécute son cours. Par exemple,
vous pouvez créer un jeu dans lequel un joueur doit tirer des extraterrestres hors du ciel. Vous pouvez stocker
l'ensemble initial d'étrangers dans une liste, puis supprimer un extraterrestre de la liste chaque fois qu'un est abattu.
Chaque fois qu'un nouvel extraterrestre apparaît à l'écran, vous l'ajoutez à la liste. Votre liste d'extraterrestres
diminuera et augmentera en longueur tout au long du jeu.

Modification d'éléments dans une liste

La syntaxe de modification d'un élément est similaire à la syntaxe d'accès à un élément d'une liste. Pour
modifier un élément, utilisez le nom de la liste suivi de l'index de l'élément que vous souhaitez modifier,
puis indiquez la nouvelle valeur que vous souhaitez que cet élément ait.

40 chapitre 3
Par exemple, disons que nous avons une liste de motos et que le premier élément de la liste est ' honda '. Comment
changerions-nous la valeur de ce premier élément?

motorcycles.py u motos = ['honda', 'yamaha', 'suzuki']


imprimer (motos)

v motos [0] = 'ducati'


imprimer (motos)

Le code à u définit la liste d'origine, avec ' Honda ' comme premier élément. Le code à v remplace
la valeur du premier élément par ' ducati '. La sortie montre que le premier élément a bien été
modifié et que le reste de la liste reste le même:

['honda', 'yamaha', 'suzuki']


['ducati', 'yamaha', 'suzuki']

Vous pouvez modifier la valeur de n'importe quel élément d'une liste, pas seulement le premier élément.

Ajout d'éléments à une liste

Vous souhaiterez peut-être ajouter un nouvel élément à une liste pour de nombreuses raisons. Par exemple, vous

souhaiterez peut-être faire apparaître de nouveaux extraterrestres dans un jeu, ajouter de nouvelles données à une

visualisation ou ajouter de nouveaux utilisateurs enregistrés à un site Web que vous avez créé. Python propose

plusieurs façons d'ajouter de nouvelles données aux listes existantes.

ajout d'éléments à la fin d'une liste

Le moyen le plus simple d'ajouter un nouvel élément à une liste consiste à ajouter l'élément dans la liste. Lorsque
vous ajoutez un élément à une liste, le nouvel élément est ajouté à la fin de la liste. En utilisant la même liste que
nous avions dans l'exemple précédent, nous ajouterons le nouvel élément ' ducati ' à la fin de la liste:

motos = ['honda', 'yamaha', 'suzuki'] imprimer (motos)

u motorcycles.append ('ducati')
imprimer (motos)

Le ajouter() méthode à u ajoute ' ducati ' à la fin de la liste sans affecter aucun des autres
éléments de la liste:

['honda', 'yamaha', 'suzuki']


['honda', 'yamaha', 'suzuki', 'ducati']

Présentation des listes 41


Le ajouter() La méthode facilite la création dynamique de listes. Par exemple, vous pouvez commencer
avec une liste vide, puis ajouter des éléments à la liste en utilisant une série de ajouter() déclarations. En
utilisant une liste vide, ajoutons le ele-
ments ' honda ',' yamaha ', et ' Suzuki ' à la liste:

motos = []

motorcycles.append ('honda')
motorcycles.append ('yamaha')
motorcycles.append ('suzuki')

imprimer (motos)

La liste résultante a exactement la même apparence que les listes des exemples précédents:

['honda', 'yamaha', 'suzuki']

Construire des listes de cette manière est très courant, car vous ne saurez souvent pas les données que vos

utilisateurs souhaitent stocker dans un programme tant que le programme n'est pas en cours d'exécution. Pour mettre vos

utilisateurs sous contrôle, commencez par définir une liste vide qui contiendra les valeurs des utilisateurs. Ajoutez ensuite

chaque nouvelle valeur fournie à la liste que vous venez de créer.

Insertion d'éléments dans une liste

Vous pouvez ajouter un nouvel élément à n'importe quelle position de votre liste en utilisant le insérer()

méthode. Pour ce faire, spécifiez l'index du nouvel élément et la valeur du nouvel


élément.

motos = ['honda', 'yamaha', 'suzuki']

u motorcycles.insert (0, 'ducati')


imprimer (motos)

Dans cet exemple, le code à u insère la valeur ' ducati ' au début de la liste. Le insérer() méthode
ouvre un espace à la position 0 et stocke la valeur ' ducati ' à cet endroit. Cette opération décale
toutes les autres valeurs de la liste d'une position vers la droite:

['ducati', 'honda', 'yamaha', 'suzuki']

Suppression d'éléments d'une liste

Souvent, vous souhaiterez supprimer un élément ou un ensemble d'éléments d'une liste. Par exemple,
lorsqu'un joueur abat un extraterrestre du ciel, vous voudrez probablement le supprimer de la liste des
extraterrestres actifs. Ou lorsqu'un utilisateur

42 chapitre 3
décide d'annuler son compte sur une application Web que vous avez créée, vous souhaiterez
supprimer cet utilisateur de la liste des utilisateurs actifs. Vous pouvez supprimer un élément selon sa
position dans la liste ou selon sa valeur.

suppression d'un élément à l'aide de l'instruction del

Si vous connaissez la position de l'élément que vous souhaitez supprimer d'une liste, vous pouvez utiliser le del déclaration.

motos = ['honda', 'yamaha', 'suzuki'] imprimer (motos)

u de motos [0]
imprimer (motos)

Le code à u les usages del pour supprimer le premier élément, ' Honda ', dans la liste des motos:

['honda', 'yamaha', 'suzuki']


['yamaha', 'suzuki']

Vous pouvez supprimer un élément de n’importe quelle position dans une liste à l’aide du del déclaration si vous
connaissez son index. Par exemple, voici comment supprimer le deuxième élément, " yamaha ', dans la liste:

motos = ['honda', 'yamaha', 'suzuki'] imprimer (motos)

de motos [1]
imprimer (motos)

La deuxième moto est supprimée de la liste:

['honda', 'yamaha', 'suzuki']


['honda', 'suzuki']

Dans les deux exemples, vous ne pouvez plus accéder à la valeur qui a été supprimée de la liste après
le del instruction est utilisée.

suppression d'un élément à l'aide de la méthode pop ()

Parfois, vous souhaiterez utiliser la valeur d'un élément après l'avoir supprimé d'une liste. Par exemple, vous
souhaiterez peut-être obtenir le X et y position d'un extraterrestre qui vient d'être abattu, vous pouvez donc
dessiner une explosion à cette position. Dans une application Web, vous souhaiterez peut-être supprimer un
utilisateur d'une liste de membres actifs, puis l'ajouter à une liste de membres inactifs.

Le pop() La méthode supprime le dernier élément d'une liste, mais elle vous permet de travailler avec
cet élément après l'avoir supprimé. Le terme pop vient de penser à une liste comme une pile d'éléments et
de faire sauter un élément du haut de la pile. Dans cette analogie, le haut d'une pile correspond à la fin
d'une liste.

Présentation des listes 43


Faisons apparaître une moto de la liste des motos:

u motos = ['honda', 'yamaha', 'suzuki']


imprimer (motos)

v popped_motorcycle = motos.pop ()
w imprimer (motos)
X imprimer (popped_motorcycle)

Nous commençons par définir et imprimer la liste motocyclettes à u. À v nous sortons une valeur de la
liste et stockons cette valeur dans la variable popped_motorcycle.
Nous imprimons la liste à w pour montrer qu'une valeur a été supprimée de la liste. Ensuite, nous imprimons la
valeur sautée à X pour prouver que nous avons toujours accès à la valeur qui a été supprimée.

La sortie montre que la valeur ' Suzuki ' a été supprimé de la fin de la liste et est maintenant
stocké dans la variable popped_motorcycle:

['honda', 'yamaha', 'suzuki']


['honda', 'yamaha']
Suzuki

Comment cela pourrait-il pop() méthode être utile? Imaginez que les motos de la liste soient stockées dans
l'ordre chronologique en fonction du moment où nous les possédions. Si tel est le cas, nous pouvons utiliser le pop()
méthode pour imprimer une déclaration sur la dernière moto que nous avons achetée:

motos = ['honda', 'yamaha', 'suzuki']

last_ented = motos.pop ()
print ("La dernière moto que j'ai possédée était une" + last_ented.title () + ".")

Le résultat est une simple phrase sur la moto la plus récente que nous possédions:

La dernière moto que je possédais était une Suzuki.

Faire sauter des éléments à partir de n'importe quelle position dans une liste

Vous pouvez réellement utiliser pop() pour supprimer un élément d'une liste à n'importe quelle position en incluant

l'index de l'élément que vous souhaitez supprimer entre parenthèses.

motos = ['honda', 'yamaha', 'suzuki']

u first_own = motos.pop (0)


v print ('La première moto que j'ai possédée était une' + first_ented.title () + '.')

44 chapitre 3
Nous commençons par faire apparaître la première moto de la liste à u, puis nous imprimons un
message sur cette moto à v. Le résultat est une simple phrase décrivant la première moto que j'ai jamais
possédée:

La première moto que j'ai possédée était une Honda.

N'oubliez pas que chaque fois que vous utilisez pop(), l'élément avec lequel vous travaillez n'est plus stocké dans
la liste.
Si vous n'êtes pas sûr d'utiliser le del déclaration ou le pop() méthode, voici un moyen simple de décider: lorsque vous
souhaitez supprimer un élément d'une liste et ne pas l'utiliser de quelque manière que ce soit, utilisez la del déclaration; si
vous souhaitez utiliser un élément au fur et à mesure que vous le supprimez, utilisez le pop() méthode.

suppression d'un élément par valeur

Parfois, vous ne saurez pas la position de la valeur que vous souhaitez supprimer d'une liste. Si vous ne
connaissez que la valeur de l'élément que vous souhaitez supprimer, vous pouvez utiliser le supprimer() méthode.

Par exemple, disons que nous voulons supprimer la valeur ' ducati ' de la liste des motos.

motos = ['honda', 'yamaha', 'suzuki', 'ducati'] imprimer (motos)

u motorcycles.remove ('ducati')
imprimer (motos)

Le code à u dit à Python de savoir où ' ducati ' apparaît dans la liste et supprimez cet
élément:

['honda', 'yamaha', 'suzuki', 'ducati'] ['honda', 'yamaha',


'suzuki']

Vous pouvez également utiliser le supprimer() méthode pour travailler avec une valeur qui est
supprimée d'une liste. Supprimons la valeur ' ducati ' et imprimez une raison pour le supprimer de la liste:

u motos = ['honda', 'yamaha', 'suzuki', 'ducati']


imprimer (motos)

v too_expensive = 'ducati'
w motorcycles.remove (trop cher)
imprimer (motos)
X print ("\ nA" + too_expensive.title () + "est trop cher pour moi.")

Après avoir défini la liste à u, nous stockons la valeur ' ducati ' dans une variable appelée trop cher v. Nous
utilisons ensuite cette variable pour indiquer à Python quelle valeur

Présentation des listes 45


pour retirer de la liste à w. À X la valeur ' ducati ' a été supprimé de la liste mais est toujours stocké dans la
variable trop cher, nous permettant d'imprimer une déclaration expliquant pourquoi nous avons supprimé ' ducati
' dans la liste des motos:

['honda', 'yamaha', 'suzuki', 'ducati'] ['honda', 'yamaha',


'suzuki']

Une Ducati est trop chère pour moi.

Remarque Le supprimer() La méthode supprime uniquement la première occurrence de la valeur que vous spécifiez. S'il est possible que
la valeur apparaisse plus d'une fois dans la liste, vous devrez utiliser une boucle pour déterminer si toutes les occurrences de
la valeur ont été supprimées. Vous apprendrez comment procéder au chapitre 7.

essayez-le vous-même

Les exercices suivants sont un peu plus complexes que ceux du chapitre 2, mais ils vous donnent
l'occasion d'utiliser les listes de toutes les manières décrites.

3-4. Liste des invités: Si vous pouviez inviter quelqu'un, vivant ou décédé, à dîner, qui inviteriez-vous? Faites

une liste comprenant au moins trois personnes que vous aimeriez inviter à dîner. Ensuite, utilisez votre liste

pour imprimer un message à chaque personne, les invitant à dîner.

3-5. Modification de la liste des invités: Vous venez d'apprendre qu'un de vos invités ne peut pas préparer le dîner, vous

devez donc envoyer une nouvelle série d'invitations. Vous devrez penser à quelqu'un d'autre à inviter.

• Commencez par votre programme de l'exercice 3-4. Ajouter un impression déclaration à la fin de votre

programme indiquant le nom de l'invité qui ne peut pas participer.

• Modifiez votre liste en remplaçant le nom de l'invité qui ne peut pas le faire par le nom de la
nouvelle personne que vous invitez.

• Imprimez un deuxième ensemble de messages d'invitation, un pour chaque personne qui est toujours dans votre liste.

3-6. Plus d'invités: Vous venez de trouver une plus grande table à manger, donc maintenant plus d'espace est disponible.

Pensez à trois autres invités à inviter à dîner.

• Commencez par votre programme de l'exercice 3-4 ou de l'exercice 3-5. Ajouter un impression

déclaration à la fin de votre programme informant les gens que vous avez trouvé une table plus

grande.

• Utilisation insérer() pour ajouter un nouvel invité au début de votre liste. Utilisation insérer() pour

• ajouter un nouvel invité au milieu de votre liste. Utilisation ajouter() pour ajouter un nouvel invité

• à la fin de votre liste.

• Imprimez un nouvel ensemble de messages d'invitation, un pour chaque personne de votre liste.

46 chapitre 3
3-7. Réduction de la liste des invités: Vous venez de découvrir que votre nouvelle table n'arrivera pas à temps pour

le dîner et que vous n'avez de la place que pour deux invités.

• Commencez par votre programme de l'exercice 3-6. Ajoutez une nouvelle ligne qui imprime un message indiquant

que vous ne pouvez inviter que deux personnes à dîner.

• Utilisation pop() pour supprimer des invités de votre liste un par un jusqu'à ce qu'il ne reste plus que deux noms dans votre

liste. Chaque fois que vous faites apparaître un nom dans votre liste, imprimez un message à cette personne pour lui faire

savoir que vous êtes désolé de ne pas pouvoir l'inviter à dîner.

• Imprimez un message à chacune des deux personnes toujours sur votre liste, en leur faisant savoir qu'elles sont toujours

invitées.

• Utilisation del pour supprimer les deux derniers noms de votre liste, de sorte que vous ayez une liste vide. Imprimez votre

liste pour vous assurer que vous avez effectivement une liste vide à la fin de votre programme.

organiser une liste


Souvent, vos listes seront créées dans un ordre imprévisible, car vous ne pouvez pas toujours contrôler
l'ordre dans lequel vos utilisateurs fournissent leurs données. Bien que cela soit inévitable dans la plupart
des cas, vous souhaiterez souvent présenter vos informations dans un ordre particulier. Parfois, vous
souhaiterez conserver l'ordre d'origine de votre liste, et d'autres fois, vous souhaiterez modifier l'ordre
d'origine. Python fournit un certain nombre de façons différentes d'organiser vos listes, en fonction de la
situation.

Trier une liste de manière permanente avec la méthode sort ()

Python Trier() La méthode rend relativement facile le tri d'une liste. Imaginez que nous ayons une liste de voitures
et que nous voulions changer l'ordre de la liste pour les stocker par ordre alphabétique. Pour simplifier la tâche,
supposons que toutes les valeurs de la liste soient en minuscules.

cars.py voitures = ['bmw', 'audi', 'toyota', 'subaru']


u voitures.sort ()
imprimer (voitures)

Le Trier() méthode, illustrée à u, modifie définitivement l'ordre de la liste. Les voitures sont
maintenant dans l'ordre alphabétique, et nous ne pouvons jamais revenir à l'ordre d'origine:

['audi', 'bmw', 'subaru', 'toyota']

Présentation des listes 47


Vous pouvez également trier cette liste dans l'ordre alphabétique inverse en passant l'argument reverse
= Vrai à la Trier() méthode. L'exemple suivant trie la liste des voitures dans l'ordre alphabétique inverse:

voitures = ['bmw', 'audi', 'toyota', 'subaru']


cars.sort (reverse = True)
imprimer (voitures)

Encore une fois, l'ordre de la liste est modifié de manière permanente:

['toyota', 'subaru', 'bmw', 'audi']

Tri temporaire d'une liste avec la fonction sorted ()

Pour conserver l'ordre d'origine d'une liste mais la présenter dans un ordre trié, vous pouvez utiliser le trié
() fonction. Le trié () La fonction vous permet d'afficher votre liste dans un ordre particulier mais n'affecte
pas l'ordre réel de la liste.
Essayons cette fonction sur la liste des voitures.

voitures = ['bmw', 'audi', 'toyota', 'subaru']

u print ("Voici la liste d'origine:")


imprimer (voitures)

v print ("\ nVoici la liste triée:")


imprimer (trié (voitures))

w print ("\ nVoici à nouveau la liste d'origine:")


imprimer (voitures)

Nous imprimons d'abord la liste dans son ordre d'origine à u puis par ordre alphabétique à v. Une fois la
liste affichée dans le nouvel ordre, nous montrons que la liste est toujours stockée dans son ordre d'origine à w.

Voici la liste originale:


['bmw', 'audi', 'toyota', 'subaru']

Voici la liste triée:


['audi', 'bmw', 'subaru', 'toyota']

X Voici à nouveau la liste originale:


['bmw', 'audi', 'toyota', 'subaru']

Notez que la liste existe toujours dans son ordre d'origine à X après le trié ()
fonction a été utilisée. Le trié () fonction peut également accepter un reverse = Vrai
argument si vous souhaitez afficher une liste dans l'ordre alphabétique inverse.

48 chapitre 3
Remarque Trier une liste par ordre alphabétique est un peu plus compliqué lorsque toutes les valeurs ne sont pas en minuscules. Il
existe plusieurs façons d'interpréter les lettres majuscules lorsque vous décidez d'un ordre de tri, et la spécification de l'ordre
exact peut être plus complexe que ce que nous voulons traiter pour le moment. Cependant, la plupart des approches de tri
s'appuieront directement sur ce que vous avez appris dans cette section.

Impression d'une liste dans l'ordre inverse

Pour inverser l'ordre d'origine d'une liste, vous pouvez utiliser le sens inverse() méthode. Si nous stockions à l'origine la
liste des voitures dans l'ordre chronologique en fonction du moment où nous les possédions, nous pourrions
facilement réorganiser la liste dans l'ordre chronologique inverse:

voitures = ['bmw', 'audi', 'toyota', 'subaru']


imprimer (voitures)

voitures.reverse ()
imprimer (voitures)

Remarquerez que sens inverse() ne trie pas dans l'ordre alphabétique; il inverse simplement
l'ordre de la liste:

['bmw', 'audi', 'toyota', 'subaru'] ['subaru', 'toyota',


'audi', 'bmw']

Le sens inverse() modifie définitivement l'ordre d'une liste, mais vous pouvez revenir à l'ordre
d'origine à tout moment en appliquant sens inverse() à la même liste une deuxième fois.

Recherche de la longueur d'une liste

Vous pouvez trouver rapidement la longueur d'une liste en utilisant le len () fonction. La liste de cet exemple comporte
quatre éléments, sa longueur est donc 4:

>>> voitures = ['bmw', 'audi', 'toyota', 'subaru']


>>> len (voitures)

Tu trouveras len () utile lorsque vous avez besoin d'identifier le nombre d'extraterrestres qui doivent
encore être abattus dans un jeu, de déterminer la quantité de données que vous devez gérer dans une
visualisation ou de calculer le nombre d'utilisateurs enregistrés sur un site Web, entre autres tâches.

Remarque Python compte les éléments dans une liste en commençant par un, vous ne devriez donc pas vous heurter à des erreurs
ponctuelles lors de la détermination de la longueur d'une liste.

Présentation des listes 49


essayez-le vous-même

3-8. Voir le monde: Pensez à au moins cinq endroits dans le monde que vous aimeriez visiter.

• Stockez les emplacements dans une liste. Assurez-vous que la liste n'est pas dans l'ordre alphabétique.

• Imprimez votre liste dans son ordre d'origine. Ne vous inquiétez pas pour imprimer la liste proprement, imprimez-la simplement

sous forme de liste Python brute.

• Utilisation trié () pour imprimer votre liste par ordre alphabétique sans modifier la liste actuelle.

• Montrez que votre liste est toujours dans son ordre d'origine en l'imprimant.

• Utilisation trié () pour imprimer votre liste dans l'ordre alphabétique inverse sans changer l'ordre de la
liste d'origine.

• Montrez que votre liste est toujours dans son ordre d'origine en l'imprimant à nouveau.

• Utilisation sens inverse() pour changer l'ordre de votre liste. Imprimez la liste pour montrer que son ordre a changé.

• Utilisation sens inverse() pour modifier à nouveau l'ordre de votre liste. Imprimez la liste pour montrer qu'elle est revenue à son

ordre d'origine.

• Utilisation Trier() pour modifier votre liste afin qu'elle soit stockée par ordre alphabétique. Imprimez la liste pour

montrer que son ordre a été modifié.

• Utilisation Trier() pour modifier votre liste afin qu'elle soit stockée dans l'ordre alphabétique inverse. Imprimez la liste

pour montrer que son ordre a changé.

3-9. Invités du dîner: En travaillant avec l'un des programmes des exercices 3-4 à 3-7 (page 46),
utilisez len () pour imprimer un message indiquant le nombre de personnes que vous invitez à dîner.

3-10. Chaque fonction: Pensez à quelque chose que vous pourriez stocker dans une liste. Par exemple, vous pouvez

créer une liste de montagnes, de rivières, de pays, de villes, de langues ou de tout ce que vous souhaitez. Écrivez un

programme qui crée une liste contenant ces éléments et utilise ensuite chaque fonction présentée dans ce chapitre au

moins une fois.

éviter les erreurs d'index lors de l'utilisation de listes


Un type d'erreur est courant lorsque vous travaillez avec des listes pour la première fois. Disons que vous
avez une liste de trois éléments et que vous demandez le quatrième élément:

motos = ['honda', 'yamaha', 'suzuki'] imprimer (motos [3])

50 chapitre 3
Cet exemple aboutit à un erreur d'index:

Traceback (dernier appel le plus récent):


Fichier "motorcycles.py", ligne 3, dans <module>
imprimer (motos [3])
IndexError: index de liste hors limites

Python tente de vous donner l'élément à l'index 3. Mais lorsqu'il recherche dans la liste, aucun élément dans
motocyclettes a un index de 3. En raison de la nature hors par un de l'indexation dans les listes, cette erreur est
typique. Les gens pensent que le troisième élément est l'élément numéro 3, car ils commencent à compter à 1.
Mais en Python, le troisième élément est le numéro 2, car il commence à indexer à 0.

Une erreur d'index signifie que Python ne peut pas déterminer l'index que vous avez demandé. Si une erreur d'index

se produit dans votre programme, essayez d'ajuster l'index que vous demandez par un. Ensuite, exécutez à nouveau le

programme pour voir si les résultats sont corrects.

Gardez à l'esprit que chaque fois que vous souhaitez accéder au dernier élément d'une liste, vous utilisez
l'index - 1. Cela fonctionnera toujours, même si votre liste a changé de taille depuis la dernière fois que vous y avez
accédé:

motos = ['honda', 'yamaha', 'suzuki']


imprimer (motos [-1])

L'index - 1 renvoie toujours le dernier élément d'une liste, dans ce cas la valeur
«suzuki»:

«suzuki»

Le seul moment où cette approche provoquera une erreur est lorsque vous demandez le dernier élément
d'une liste vide:

motos = []
imprimer (motos [-1])

Aucun élément n'est dans motocyclettes, donc Python renvoie une autre erreur d'index:

Traceback (dernier appel le plus récent):


Fichier "motorcyles.py", ligne 3, dans <module>
imprimer (motos [-1])
IndexError: index de liste hors limites

Remarque Si une erreur d'index se produit et que vous ne savez pas comment la résoudre, essayez d'imprimer votre liste ou
imprimez simplement la longueur de votre liste. Votre liste peut être très différente de ce que vous pensiez, surtout si
elle a été gérée dynamiquement par votre programme. Voir la liste réelle, ou le nombre exact d'éléments dans votre
liste, peut vous aider à trier ces erreurs logiques.

Présentation des listes 51


essayez-le vous-même

3-11. Erreur intentionnelle: Si vous n'avez pas encore reçu d'erreur d'index dans l'un de vos programmes,

essayez d'en provoquer une. Modifiez un index dans l'un de vos programmes pour produire une erreur d'index.

Assurez-vous de corriger l'erreur avant de fermer le programme.

résumé
Dans ce chapitre, vous avez appris ce que sont les listes et comment travailler avec les éléments individuels d'une
liste. Vous avez appris à définir une liste et à ajouter et supprimer des éléments. Vous avez appris à trier les listes
de manière permanente et temporaire à des fins d'affichage. Vous avez également appris à trouver la longueur
d'une liste et à éviter les erreurs d'index lorsque vous travaillez avec des listes.

Au chapitre 4, vous apprendrez à travailler plus efficacement avec les éléments d'une liste. En parcourant chaque
élément d'une liste en utilisant seulement quelques lignes de code, vous serez en mesure de travailler efficacement,
même lorsque votre liste contient des milliers ou des millions d'éléments.

52 chapitre 3
4
TRAVAILLER AVEC LES I ST S

Au chapitre 3, vous avez appris à créer une liste simple et à


travailler avec les éléments individuels d'une liste. Dans ce chapitre,
vous apprendrez à boucle à travers une liste entière en utilisant
seulement quelques lignes de code, quelle que soit la façon dont

la liste est longue. La boucle vous permet d'effectuer la même action, ou ensemble d'actions, avec chaque élément d'une

liste. En conséquence, vous serez en mesure de travailler efficacement avec des listes de toute longueur, y compris celles

contenant des milliers, voire des millions d'éléments.

en boucle sur une liste entière


Vous voudrez souvent parcourir toutes les entrées d'une liste, en effectuant la même tâche avec chaque
élément. Par exemple, dans un jeu, vous souhaiterez peut-être déplacer chaque élément de l'écran du même
montant, ou dans une liste de nombres, vous souhaiterez peut-être effectuer la même opération statistique sur
chaque élément. Ou peut-être voudrez-vous afficher chaque titre à partir d'une liste d'articles sur un site Web.
Lorsque vous voulez faire la même action avec chaque élément d'une liste, vous pouvez utiliser Python pour boucle.
Disons que nous avons une liste de noms de magiciens et que nous voulons imprimer chaque nom de
la liste. Nous pourrions le faire en récupérant chaque nom de la liste individuellement, mais cette approche
pourrait poser plusieurs problèmes. Pour un,
il serait répétitif de le faire avec une longue liste de noms. De plus, nous devions changer notre code à
chaque fois que la longueur de la liste changeait. UNE pour loop évite ces deux problèmes en laissant Python
gérer ces problèmes en interne.
Utilisons un pour boucle pour imprimer chaque nom dans une liste de magiciens:

magicians.py u magiciens = ['alice', 'david', 'carolina']


v pour magicien en magiciens:
w imprimer (magicien)

Nous commençons par définir une liste à u, comme nous l'avons fait au chapitre 3. À v,

nous définissons un pour boucle. Cette ligne indique à Python d'extraire un nom de la liste
magiciens, et stockez-le dans la variable magicien. À w nous disons à Python d'imprimer le nom qui vient
d'être stocké dans magicien. Python répète ensuite les lignes v
et w, une fois pour chaque nom de la liste. Il peut être utile de lire ce code comme suit: «Pour chaque
magicien de la liste des magiciens, écrivez le nom du magicien.» La sortie est une simple impression de
chaque nom dans la liste:

Alice
David
Caroline

Un regard plus attentif sur le bouclage

Le concept de bouclage est important car c'est l'un des moyens les plus courants d'automatisation des tâches
répétitives par un ordinateur. Par exemple, dans une boucle simple comme nous l'avons utilisé dans magicians.py, Python
lit initialement la première ligne de la boucle:

pour magicien en magiciens:

Cette ligne indique à Python de récupérer la première valeur de la liste magiciens


et stockez-le dans la variable magicien. Cette première valeur est ' Alice '. Python lit ensuite la ligne suivante:

imprimer (magicien)

Python imprime la valeur actuelle de magicien, qui est encore ' Alice '. Étant donné que la liste contient plus
de valeurs, Python retourne à la première ligne de la boucle:

pour magicien en magiciens:

Python récupère le nom suivant dans la liste, ' David', et stocke cette valeur dans magicien. Python
exécute ensuite la ligne:

imprimer (magicien)

54 Chapitre 4
Python imprime la valeur actuelle de magicien encore une fois, qui est maintenant ' David'.
Python répète la boucle entière une fois de plus avec la dernière valeur de la liste,
«Caroline». Comme il n'y a plus de valeurs dans la liste, Python passe à la ligne suivante du programme.
Dans ce cas, rien ne vient après le pour boucle, donc le programme se termine simplement.

Lorsque vous utilisez des boucles pour la première fois, gardez à l'esprit que l'ensemble d'étapes est répété
une fois pour chaque élément de la liste, quel que soit le nombre d'éléments dans la liste. Si vous avez un million
d'éléments dans votre liste, Python répète ces étapes un million de fois - et généralement très rapidement.

Gardez également à l'esprit lorsque vous écrivez le vôtre pour boucles que vous pouvez choisir le nom de
votre choix pour la variable temporaire contenant chaque valeur de la liste. Cependant, il est utile de choisir un
nom significatif qui représente un seul élément de la liste. Par exemple, voici une bonne façon de démarrer une pour
boucle pour une liste de chats, une liste de chiens et une liste générale d'éléments:

pour chat chez chat: pour


chien chez chien:
pour l'élément dans list_of_items:

Ces conventions de dénomination peuvent vous aider à suivre l'action en cours sur chaque élément
d'un pour boucle. L'utilisation de noms au singulier et au pluriel peut vous aider à identifier si une section de
code fonctionne avec un seul élément de la liste ou la liste entière.

Faire plus de travail dans une boucle for

Vous pouvez faire à peu près n'importe quoi avec chaque élément d'un pour boucle. Continuons sur l'exemple
précédent en imprimant un message à chaque magicien, en leur disant qu'ils ont réalisé une super astuce:

magiciens = ['alice', 'david', 'carolina'] pour magicien en


magiciens:
u print (magician.title () + ", c'était une super astuce!")

La seule différence dans ce code est à u où nous composons un message à chaque magicien, en
commençant par le nom de ce magicien. La première fois dans la boucle, la valeur du magicien est ' Alice
', donc Python commence le premier message avec le nom ' Alice '. La deuxième fois que le message
commencera par
'David', et la troisième fois à travers le message commencera par ' Caroline ».
La sortie affiche un message personnalisé pour chaque magicien de la liste:

Alice, c'était une super astuce! David, c'était une


super astuce! Carolina, c'était une super astuce!

Vous pouvez également écrire autant de lignes de code que vous le souhaitez dans le pour boucle. Chaque
ligne en retrait suivant la ligne pour magicien en magiciens est considéré à l'intérieur de la boucle, et chaque ligne
indentée est exécutée une fois pour chaque

Travailler avec des listes 55


valeur dans la liste. Par conséquent, vous pouvez effectuer autant de travail que vous le souhaitez avec chaque

valeur de la liste.

Ajoutons une deuxième ligne à notre message, disant à chaque magicien que nous attendons avec impatience
leur prochaine astuce:

magiciens = ['alice', 'david', 'carolina'] pour magicien en


magiciens:
print (magician.title () + ", c'était une super astuce!")
u print ("J'ai hâte de voir votre prochain tour," + magician.title () + ". \ n")

Parce que nous avons indenté les deux impression déclarations, chaque ligne sera exécutée une fois pour
chaque magicien de la liste. La nouvelle ligne ("\ n ") dans la seconde
impression déclaration u insère une ligne vierge après chaque passage dans la boucle. Cela crée un ensemble de
messages qui sont soigneusement regroupés pour chaque personne de la liste:

Alice, c'était une super astuce!


J'ai hâte de voir ton prochain tour, Alice.

David, c'était une super astuce!


J'ai hâte de voir ton prochain tour, David.

Carolina, c'était une super astuce!


J'ai hâte de voir ton prochain tour, Carolina.

Vous pouvez utiliser autant de lignes que vous le souhaitez dans votre pour boucles. En pratique, vous trouverez

souvent utile d'effectuer un certain nombre d'opérations différentes avec chaque élément d'une liste lorsque vous utilisez un pour

boucle.

Faire quelque chose après une boucle for

Que se passe-t-il une fois pour boucle a fini de s'exécuter? Habituellement, vous voudrez résumer
un bloc de sortie ou passer à un autre travail que votre programme doit accomplir.

Toutes les lignes de code après le pour Les boucles qui ne sont pas indentées sont exécutées une fois
sans répétition. Écrivons un merci au groupe de magiciens dans son ensemble, en les remerciant d'avoir
organisé un excellent spectacle. Pour afficher ce message de groupe une fois que tous les messages
individuels ont été imprimés, nous plaçons le message de remerciement après le pour boucle sans indentation:

magiciens = ['alice', 'david', 'carolina'] pour magicien en


magiciens:
print (magician.title () + ", c'était une super astuce!")
print ("J'ai hâte de voir votre prochain tour," + magician.title () + ". \ n")

u print ("Merci à tous. C'était un grand spectacle de magie!")

56 Chapitre 4
Les deux premiers impression les déclarations sont répétées une fois pour chaque magicien de la liste, comme vous

l'avez vu précédemment. Cependant, parce que la ligne à u n'est pas en retrait, il est imprimé une seule fois:

Alice, c'était une super astuce!


J'ai hâte de voir ton prochain tour, Alice.

David, c'était une super astuce!


J'ai hâte de voir ton prochain tour, David.

Carolina, c'était une super astuce!


J'ai hâte de voir ton prochain tour, Carolina.

Merci tout le monde. C'était un grand spectacle de magie!

Lorsque vous traitez des données à l'aide d'un pour boucle, vous constaterez que c'est un bon moyen de
résumer une opération qui a été effectuée sur un ensemble de données entier. Par exemple, vous pouvez
utiliser un pour boucle pour initialiser un jeu en parcourant une liste de personnages et en affichant chaque
personnage à l'écran. Vous pouvez ensuite écrire un bloc non indenté après cette boucle qui affiche un
bouton Lire maintenant après que tous les personnages ont été dessinés à l'écran.

éviter les erreurs d'indentation


Python utilise l'indentation pour déterminer quand une ligne de code est connectée à la ligne au-dessus. Dans les
exemples précédents, les lignes qui imprimaient des messages à des magiciens individuels faisaient partie du pour boucle
parce qu'ils étaient en retrait. L'utilisation de l'indentation par Python rend le code très facile à lire.
Fondamentalement, il utilise des espaces pour vous forcer à écrire du code parfaitement formaté avec une structure
visuelle claire. Dans les programmes Python plus longs, vous remarquerez des blocs de code indentés à plusieurs
niveaux différents. Ces niveaux d'indentation vous aident à avoir une idée générale de l'organisation globale du
programme.

Lorsque vous commencez à écrire du code qui repose sur une indentation appropriée, vous devrez
surveiller quelques erreurs d'indentation. Par exemple, les gens mettent parfois en retrait des blocs de code qui
n'ont pas besoin d'être mis en retrait ou oublient d'indenter les blocs qui doivent être mis en retrait. Voir des
exemples de ces erreurs maintenant vous aidera à les éviter à l'avenir et à les corriger lorsqu'elles
apparaissent dans vos propres programmes.

Examinons certaines des erreurs d'indentation les plus courantes.

Oublier de mettre en retrait

Mettez toujours en retrait la ligne après le pour instruction dans une boucle. Si vous oubliez, Python vous rappellera:

magicians.py magiciens = ['alice', 'david', 'carolina'] pour magicien en


magiciens:
u imprimer (magicien)

Travailler avec des listes 57


Le impression déclaration à u devrait être en retrait, mais ce n'est pas le cas. Lorsque Python attend un
bloc indenté et n'en trouve pas, il vous permet de savoir avec quelle ligne il a eu un problème.

Fichier "magicians.py", ligne 3


imprimer (magicien)
^
IndentationError: un bloc indenté attendu

Vous pouvez généralement résoudre ce type d'erreur d'indentation en indentant la ou les lignes
immédiatement après le pour déclaration.

Oublier de mettre en retrait des lignes supplémentaires

Parfois, votre boucle s'exécutera sans aucune erreur mais ne produira pas le résultat attendu. Cela peut se
produire lorsque vous essayez d'effectuer plusieurs tâches en boucle et que vous oubliez d'indenter certaines
de ses lignes.
Par exemple, voici ce qui se passe lorsque nous oublions d'indenter la deuxième ligne de la boucle qui
indique à chaque magicien que nous attendons avec impatience son prochain tour:

magiciens = ['alice', 'david', 'carolina'] pour magicien en


magiciens:
print (magician.title () + ", c'était une super astuce!")
u print ("J'ai hâte de voir votre prochain tour," + magician.title () + ". \ n")

Le impression déclaration à u est censé être indenté, mais parce que Python trouve au moins une
ligne indentée après le pour déclaration, il ne signale pas une erreur. En conséquence, le premier impression
L'instruction est exécutée une fois pour chaque nom de la liste car elle est indentée. La deuxième impression
L'instruction n'est pas indentée, elle n'est donc exécutée qu'une seule fois après la fin de l'exécution de
la boucle. Parce que la valeur finale de magicien est ' carolina ', elle est la seule à recevoir le message «dans
l'attente du prochain tour»:

Alice, c'était une super astuce! David, c'était une


super astuce! Carolina, c'était une super astuce!

J'ai hâte de voir ton prochain tour, Carolina.

C'est un erreur logique. La syntaxe est du code Python valide, mais le code ne produit pas le résultat souhaité
car un problème se produit dans sa logique. Si vous prévoyez de voir une certaine action répétée une fois pour
chaque élément d'une liste et qu'elle n'est exécutée qu'une seule fois, déterminez si vous devez simplement mettre
en retrait une ligne ou un groupe de lignes.

58 Chapitre 4
Mise en retrait inutile
Si vous indentez accidentellement une ligne qui n'a pas besoin d'être indentée, Python vous
informe du retrait inattendu:

bonjour_world.py message = "Bonjour le monde Python!"


u imprimer (message)

Nous n'avons pas besoin d'indenter le impression déclaration à u, parce que ce n'est pas

appartiennent à la ligne au-dessus; par conséquent, Python signale cette erreur:

Fichier "hello_world.py", ligne 2


imprimer (message)
^
IndentationError: retrait inattendu

Vous pouvez éviter les erreurs d'indentation inattendues en indentant uniquement lorsque vous avez une
raison spécifique de le faire. Dans les programmes que vous écrivez à ce stade, les seules lignes à indenter sont
les actions que vous souhaitez répéter pour chaque élément d'un pour boucle.

Mise en retrait inutile après la boucle

Si vous indentez accidentellement du code qui doit s'exécuter après la fin d'une boucle, ce code sera répété
une fois pour chaque élément de la liste. Parfois, cela invite Python à signaler une erreur, mais vous
recevrez souvent une simple erreur logique.
Par exemple, voyons ce qui se passe lorsque nous indentons accidentellement la ligne qui a remercié
les magiciens en tant que groupe pour avoir fait un bon spectacle:

magiciens = ['alice', 'david', 'carolina'] pour magicien en


magiciens:
print (magician.title () + ", c'était une super astuce!")
print ("J'ai hâte de voir votre prochain tour," + magician.title () + ". \ n")

u print ("Merci à tous, c'était un grand spectacle de magie!")

Parce que la ligne à u est en retrait, il est imprimé une fois pour chaque personne de la liste, comme vous pouvez

le voir sur v:

Alice, c'était une super astuce!


J'ai hâte de voir ton prochain tour, Alice.

v Merci à tous, c'était un grand spectacle de magie!


David, c'était une super astuce!
J'ai hâte de voir ton prochain tour, David.

v Merci à tous, c'était un grand spectacle de magie!


Carolina, c'était une super astuce!
J'ai hâte de voir ton prochain tour, Carolina.

v Merci à tous, c'était un grand spectacle de magie!

Travailler avec des listes 59


Il s'agit d'une autre erreur logique, similaire à celle de la section «Oublier de mettre en retrait des lignes
supplémentaires» à la page 58. Étant donné que Python ne sait pas ce que vous essayez d'accomplir avec votre
code, il exécutera tout le code écrit dans une syntaxe valide. . Si une action est répétée plusieurs fois alors qu'elle
ne doit être exécutée qu'une seule fois, déterminez si vous devez simplement annuler l'indentation du code pour
cette action.

Oublier le côlon
Le côlon à la fin d'un pour indique à Python d'interpréter la ligne suivante comme le début d'une
boucle.

magiciens = ['alice', 'david', 'carolina']


u pour magicien en magiciens
imprimer (magicien)

Si vous oubliez accidentellement le côlon, comme indiqué à u, vous obtiendrez une erreur de syntaxe car
Python ne sait pas ce que vous essayez de faire. Bien qu'il s'agisse d'une erreur facile à corriger, ce n'est pas
toujours une erreur facile à trouver. Vous seriez surpris par le temps que les programmeurs passent à traquer les
erreurs d'un seul caractère comme celle-ci. De telles erreurs sont difficiles à trouver car nous ne voyons souvent
que ce que nous nous attendons à voir.

essayez-le vous-même

4-1. Pizzas: Pensez à au moins trois sortes de vos pizzas préférées. Stockez ces noms de pizza dans une liste, puis

utilisez un pour boucle pour imprimer le nom de chaque pizza.

• Modifiez votre pour boucle pour imprimer une phrase en utilisant le nom de la pizza au lieu de n'imprimer que

le nom de la pizza. Pour chaque pizza, vous devriez avoir une ligne de sortie contenant une simple

déclaration comme J'aime la pizza au pepperoni.

• Ajoutez une ligne à la fin de votre programme, en dehors du pour boucle, qui indique à quel point vous aimez

la pizza. Le résultat doit être composé de trois lignes ou plus sur les types de pizza que vous aimez, puis

d'une phrase supplémentaire, telle que

J'adore vraiment la pizza!

4-2. Animaux: Pensez à au moins trois animaux différents qui ont une caractéristique commune. Enregistrez les

noms de ces animaux dans une liste, puis utilisez un pour boucle pour imprimer le nom de chaque animal.

• Modifiez votre programme pour imprimer une déclaration sur chaque animal, telle que

Un chien ferait un excellent animal de compagnie.

• Ajoutez une ligne à la fin de votre programme indiquant ce que ces animaux ont en commun. Vous pouvez imprimer une

phrase telle que N'importe lequel de ces animaux ferait un excellent animal de compagnie!

60 Chapitre 4
faire des listes numériques
De nombreuses raisons existent pour stocker un ensemble de nombres. Par exemple, vous devrez garder une trace des

positions de chaque personnage dans un jeu, et vous voudrez peut-être également garder une trace des meilleurs scores

d'un joueur. Dans les visualisations de données, vous travaillerez presque toujours avec des ensembles de nombres, tels

que des températures, des distances, des tailles de population ou des valeurs de latitude et de longitude, entre autres types

d'ensembles numériques.

Les listes sont idéales pour stocker des ensembles de nombres, et Python fournit un certain nombre d'outils pour
vous aider à travailler efficacement avec des listes de nombres. Une fois que vous aurez compris comment utiliser

efficacement ces outils, votre code fonctionnera bien même lorsque vos listes contiennent des millions d'éléments.

Utilisation de la fonction range ()

Python gamme() La fonction facilite la génération d'une série de nombres. Par exemple, vous pouvez utiliser
le gamme() fonction pour imprimer une série de nombres comme ceci:

nombres.py pour la valeur dans la plage (1,5):


print (valeur)

Bien que ce code semble devoir imprimer les nombres de 1 à 5, il n'imprime pas le
nombre 5:

1
2
3
4

Dans cet exemple, gamme() n'imprime que les nombres de 1 à 4. C'est un autre résultat du
comportement décalé que vous verrez souvent dans les langages de programmation. Le gamme() fait que
Python commence à compter à la première valeur que vous lui donnez, et il s'arrête lorsqu'il atteint la
deuxième valeur que vous fournissez. Comme il s'arrête à cette deuxième valeur, la sortie ne contient
jamais la valeur finale, qui aurait été 5 dans ce cas.

Pour imprimer les nombres de 1 à 5, vous utiliseriez gamme (1,6):

pour la valeur dans la plage (1,6):


print (valeur)

Cette fois, la sortie commence à 1 et se termine à 5:

1
2
3
4
5

Travailler avec des listes 61


Si votre sortie est différente de ce que vous attendez lorsque vous utilisez
gamme(), essayez d'ajuster votre valeur finale de 1.

Utilisation de range () pour créer une liste de nombres

Si vous souhaitez faire une liste de nombres, vous pouvez convertir les résultats de gamme()
directement dans une liste à l'aide du liste() fonction. Lorsque vous enveloppez liste() autour d'un appel au gamme()
fonction, la sortie sera une liste de nombres.
Dans l'exemple de la section précédente, nous avons simplement imprimé une série de nombres. On peut
utiliser liste() pour convertir ce même ensemble de nombres en une liste:

nombres = liste (intervalle (1,6))


imprimer (nombres)

Et voici le résultat:

[1, 2, 3, 4, 5]

Nous pouvons également utiliser le gamme() pour dire à Python de sauter les nombres dans une plage
donnée. Par exemple, voici comment nous listerons les nombres pairs entre 1 et 10:

even_numbers.py even_numbers = liste (intervalle (2,11,2))


imprimer (numéros_paires)

Dans cet exemple, le gamme() La fonction commence par la valeur 2, puis ajoute 2 à cette valeur. Il
ajoute 2 à plusieurs reprises jusqu'à ce qu'il atteigne ou dépasse la valeur finale, 11, et produit ce résultat:

[2, 4, 6, 8, 10]

Vous pouvez créer presque tous les ensembles de nombres que vous souhaitez en utilisant le gamme()

fonction. Par exemple, considérez comment vous pouvez créer une liste des 10 premiers nombres
carrés (c'est-à-dire le carré de chaque entier de 1 à 10). En Python, deux astérisques (**) représentent
des exposants. Voici comment mettre les 10 premiers nombres carrés dans une liste:

squares.py u carrés = []
v pour la valeur dans la plage (1,11):
w carré = valeur ** 2
X squares.append (carré)

y imprimer (carrés)

Nous commençons avec une liste vide appelée carrés à u. À v, nous disons à Python de parcourir chaque
valeur de 1 à 10 en utilisant le gamme() fonction. À l'intérieur de la boucle, la valeur actuelle est élevée à la
deuxième puissance et stockée dans le

62 Chapitre 4
variable carré à w. À X, chaque nouvelle valeur de carré est ajouté à la liste
carrés. Enfin, lorsque la boucle est terminée, la liste des carrés est imprimée à y:

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Pour écrire ce code de manière plus concise, omettez la variable temporaire carré
et ajoutez chaque nouvelle valeur directement à la liste:

carrés = []
pour la valeur dans la plage (1,11):
u squares.append (valeur ** 2)

imprimer (carrés)

Le code à u fait le même travail que les lignes à w et X dans squares.py.


Chaque valeur de la boucle est élevée à la deuxième puissance, puis immédiatement ajoutée à la
liste des carrés.
Vous pouvez utiliser l'une de ces deux approches lorsque vous créez des listes plus complexes. Parfois,
l'utilisation d'une variable temporaire rend votre code plus facile à lire; d'autres fois, cela rend le code inutilement
long. Concentrez-vous d'abord sur l'écriture de code que vous comprenez clairement, qui fait ce que vous
voulez qu'il fasse. Recherchez ensuite des approches plus efficaces lorsque vous révisez votre code.

Statistiques simples avec une liste de nombres

Quelques fonctions Python sont spécifiques aux listes de nombres. Par exemple, vous pouvez facilement
trouver le minimum, le maximum et la somme d'une liste de nombres:

>>> chiffres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]


>>> min (chiffres)
0
>>> max (chiffres)
9
>>> somme (chiffres)

45

Remarque Les exemples de cette section utilisent de courtes listes de nombres afin de s'adapter facilement à la page. Ils
fonctionneraient tout aussi bien si votre liste contenait un million de chiffres ou plus.

Compréhensions de la liste

L'approche décrite précédemment pour générer la liste carrés consistait à utiliser trois ou quatre lignes de
code. UNE compréhension de liste vous permet de générer cette même liste en une seule ligne de code.
Une compréhension de liste combine les
pour boucle et la création de nouveaux éléments en une seule ligne, et ajoute automatiquement chaque
nouvel élément. Les compréhensions de listes ne sont pas toujours présentées aux débutants, mais je les
ai incluses ici car vous les verrez probablement dès que vous commencerez à regarder le code des
autres.

Travailler avec des listes 63


L'exemple suivant crée la même liste de nombres carrés que vous avez vue précédemment, mais utilise une
compréhension de liste:

squares.py carrés = [valeur ** 2 pour la valeur de la plage (1,11)] impression


(carrés)

Pour utiliser cette syntaxe, commencez par un nom descriptif pour la liste, tel que
carrés. Ensuite, ouvrez un ensemble de crochets et définissez l'expression des valeurs que vous
souhaitez stocker dans la nouvelle liste. Dans cet exemple, l'expression est valeur ** 2, ce qui élève la
valeur à la deuxième puissance. Ensuite, écrivez un pour boucle pour générer les nombres que vous
souhaitez insérer dans l'expression et fermez les crochets. Le pour boucle dans cet exemple est pour la
valeur dans la plage (1,11), qui alimente les valeurs 1 à 10 dans l'expression

valeur ** 2. Notez qu'aucun deux-points n'est utilisé à la fin de la pour déclaration.


Le résultat est la même liste de nombres carrés que vous avez vue précédemment:

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Il faut de la pratique pour rédiger vos propres compréhensions de listes, mais vous les trouverez utiles une
fois que vous serez à l'aise pour créer des listes ordinaires. Lorsque vous écrivez trois ou quatre lignes de code
pour générer des listes et que cela commence à vous sembler répétitif, pensez à rédiger vos propres
compréhensions de liste.

essayez-le vous-même

4-3. Compter jusqu'à vingt: Utiliser un pour boucle pour imprimer les nombres de 1 à 20 inclus.

4-4. Un million: Faites une liste des nombres de un à un million, puis utilisez un pour boucle pour imprimer
les nombres. (Si la sortie prend trop de temps, arrêtez-la en appuyant sur ctrl- C ou en fermant la fenêtre de
sortie.)

4-5. Somme d'un million: Faites une liste des nombres de un à un million, puis utilisez min () et max () pour vous

assurer que votre liste commence réellement à un et se termine à un million. Utilisez également le somme() fonction

pour voir à quelle vitesse Python peut ajouter un million de nombres.

4-6. Nombres impairs: Utilisez le troisième argument du gamme() fonction pour faire une liste des nombres impairs de 1

à 20. Utiliser un pour boucle pour imprimer chaque numéro.

4-7. Trois: Faites une liste des multiples de 3 de 3 à 30. Utiliser un pour boucle pour imprimer les nombres de

votre liste.

4-8. Cubes: Un nombre élevé à la troisième puissance est appelé un cube . Par exemple, le cube de 2 s'écrit
2 ** 3 en Python. Faites une liste des 10 premiers cubes (c'est-à-dire le cube de chaque entier de 1 à 10) et
utilisez un pour boucle pour imprimer la valeur de chaque cube.

4-9. Compréhension du cube: Utilisez une compréhension de liste pour générer une liste des 10 premiers cubes.

64 Chapitre 4
travailler avec une partie d'une liste

Au chapitre 3, vous avez appris à accéder à des éléments uniques dans une liste, et dans ce chapitre, vous avez
appris à travailler sur tous les éléments d'une liste. Vous pouvez également travailler avec un groupe spécifique
d'éléments dans une liste, que Python appelle un tranche.

Trancher une liste

Pour créer une tranche, vous spécifiez l'index des premier et dernier éléments avec lesquels vous
souhaitez travailler. Comme avec le gamme() fonction, Python arrête un élément avant le deuxième index
que vous spécifiez. Pour afficher les trois premiers éléments d'une liste, vous demanderiez des indices 0 par
3, qui renverrait des éléments 0, 1, et 2.

L'exemple suivant implique une liste de joueurs d'une équipe:

joueurs.py joueurs = ['charles', 'martina', 'michael', 'florence', 'eli']


u imprimer (joueurs [0: 3])

Le code à u imprime une tranche de cette liste, qui ne comprend que les trois premiers
joueurs. La sortie conserve la structure de la liste et inclut les trois premiers joueurs de la liste:

['charles', 'martina', 'michael']

Vous pouvez générer n'importe quel sous-ensemble d'une liste. Par exemple, si vous voulez les deuxième, troisième

et quatrième éléments dans une liste, vous commenceriez la tranche à l'index 1 et se termine à l'index 4:

joueurs = ['charles', 'martina', 'michael', 'florence', 'eli']


imprimer (joueurs [1: 4])

Cette fois, la tranche commence par ' martina ' et se termine par ' Florence':

['martina', 'michael', 'florence']

Si vous omettez le premier index d'une tranche, Python démarre automatiquement votre tranche au
début de la liste:

joueurs = ['charles', 'martina', 'michael', 'florence', 'eli']


imprimer (joueurs [: 4])

Sans index de départ, Python commence au début de la liste:

['charles', 'martina', 'michael', 'florence']

Travailler avec des listes 65


Une syntaxe similaire fonctionne si vous voulez une tranche qui inclut la fin d'une liste. Par exemple, si vous
voulez que tous les éléments du troisième élément au dernier élément, vous pouvez commencer par index 2 et
omettez le deuxième index:

joueurs = ['charles', 'martina', 'michael', 'florence', 'eli']


imprimer (joueurs [2:])

Python renvoie tous les éléments du troisième élément jusqu'à la fin de la liste:

['michael', 'florence', 'eli']

Cette syntaxe vous permet de sortir tous les éléments de n'importe quel point de votre liste jusqu'à la fin,
quelle que soit la longueur de la liste. Rappelons qu'un index négatif renvoie un élément à une certaine
distance de la fin d'une liste; par conséquent, vous pouvez générer n'importe quelle tranche à partir de la fin
d'une liste. Par exemple, si nous voulons afficher les trois derniers joueurs de la liste, nous pouvons utiliser la
tranche
joueurs [-3:]:

joueurs = ['charles', 'martina', 'michael', 'florence', 'eli']


imprimer (joueurs [-3:])

Cela imprime les noms des trois derniers joueurs et continuerait à fonctionner à mesure que la liste
des joueurs change de taille.

Boucle à travers une tranche

Vous pouvez utiliser une tranche dans un pour boucle si vous souhaitez parcourir un sous-ensemble d'éléments dans
une liste. Dans l'exemple suivant, nous parcourons les trois premiers joueurs et imprimons leurs noms dans le cadre
d'une liste simple:

joueurs = ['charles', 'martina', 'michael', 'florence', 'eli']

print ("Voici les trois premiers joueurs de mon équipe:")


u pour le joueur dans les joueurs [: 3]:
imprimer (player.title ())

Au lieu de parcourir la liste complète des joueurs sur u, Python ne parcourt que les trois
premiers noms:

Voici les trois premiers joueurs de mon équipe: Charles

Martina
Michael

Les tranches sont très utiles dans un certain nombre de situations. Par exemple, lorsque vous créez un jeu, vous
pouvez ajouter le score final d'un joueur à une liste chaque fois que ce joueur finit de jouer. Vous pouvez ensuite obtenir
les trois meilleurs scores d'un joueur en triant la liste par ordre décroissant et en prenant une tranche qui ne comprend
que les trois premiers scores. Lorsque vous travaillez avec des données, vous pouvez utiliser des tranches pour traiter

66 Chapitre 4
vos données par blocs d'une taille spécifique. Ou, lorsque vous créez une application Web, vous pouvez utiliser
des tranches pour afficher des informations dans une série de pages avec une quantité appropriée d'informations
sur chaque page.

Copier une liste

Souvent, vous voudrez commencer avec une liste existante et créer une liste entièrement nouvelle basée sur la
première. Explorons le fonctionnement de la copie d'une liste et examinons une situation dans laquelle la copie d'une
liste est utile.
Pour copier une liste, vous pouvez créer une tranche qui inclut la liste d'origine entière en omettant le
premier index et le deuxième index ([:]). Cela indique à Python de créer une tranche qui commence au premier
élément et se termine par le dernier élément, produisant une copie de la liste entière.

Par exemple, imaginons que nous ayons une liste de nos aliments préférés et que nous voulions faire une liste
distincte d'aliments qu'un ami aime. Cet ami aime tout ce qui se trouve dans notre liste jusqu'à présent, nous pouvons donc
créer sa liste en copiant la nôtre:

foods.py u my_foods = ['pizza', 'falafel', 'gâteau aux carottes']


v friend_foods = mes_aliments [:]

print ("Mes aliments préférés sont:") print


(my_foods)

print ("\ nLes plats préférés de mon ami sont:") print


(friend_foods)

À u nous faisons une liste des aliments que nous aimons appelés mes_aliments. À v nous faisons une nouvelle
liste appelée friend_foods. Nous faisons une copie de mes_aliments en demandant une part de mes_aliments sans spécifier
d'index et stocker la copie dans friend_foods.
Lorsque nous imprimons chaque liste, nous voyons qu'elles contiennent toutes les deux les mêmes aliments:

Mes plats préférés sont:


['pizza', 'falafel', 'gâteau aux carottes']

Les plats préférés de mon ami sont: [«pizza»,


«falafel», «gâteau aux carottes»]

Pour prouver que nous avons en fait deux listes distinctes, nous ajouterons un nouvel aliment à chaque liste et
montrerons que chaque liste garde une trace des aliments préférés de la personne appropriée:

my_foods = ['pizza', 'falafel', 'gâteau aux carottes']


u friend_foods = mes_aliments [:]

v my_foods.append ('cannoli')
w friend_foods.append ('glace')

print ("Mes aliments préférés sont:") print


(my_foods)

Travailler avec des listes 67


print ("\ nLes plats préférés de mon ami sont:") print
(friend_foods)

À u nous copions les éléments originaux dans mes_aliments à la nouvelle liste friend_foods, comme nous l'avons fait dans

l'exemple précédent. Ensuite, nous ajoutons un nouvel aliment à chaque liste: à v nous

ajouter ' cannoli ' à mes_aliments, et à w nous ajoutons ' la crème glacée' à friend_foods. Nous avons ensuite

imprimez les deux listes pour voir si chacun de ces aliments est dans la liste appropriée.

Mes plats préférés sont:


X [' pizza »,« falafel »,« gâteau aux carottes »,« cannoli »]

Les plats préférés de mon ami sont:


y [' pizza »,« falafel »,« gâteau aux carottes »,« crème glacée »]

La sortie à X montre que ' cannoli ' apparaît maintenant dans notre liste d'aliments préférés mais ' la crème
glacée' pas. À y on peut voir ça ' la crème glacée' apparaît maintenant dans la liste de nos amis mais ' cannoli ' pas. Si
nous avions simplement mis friend_foods
égal à mes_aliments, nous ne produirions pas deux listes distinctes. Par exemple, voici ce qui se passe
lorsque vous essayez de copier une liste sans utiliser de tranche:

my_foods = ['pizza', 'falafel', 'gâteau aux carottes']

# Cela ne fonctionne pas:


u friend_foods = mes_aliments

my_foods.append ('cannoli')
friend_foods.append ('glace')

print ("Mes aliments préférés sont:") print


(my_foods)

print ("\ nLes plats préférés de mon ami sont:") print


(friend_foods)

Au lieu de stocker une copie de mes_aliments dans friend_foods à u, nous fixons


friend_foods égal à mes_aliments. Cette syntaxe indique en fait à Python de connecter la
nouvelle variable friend_foods à la liste déjà contenue dans
mes_aliments, alors maintenant les deux variables pointent vers la même liste. En conséquence, lorsque nous ajoutons ' cannoli
' à mes_aliments, il apparaîtra également dans friend_foods. De même ' la crème glacée' apparaîtra dans les deux listes, même
s'il semble être ajouté uniquement à
friend_foods.
La sortie montre que les deux listes sont les mêmes maintenant, ce qui n'est pas ce que nous voulions:

Mes plats préférés sont:


['pizza', 'falafel', 'gâteau aux carottes', 'cannoli', 'glace']

Les plats préférés de mon ami sont:


['pizza', 'falafel', 'gâteau aux carottes', 'cannoli', 'glace']

68 Chapitre 4
Remarque Ne vous inquiétez pas des détails de cet exemple pour le moment. Fondamentalement, si vous essayez de travailler avec
une copie d'une liste et que vous voyez un comportement inattendu, assurez-vous de copier la liste en utilisant une tranche,
comme nous l'avons fait dans le premier exemple.

essayez-le vous-même

4-10. Tranches: En utilisant l'un des programmes que vous avez écrits dans ce chapitre, ajoutez plusieurs lignes à

la fin du programme qui font ce qui suit:

• Imprimez le message, Les trois premiers éléments de la liste sont:. Utilisez ensuite une tranche pour imprimer les trois

premiers éléments de la liste de ce programme.

• Imprimez le message, Trois éléments du milieu de la liste sont:. Utilisez une tranche pour imprimer trois

éléments à partir du milieu de la liste.

• Imprimez le message, Les trois derniers éléments de la liste sont:. Utilisez une tranche pour imprimer les trois derniers

éléments de la liste.

4-11. Mes Pizzas, Vos Pizzas: Commencez par votre programme à partir de l'exercice 4-1 (page 60).

Faites une copie de la liste des pizzas et appelez-la friend_pizzas.

Ensuite, procédez comme suit:

• Ajoutez une nouvelle pizza à la liste d'origine.

• Ajouter une autre pizza à la liste friend_pizzas.

• Prouvez que vous avez deux listes distinctes. Imprimez le message, Mes pizzas préférées sont :, puis utilisez un pour boucle

pour imprimer la première liste. Imprimez le message,

Les pizzas préférées de mon ami sont :, puis utilisez un pour boucle pour imprimer la deuxième liste. Assurez-vous

que chaque nouvelle pizza est stockée dans la liste appropriée.

4-12. Plus de boucles: Toutes les versions de foods.py dans cette section ont évité d'utiliser

pour boucles lors de l'impression pour économiser de l'espace. Choisissez une version de foods.py, et écris deux pour boucles

pour imprimer chaque liste d'aliments.

tuples
Les listes fonctionnent bien pour stocker des ensembles d'éléments qui peuvent changer tout au long de

vie d'un programme. La possibilité de modifier des listes est particulièrement importante lorsque vous travaillez avec une

liste d'utilisateurs sur un site Web ou une liste de personnages dans un jeu. Cependant, vous souhaiterez parfois créer une
liste d'éléments qui ne peuvent pas changer. Les tuples vous permettent de faire exactement cela. Python fait référence à

des valeurs qui ne peuvent pas changer en tant que immuable, et une liste immuable est appelée un tuple.

Définition d'un tuple

Un tuple ressemble à une liste sauf que vous utilisez des parenthèses au lieu de crochets. Une fois que vous avez
défini un tuple, vous pouvez accéder à des éléments individuels en utilisant l'index de chaque élément, comme vous
le feriez pour une liste.

Travailler avec des listes 69


Par exemple, si nous avons un rectangle qui doit toujours avoir une certaine taille, nous pouvons nous
assurer que sa taille ne change pas en mettant les dimensions dans un tuple:

dimensions.py u dimensions = (200, 50)


v impression (dimensions [0])
impression (dimensions [1])

Nous définissons le tuple dimensions à u, en utilisant des parenthèses au lieu de crochets. À v nous imprimons
chaque élément du tuple individuellement, en utilisant la même syntaxe que nous utilisons pour accéder aux
éléments d'une liste:

200
50

Voyons ce qui se passe si nous essayons de changer l'un des éléments du tuple
dimensions:

dimensions = (200, 50)


u dimensions [0] = 250

Le code à u essaie de changer la valeur de la première dimension, mais Python renvoie une erreur de type.

Fondamentalement, parce que nous essayons de modifier un tuple, ce qui ne peut pas être fait pour ce type d'objet, Python

nous dit que nous ne pouvons pas attribuer une nouvelle valeur à un élément dans un tuple:

Traceback (dernier appel le plus récent):


Fichier "dimensions.py", ligne 3, dans <module>
dimensions [0] = 250
TypeError: l'objet 'tuple' ne prend pas en charge l'affectation d'élément

Ceci est avantageux car nous voulons que Python lève une erreur lorsqu'une ligne de code tente
de changer les dimensions du rectangle.

Bouclage de toutes les valeurs dans un tuple

Vous pouvez boucler sur toutes les valeurs d'un tuple en utilisant un pour boucle, comme vous l'avez fait avec une liste:

dimensions = (200, 50)


pour la dimension en dimensions:
impression (dimension)

Python renvoie tous les éléments du tuple, comme il le ferait pour une liste:

200
50

70 Chapitre 4
Écriture sur un tuple

Bien que vous ne puissiez pas modifier un tuple, vous pouvez attribuer une nouvelle valeur à une variable qui contient
un tuple. Donc, si nous voulions changer nos dimensions, nous pourrions redéfinir le tuple entier:

u dimensions = (200, 50)


print ("Dimensions d'origine:")
pour la dimension en dimensions:
impression (dimension)

v dimensions = (400, 100)


w print ("\ nDimensions modifiées:")
pour la dimension en dimensions:
impression (dimension)

Le bloc à u définit le tuple d'origine et imprime les dimensions initiales. À v, nous stockons un
nouveau tuple dans la variable dimensions. Nous imprimons ensuite les nouvelles dimensions à w. Python
ne génère aucune erreur cette fois, car l'écrasement d'une variable est valide:

Dimensions d'origine:
200
50

Dimensions modifiées:
400
100

Par rapport aux listes, les tuples sont des structures de données simples. Utilisez-les lorsque vous souhaitez
stocker un ensemble de valeurs qui ne doivent pas être modifiées tout au long de la vie d'un programme.

essayez-le vous-même

4-13. Buffet: Un restaurant de style buffet ne propose que cinq plats de base. Pensez à cinq aliments simples et

conservez-les dans un tuple.

• Utiliser un pour boucle pour imprimer chaque nourriture proposée par le restaurant.

• Essayez de modifier l'un des éléments et assurez-vous que Python rejette la modification.

• Le restaurant modifie son menu, remplaçant deux des plats par des aliments différents. Ajoutez
un bloc de code qui réécrit le tuple, puis utilisez un pour
boucle pour imprimer chacun des éléments du menu révisé.

Travailler avec des listes 71


styliser votre code
Maintenant que vous écrivez des programmes plus longs, des idées sur la façon de styliser votre code valent la
peine d'être connues. Prenez le temps de rendre votre code aussi simple que possible à lire. L'écriture de code
facile à lire vous aide à suivre ce que font vos programmes et aide également les autres à comprendre votre
code.
Les programmeurs Python se sont mis d'accord sur un certain nombre de conventions de style pour
s'assurer que le code de chacun est structuré à peu près de la même manière. Une fois que vous avez appris à
écrire du code Python propre, vous devriez être en mesure de comprendre la structure globale du code Python de
n'importe qui d'autre, à condition qu'ils suivent les mêmes directives. Si vous espérez devenir programmeur
professionnel à un moment donné, vous devriez commencer à suivre ces directives dès que possible pour
développer de bonnes habitudes.

Le guide de style

Quand quelqu'un veut apporter un changement au langage Python, il écrit un Proposition d'amélioration de
Python (PEP). L'un des PEP les plus anciens est PEP 8, qui indique aux programmeurs Python comment
styliser leur code. PEP 8 est assez long, mais il est en grande partie lié à des structures de codage plus
complexes que ce que vous avez vu jusqu'à présent.

Le guide de style Python a été écrit en sachant que le code est lu plus souvent qu'il n'est écrit. Vous
allez écrire votre code une fois, puis commencer à le lire lorsque vous commencez le débogage. Lorsque
vous ajoutez des fonctionnalités à un programme, vous passerez plus de temps à lire votre code. Lorsque
vous partagez votre code avec d'autres programmeurs, ils liront également votre code.

Étant donné le choix entre écrire du code plus facile à écrire ou du code plus facile à lire, les
programmeurs Python vous encourageront presque toujours à écrire du code plus facile à lire. Les
instructions suivantes vous aideront à écrire du code clair dès le début.

Échancrure

PEP 8 vous recommande d'utiliser quatre espaces par niveau d'indentation. L'utilisation de quatre espaces
améliore la lisibilité tout en laissant de la place pour plusieurs niveaux d'indentation sur chaque ligne.

Dans un document de traitement de texte, les gens utilisent souvent des tabulations plutôt que des espaces pour

mettre en retrait. Cela fonctionne bien pour les documents de traitement de texte, mais l'interpréteur Python est confus

lorsque les tabulations sont mélangées avec des espaces. Chaque éditeur de texte fournit un paramètre qui vous permet

d'utiliser le languette mais convertit ensuite chaque onglet en un nombre défini d'espaces. Vous devez absolument utiliser votre languette

mais assurez-vous également que votre éditeur est configuré pour insérer des espaces plutôt que des tabulations dans

votre document.

Le mélange des onglets et des espaces dans votre fichier peut entraîner des problèmes très difficiles à

diagnostiquer. Si vous pensez avoir un mélange d'onglets et d'espaces, vous pouvez convertir tous les onglets d'un

fichier en espaces dans la plupart des éditeurs.

72 Chapitre 4
Longueur de la ligne

De nombreux programmeurs Python recommandent que chaque ligne contienne moins de 80 caractères.
Historiquement, cette directive s'est développée parce que la plupart des ordinateurs ne pouvaient contenir que 79
caractères sur une seule ligne dans une fenêtre de terminal. Actuellement, les utilisateurs peuvent insérer des lignes
beaucoup plus longues sur leurs écrans, mais il existe d'autres raisons de respecter la longueur de ligne standard de
79 caractères. Les programmeurs professionnels ont souvent plusieurs fichiers ouverts sur le même écran, et
l'utilisation de la longueur de ligne standard leur permet de voir des lignes entières dans deux ou trois fichiers qui sont
ouverts côte à côte à l'écran. PEP 8 vous recommande également de limiter tous vos commentaires à 72 caractères
par ligne, car certains des outils qui génèrent une documentation automatique pour les projets plus importants ajoutent
des caractères de mise en forme au début de chaque ligne commentée.

Les directives PEP 8 pour la longueur des lignes ne sont pas figées et certaines équipes préfèrent une limite de
99 caractères. Ne vous inquiétez pas trop de la longueur des lignes dans votre code pendant que vous apprenez,
mais sachez que les personnes qui travaillent en collaboration suivent presque toujours les directives PEP 8. La
plupart des éditeurs vous permettent de configurer un repère visuel, généralement une ligne verticale sur votre écran,
qui vous montre où se trouvent ces limites.

Remarque L'annexe B vous montre comment configurer votre éditeur de texte pour qu'il insère toujours quatre espaces à
chaque fois que vous appuyez sur la touche languette et affiche une ligne de guidage verticale pour vous aider à
respecter la limite de 79 caractères.

Lignes vierges

Pour regrouper visuellement des parties de votre programme, utilisez des lignes vides. Vous devez utiliser des
lignes vides pour organiser vos fichiers, mais ne le faites pas de manière excessive. En suivant les exemples
fournis dans ce livre, vous devez trouver le bon équilibre. Par exemple, si vous avez cinq lignes de code qui
créent une liste, puis trois autres lignes qui font quelque chose avec cette liste, il est approprié de placer une
ligne vide entre les deux sections. Cependant, vous ne devez pas placer trois ou quatre lignes vides entre les
deux sections.

Les lignes vides n'affecteront pas la façon dont votre code s'exécute, mais elles affecteront la lisibilité
de votre code. L'interpréteur Python utilise l'indentation horizontale pour interpréter la signification de votre
code, mais il ne tient pas compte de l'espacement vertical.

Autres directives de style

PEP 8 a de nombreuses recommandations de style supplémentaires, mais la plupart des directives font référence à des

programmes plus complexes que ce que vous écrivez à ce stade. Au fur et à mesure que vous apprendrez des structures

Python plus complexes, je partagerai les parties pertinentes des directives PEP 8.

Travailler avec des listes 73


essayez-le vous-même

4-14. PEP 8: Regardez à travers le guide de style PEP 8 original à https://python.org/ dev / peps / pep-0008 /. Vous

n'en utiliserez pas beaucoup maintenant, mais il pourrait être intéressant de le parcourir.

4-15. Révision du code: Choisissez trois des programmes que vous avez écrits dans ce chapitre et modifiez chacun d'eux

pour se conformer à PEP 8:

• Utilisez quatre espaces pour chaque niveau d'indentation. Configurez votre éditeur de texte pour qu'il insère quatre

espaces à chaque fois que vous appuyez sur languette, si vous ne l'avez pas déjà fait (voir l'annexe B pour savoir

comment procéder).

• Utilisez moins de 80 caractères sur chaque ligne et configurez votre éditeur pour afficher une ligne de guidage

verticale à la position du 80e caractère.

• N'utilisez pas trop de lignes vides dans vos fichiers programme.

résumé
Dans ce chapitre, vous avez appris à travailler efficacement avec les éléments d'une liste. Vous avez appris à travailler
sur une liste à l'aide d'un pour boucle, comment Python utilise l'indentation pour structurer un programme et comment
éviter certaines erreurs d'indentation courantes. Vous avez appris à créer de simples listes numériques, ainsi que
quelques opérations que vous pouvez effectuer sur des listes numériques. Vous avez appris à découper une liste pour
travailler avec un sous-ensemble d'éléments et à copier correctement des listes à l'aide d'une tranche. Vous avez
également découvert les tuples, qui offrent un degré de protection à un ensemble de valeurs qui ne devraient pas
changer, et comment styliser votre code de plus en plus complexe pour le rendre facile à lire.

Dans le chapitre 5, vous apprendrez à répondre de manière appropriée à différentes conditions en utilisant
si déclarations. Vous apprendrez à enchaîner des ensembles relativement complexes de tests conditionnels pour
répondre de manière appropriée au type de situation ou d'information que vous recherchez. Vous apprendrez
également à utiliser si
instructions tout en parcourant une liste pour effectuer des actions spécifiques avec des éléments sélectionnés dans une
liste.

74 Chapitre 4
5
Je f déclaration s

La programmation implique souvent d'examiner un ensemble


de conditions et de décider des mesures à prendre en fonction de ces
conditions. Python si instruction vous permet d'examiner l'état actuel
d'un programme et de répondre de manière appropriée à cet état.

Dans ce chapitre, vous apprendrez à écrire des tests conditionnels, qui vous permettent de vérifier n'importe
quelle condition d'intérêt. Vous apprendrez à écrire simplement si instructions, et vous apprendrez à créer une série
plus complexe de si instructions pour identifier quand les conditions exactes souhaitées sont présentes. Vous
appliquerez ensuite ce concept aux listes afin de pouvoir rédiger un pour boucle qui gère la plupart des éléments
d'une liste dans un sens mais gère certains éléments avec des valeurs spécifiques d'une manière différente.
un exemple simple
Le court exemple suivant montre comment si les tests vous permettent de répondre correctement à des situations
spéciales. Imaginez que vous avez une liste de voitures et que vous souhaitez imprimer le nom de chaque voiture. Les
noms de voitures sont des noms propres, donc les noms de la plupart des voitures doivent être imprimés dans la casse
du titre. Cependant, la valeur ' BMW' doit être imprimé en majuscules. Le code suivant parcourt une liste de noms de
voitures et recherche la valeur ' BMW'. Chaque fois que la valeur est ' BMW', il est imprimé en majuscules au lieu de la casse
du titre:

cars.py voitures = ['audi', 'bmw', 'subaru', 'toyota']

pour voiture dans les voitures:

u si voiture == 'bmw':
imprimer (car.upper ())
autre:
imprimer (car.title ())

La boucle de cet exemple vérifie d'abord si la valeur actuelle de auto est ' BMW' u.
Si tel est le cas, la valeur est imprimée en majuscules. Si la valeur de auto est autre chose que ' BMW', il est imprimé
dans la casse du titre:

Audi
BMW

Subaru
Toyota

Cet exemple combine un certain nombre de concepts que vous découvrirez dans ce chapitre.
Commençons par examiner les types de tests que vous pouvez utiliser pour examiner les conditions de
votre programme.

Tests conditionnels

Au cœur de chaque si instruction est une expression qui peut être évaluée comme
s'appelle un test conditionnel. Python utilise les valeurs Vrai et
Vrai ou Faux et

Faux pour décider si le code d'un si l'instruction doit être exécutée. Si un test conditionnel
évalue Vrai, Python exécute le code suivant le si
déclaration. Si le test évalue Faux, Python ignore le code suivant si déclaration.

Vérifier l'égalité
La plupart des tests conditionnels comparent la valeur actuelle d'une variable à une valeur d'intérêt
spécifique. Le test conditionnel le plus simple vérifie si la valeur d'une variable est égale à la valeur
d'intérêt:

u >>> voiture = 'bmw'


v >>> voiture == 'bmw'
Vrai

76 Chapitre 5
La ligne à u définit la valeur de auto à ' BMW' en utilisant un seul signe égal, comme vous l'avez déjà
vu à plusieurs reprises. La ligne à v vérifie si la valeur de auto est ' BMW' en utilisant un double signe égal
(==). Ce opérateur d'égalité Retour
Vrai si les valeurs à gauche et à droite de l'opérateur correspondent, et
Faux s'ils ne correspondent pas. Les valeurs de cet exemple correspondent, donc Python renvoie Vrai.

Lorsque la valeur de auto est autre chose que ' BMW', ce test renvoie
Faux:

u >>> voiture = 'audi'


v >>> voiture == 'bmw'
Faux

Un seul signe égal est vraiment une déclaration; vous pourriez lire le code à u
comme "Définir la valeur de la voiture égale à" audi '. »D'autre part, un double signe égal, comme celui de v, pose une
question: «La valeur de la voiture est-elle égale à ' BMW'? «La plupart des langages de programmation utilisent des
signes égaux de cette manière.

Ignorer la casse lors de la vérification de l'égalité

Le test d'égalité est sensible à la casse en Python. Par exemple, deux valeurs avec des majuscules différentes ne
sont pas considérées comme égales:

>>> voiture = 'Audi'


>>> voiture == 'audi'
Faux

Si le cas est important, ce comportement est avantageux. Mais si la casse n'a pas d'importance et que vous
souhaitez simplement tester la valeur d'une variable, vous pouvez convertir la valeur de la variable en minuscules
avant de faire la comparaison:

>>> voiture = 'Audi'


>>> car.lower () == 'audi'
Vrai

Ce test reviendrait Vrai peu importe la valeur ' Audi ' est formaté car le test est désormais
insensible à la casse. Le plus bas() la fonction ne modifie pas la valeur initialement stockée dans auto,
vous pouvez donc faire ce genre de comparaison sans affecter la variable d'origine:

u >>> voiture = 'Audi'


v >>> car.lower () == 'audi'
Vrai
w >>> auto
«Audi»

À u nous stockons la chaîne en majuscules ' Audi ' dans la variable auto. À v
nous convertissons la valeur de auto en minuscules et comparez la valeur en minuscules

if Déclarations 77
à la chaîne ' audi '. Les deux chaînes correspondent, donc Python retourne Vrai. À w
nous pouvons voir que la valeur stockée dans auto n'a pas été affecté par le test conditionnel.

Les sites Web appliquent certaines règles pour les données que les utilisateurs entrent d'une manière similaire à
celle-ci. Par exemple, un site peut utiliser un test conditionnel comme celui-ci pour s'assurer que chaque utilisateur a un
nom d'utilisateur vraiment unique, et pas seulement une variation sur la capitalisation du nom d'utilisateur d'une autre
personne. Quand quelqu'un soumet un nouveau nom d'utilisateur, ce nouveau nom d'utilisateur est converti en
minuscules et comparé aux versions minuscules de tous les noms d'utilisateur existants. Lors de cette vérification, un
nom d'utilisateur comme ' John' sera rejetée si une variation de ' John'

déja en cours d'utilisation.

Vérification des inégalités

Lorsque vous souhaitez déterminer si deux valeurs ne sont pas égales, vous pouvez combiner un point
d'exclamation et un signe égal (! =). Le point d'exclamation représente ne pas, comme il le fait dans de
nombreux langages de programmation.
Utilisons un autre si instruction pour examiner comment utiliser l'opérateur d'inégalité. Nous allons stocker
une garniture de pizza demandée dans une variable, puis imprimer un message si la personne n'a pas commandé
d'anchois:

toppings.py request_topping = 'champignons'

u si demandé_topping! = 'anchois':
print ("Tenez les anchois!")

La ligne à u compare la valeur de demandé_topping à la valeur


'anchois'. Si
ces deux valeurs ne correspondent pas, Python renvoie Vrai et exécute le code
suivant le si déclaration. Si les deux valeurs correspondent, Python renvoie Faux et n'exécute pas
le code suivant le si déclaration.
Parce que la valeur de demandé_topping n'est pas ' anchois', le impression Etat-
est exécuté:

Tenez les anchois!

La plupart des expressions conditionnelles que vous écrivez testent l'égalité, mais parfois
vous trouverez plus efficace de tester l'inégalité.

Comparaisons numériques

Le test des valeurs numériques est assez simple. Par exemple, le code suivant vérifie si une
personne a 18 ans:

>>> âge = 18
>>> âge == 18
Vrai

78 Chapitre 5
Vous pouvez également tester pour voir si deux nombres ne sont pas égaux. Par exemple, le code suivant
imprime un message si la réponse donnée n'est pas correcte:

la magie_ réponse = 17
number.py
u si réponse! = 42:
print ("Ce n'est pas la bonne réponse. Veuillez réessayer!")

Le test conditionnel à u passe, car la valeur de réponse (17) n'est pas égal à 42. Comme le
test réussit, le bloc de code indenté est exécuté:

Ce n’est pas la bonne réponse. Veuillez réessayer!

Vous pouvez également inclure diverses comparaisons mathématiques dans vos instructions
conditionnelles, telles que inférieure à, inférieure ou égale à, supérieure à et supérieure ou égale à:

>>> âge = 19
>>> âge <21
Vrai
>>> âge <= 21
Vrai
>>> âge> 21
Faux
>>> âge> = 21
Faux

Chaque comparaison mathématique peut être utilisée dans le cadre d'un si déclaration, qui peut vous
aider à détecter les conditions exactes d'intérêt.

Vérification de plusieurs conditions

Vous voudrez peut-être vérifier plusieurs conditions en même temps. Par exemple, il se peut que vous
ayez parfois besoin de deux conditions pour être Vrai pour agir. D'autres fois, vous pourriez être satisfait
d'une seule condition Vrai. Les mots-clés
et et ou peut vous aider dans ces situations.

Utilisation et pour vérifier plusieurs conditions

Pour vérifier si deux conditions sont toutes les deux Vrai simultanément, utilisez le mot-clé et combiner
les deux tests conditionnels; si chaque test réussit, l'expression globale évalue à Vrai. Si l'un des tests
échoue ou si les deux tests échouent, l'expression prend la valeur Faux.

Par exemple, vous pouvez vérifier si deux personnes ont toutes les deux plus de 21 ans à l'aide du test suivant:

u >>> age_0 = 22
>>> age_1 = 18
v >>> age_0> = 21 et age_1> = 21
Faux

if Déclarations 79
w >>> age_1 = 22
>>> age_0> = 21 et age_1> = 21
Vrai

À u nous définissons deux âges, age_0 et age_1. À v nous vérifions si les deux âges ont 21 ans ou plus.
Le test de gauche réussit, mais le test de droite échoue, donc l'expression conditionnelle globale est évaluée
à Faux. À w nous changeons age_1
à 22. La valeur de age_1 est maintenant supérieur à 21, donc les deux tests individuels réussissent, ce qui fait que
l'expression conditionnelle globale est évaluée comme Vrai.
Pour améliorer la lisibilité, vous pouvez utiliser des parenthèses autour des tests individuels, mais elles ne sont
pas obligatoires. Si vous utilisez des parenthèses, votre test ressemblerait à ceci:

(age_0> = 21) et (age_1> = 21)

Utilisation de ou pour vérifier plusieurs conditions

Le mot clé ou vous permet également de vérifier plusieurs conditions, mais il réussit lorsque l'un ou les
deux tests individuels réussissent. Une ou expression échoue uniquement lorsque les deux tests
échouent.
Considérons à nouveau deux âges, mais cette fois, nous ne chercherons qu'une seule personne âgée de plus de 21

ans:

u >>> age_0 = 22
>>> age_1 = 18
v >>> age_0> = 21 ou age_1> = 21
Vrai
w >>> age_0 = 18
>>> age_0> = 21 ou age_1> = 21
Faux

Nous recommençons avec deux variables d'âge à u. Parce que le test pour age_0 à v
réussit, l'expression globale est évaluée à Vrai. Nous abaissons alors age_0 à 18. Dans le test à w, les deux
tests échouent maintenant et l'expression globale évalue à Faux.

Vérifier si une valeur se trouve dans une liste

Parfois, il est important de vérifier si une liste contient une certaine valeur avant d'effectuer une action. Par
exemple, vous souhaiterez peut-être vérifier si un nouveau nom d'utilisateur existe déjà dans une liste de noms
d'utilisateurs actuels avant de terminer l'enregistrement d'une personne sur un site Web. Dans un projet de
mappage, vous souhaiterez peut-être vérifier si un emplacement soumis existe déjà dans une liste
d'emplacements connus.

Pour savoir si une valeur particulière est déjà dans une liste, utilisez le mot-clé dans. Considérons
un code que vous pourriez écrire pour une pizzeria. Nous établirons une liste des garnitures qu'un client
a demandées pour une pizza, puis vérifierons si certaines garnitures sont dans la liste.

80 Chapitre 5
>>> required_toppings = ['champignons', 'oignons', 'ananas']
u >>> ' champignons 'dans les garnitures_demandées
Vrai
v >>> ' pepperoni 'dans les garnitures demandées
Faux

À u et v, le mot-clé dans dit à Python de vérifier l'existence de


'champignons' et ' pepperoni' dansla liste demandés_toppings. Cette technique est
assez puissant car vous pouvez créer une liste de valeurs essentielles, puis vérifier facilement si la
valeur que vous testez correspond à l'une des valeurs de la liste.

Vérifier si une valeur ne figure pas dans une liste

D'autres fois, il est important de savoir si une valeur n'apparaît pas dans une liste. Vous pouvez utiliser le mot-clé ne
pas dans cette situation. Par exemple, considérons une liste d'utilisateurs qui n'ont pas le droit de commenter
dans un forum. Vous pouvez vérifier si un utilisateur a été banni avant d'autoriser cette personne à soumettre un
commentaire:

banni_ banned_users = ['andrew', 'carolina', 'david'] user = 'marie'


users.py

u si l'utilisateur n'est pas dans banned_users:

print (user.title () + ", vous pouvez poster une réponse si vous le souhaitez.")

La ligne à u lit assez clairement. Si la valeur de utilisateur n'est pas dans la liste
banned_users, Retour de Python Vrai et exécute la ligne en retrait.
L'utilisateur ' Marie' n'est pas dans la liste banned_users, elle voit donc un message l'invitant à poster
une réponse:

Marie, vous pouvez poster une réponse si vous le souhaitez.

Expressions booléennes

Au fur et à mesure que vous en apprendrez plus sur la programmation, vous entendrez le terme Expression
booléenne à un moment donné. Une expression booléenne n'est qu'un autre nom pour un test conditionnel. UNE Valeur
booléenne est soit Vrai ou Faux, tout comme la valeur d'une expression conditionnelle après son évaluation.

Les valeurs booléennes sont souvent utilisées pour suivre certaines conditions, par exemple si un jeu est en
cours d'exécution ou si un utilisateur peut modifier certains contenus sur un site Web:

game_active = Vrai
can_edit = Faux

Les valeurs booléennes fournissent un moyen efficace de suivre l'état d'un programme ou d'une condition
particulière qui est importante dans votre programme.

if Déclarations 81
essayez-le vous-même

5-1. Tests conditionnels: Écrivez une série de tests conditionnels. Imprimez une déclaration décrivant chaque

test et votre prédiction pour les résultats de chaque test. Votre code devrait ressembler à ceci:

voiture = 'subaru'
print ("La voiture est-elle == 'subaru'? Je prédis la vérité.") print
(voiture == 'subaru')

print ("\ nEst-ce que voiture == 'audi'? Je prédis faux.") print


(voiture == 'audi')

• Examinez attentivement vos résultats et assurez-vous de comprendre pourquoi chaque ligne est évaluée Vrai ou

Faux .

• Créez au moins 10 tests. Avoir au moins 5 tests évalués à Vrai et 5 autres tests évaluent à Faux .

5-2. Plus de tests conditionnels: Vous n'êtes pas obligé de limiter le nombre de tests que vous créez à 10. Si vous

souhaitez essayer plus de comparaisons, écrivez plus de tests et ajoutez-les à conditional_tests.py. Avoir au

moins un Vrai et une Faux résultat pour chacun des éléments suivants:

• Tests d'égalité et d'inégalité avec des chaînes

• Tests utilisant le plus bas() fonction

• Tests numériques impliquant l'égalité et l'inégalité, supérieur et inférieur à, supérieur ou


égal à et inférieur ou égal à

• Tests utilisant le et mot-clé et le ou mot-clé Teste si un élément

• est dans une liste

• Tester si un élément ne figure pas dans une liste

si déclarations
Lorsque vous comprenez les tests conditionnels, vous pouvez commencer à écrire si déclarations.
Plusieurs types de si des instructions existent, et votre choix à utiliser dépend du nombre de conditions
que vous devez tester. Vous avez vu plusieurs exemples de si dans la discussion sur les tests
conditionnels, mais approfondissons maintenant le sujet.

Instructions if simples

Le type le plus simple de si l'instruction a un test et une action:

si test_conditionnel:
faire quelque chose

82 Chapitre 5
Vous pouvez mettre n'importe quel test conditionnel sur la première ligne et à peu
près n'importe quelle action dans le bloc indenté après le test. Si le test conditionnel
évalue Vrai, Python exécute le code suivant le si déclaration. Si le test évalue Faux, Python
ignore le code suivant si
déclaration.
Disons que nous avons une variable représentant l'âge d'une personne et que nous voulons savoir si
cette personne est assez âgée pour voter. Le code suivant teste si la personne peut voter:

votant.py âge = 19
u si âge> = 18:
v print ("Vous êtes assez vieux pour voter!")

À u Python vérifie si la valeur dans âge est supérieur ou égal à 18. C'est le cas, donc
Python exécute l'indenté impression déclaration à v:

Vous êtes en âge de voter!

L'indentation joue le même rôle dans si déclarations comme il l'a fait dans pour boucles.
Toutes les lignes en retrait après un si sera exécutée si le test réussit, et le bloc entier de lignes
indentées sera ignoré si le test échoue.

Vous pouvez avoir autant de lignes de code que vous le souhaitez dans le bloc suivant si déclaration.
Ajoutons une autre ligne de sortie si la personne est assez âgée pour voter, en demandant si la personne
s'est déjà inscrite pour voter:

âge = 19
si âge> = 18:
print ("Vous êtes assez vieux pour voter!")
print ("Vous êtes-vous déjà inscrit pour voter?")

Le test conditionnel réussit, et les deux impression les instructions sont indentées, donc les deux lignes sont
imprimées:

Vous êtes en âge de voter!


Vous êtes-vous déjà inscrit pour voter?

Si la valeur de âge est inférieur à 18, ce programme ne produirait aucune sortie.

Instructions if-else

Souvent, vous souhaiterez effectuer une action lorsqu'un test conditionnel réussit et une action différente dans
tous les autres cas. Python sinon la syntaxe rend cela possible. Une sinon bloc est similaire à un simple si déclaration,
mais le autre L'instruction vous permet de définir une action ou un ensemble d'actions qui sont exécutées
lorsque le test conditionnel échoue.

if Déclarations 83
Nous afficherons le même message que nous avions précédemment si la personne est assez âgée pour voter,

mais cette fois, nous ajouterons un message pour toute personne qui n'est pas assez âgée pour voter:

âge = 17
u si âge> = 18:
print ("Vous êtes en âge de voter!") print ("Vous êtes-vous
déjà inscrit pour voter?")
v autre:
print ("Désolé, vous êtes trop jeune pour voter.")
print ("Veuillez vous inscrire pour voter dès que vous aurez 18 ans!")

Si le test conditionnel à u passe, le premier bloc de impression


instructions est exécutée. Si le test évalue Faux, le autre bloquer à v est exécuté. Parce que âge est
inférieure à 18 cette fois, le test conditionnel échoue et le code dans le autre le bloc est exécuté:

Désolé, vous êtes trop jeune pour voter.


Veuillez vous inscrire pour voter dès que vous aurez 18 ans!

Ce code fonctionne car il n'a que deux situations possibles à évaluer: une personne
est soit en âge de voter, soit en âge de voter. Le sinon
La structure fonctionne bien dans les situations dans lesquelles vous souhaitez que Python exécute toujours l'une des
deux actions possibles. Dans un simple sinon chaîne comme celle-ci, l'une des deux actions sera toujours exécutée.

La chaîne if-elif-else

Souvent, vous devrez tester plus de deux situations possibles, et pour les évaluer, vous pouvez utiliser
Python if-elif-else syntaxe. Python n'exécute qu'un seul bloc dans un if-elif-else chaîne. Il exécute chaque
test conditionnel dans l'ordre jusqu'à ce qu'il soit réussi. Lorsqu'un test réussit, le code suivant ce test
est exécuté et Python ignore le reste des tests.

De nombreuses situations du monde réel impliquent plus de deux conditions possibles. Par exemple,
considérons un parc d'attractions qui facture des tarifs différents pour différents groupes d'âge:

• L'entrée pour toute personne de moins de 4 ans est gratuite.

• L'entrée pour toute personne âgée de 4 à 18 ans est de 5 $. L'entrée pour toute

• personne âgée de 18 ans ou plus est de 10 $.

Comment pouvons-nous utiliser un si déclaration pour déterminer le taux d'admission d'une personne? Le
code suivant teste le groupe d'âge d'une personne, puis imprime un message de prix d'admission:

amusement_ âge = 12
park.py
u si âge <4:
print ("Votre prix d'entrée est de 0 $.")

84 Chapitre 5
v âge elif <18 ans:
print ("Le coût d'admission est de 5 $.")
w autre:
print ("Le coût d'admission est de 10 $.")

Le si tester à u teste si une personne a moins de 4 ans. Si le test réussit, un message


approprié est imprimé et Python ignore le reste des tests. Le elif ligne à v est vraiment un autre si test,
qui ne s'exécute que si le test précédent a échoué. À ce stade de la chaîne, nous savons que la
personne a au moins 4 ans car le premier test a échoué. Si la personne a moins de 18 ans, un
message approprié est imprimé et Python ignore le autre bloquer. Si les deux si et elif les tests
échouent, Python exécute le code dans le autre bloquer à w.

Dans cet exemple, le test à u évalue à Faux, donc son bloc de code n'est pas exécuté.
Cependant, le deuxième test évalue à Vrai ( 12 est inférieur à 18) donc son code est exécuté. Le
résultat est une phrase, informant l'utilisateur du coût d'admission:

Votre coût d'admission est de 5 $.

Tout âge supérieur à 17 ans entraînerait l'échec des deux premiers tests. Dans ces
situations, le autre le bloc serait exécuté et le prix d'entrée serait de 10 $.

Plutôt que d'imprimer le prix d'entrée dans le if-elif-else bloc, il serait plus concis de fixer
uniquement le prix à l'intérieur du if-elif-else chaîne et ensuite avoir un simple impression instruction
qui s'exécute après que la chaîne a été évaluée:

âge = 12

si âge <4:
u prix = 0
âge elif <18 ans:
v prix = 5
autre:
w prix = 10

X print ("Votre prix d'entrée est de $" + str (prix) + ".")

Les lignes à u, v, et w définir la valeur de le prix selon l'âge de la personne, comme dans l'exemple
précédent. Une fois le prix fixé par le if-elif-else chaîne, un séparé non indenté impression déclaration X utilise
cette valeur pour afficher un message indiquant le prix d'entrée de la personne.

Ce code produit la même sortie que l'exemple précédent, mais le but de la if-elif-else la
chaîne est plus étroite. Au lieu de déterminer un prix et d'afficher un message, il détermine
simplement le prix d'entrée. En plus d'être plus efficace, ce code révisé est plus facile à
modifier que l'approche originale. Pour modifier le texte du message de sortie, vous devez
en modifier un seul impression déclaration plutôt que trois

impression déclarations.

if Déclarations 85
Utilisation de plusieurs blocs elif

Vous pouvez en utiliser autant elif bloque votre code comme vous le souhaitez. Par exemple, si le parc d'attractions devait
mettre en œuvre une réduction pour les personnes âgées, vous pourriez ajouter un test conditionnel supplémentaire au
code pour déterminer si quelqu'un était admissible à la réduction pour les seniors. Disons que toute personne de 65 ans
ou plus paie la moitié de l'admission régulière, soit 5 $:

âge = 12

si âge <4:
prix = 0
âge elif <18 ans:
prix = 5
u âge elif <65 ans:
prix = 10
v autre:
prix = 5

print ("Votre prix d'entrée est de $" + str (prix) + ".")

La plupart de ce code est inchangé. La deuxième elif bloquer à u vérifie maintenant pour s'assurer
qu'une personne a moins de 65 ans avant de lui attribuer le plein tarif d'admission de 10 $. Notez que la
valeur attribuée dans le autre bloquer à v
doit être changé à 5 $, car les seuls âges qui atteignent ce bloc sont les personnes de 65 ans ou
plus.

Omettre le bloc else


Python ne nécessite pas de autre bloc à la fin d'un if-elif chaîne. Parfois un autre le bloc est utile;
parfois, il est plus clair d'utiliser un
elif déclaration qui attrape la condition spécifique d'intérêt:

âge = 12

si âge <4:
prix = 0
âge elif <18 ans:
prix = 5
âge elif <65 ans:
prix = 10
u âge elif> = 65:
prix = 5

print ("Votre prix d'entrée est de $" + str (prix) + ".")

L'extra elif bloquer à u attribue un prix de 5 $ lorsque la personne a 65 ans ou plus, ce qui est un
peu plus clair que le général autre bloquer. Avec ce changement, chaque bloc de code doit passer un
test spécifique pour être exécuté.

86 Chapitre 5
Le autre block est une instruction fourre-tout. Il correspond à toute condition qui n'a pas été remplie par
un si ou elif test, et cela peut parfois inclure des données invalides ou même malveillantes. Si vous avez une
condition finale spécifique que vous testez, envisagez d'utiliser une condition finale elif bloquer et omettre le autre
bloquer. En conséquence, vous gagnerez en confiance que votre code ne s'exécutera que dans les bonnes
conditions.

Test de plusieurs conditions

Le if-elif-else La chaîne est puissante, mais son utilisation n'est appropriée que lorsque vous n'avez besoin
que d'un seul test pour réussir. Dès que Python trouve un test qui réussit, il ignore le reste des tests. Ce
comportement est bénéfique, car il est efficace et vous permet de tester une condition spécifique.

Cependant, il est parfois important de vérifier toutes les conditions d'intérêt. Dans ce cas, vous
devez utiliser une série de simples si déclarations sans
elif ou autre blocs. Cette technique est logique lorsque plusieurs conditions peuvent être Vrai, et
vous voulez agir sur chaque condition qui est Vrai.
Revenons sur l'exemple de la pizzeria. Si quelqu'un demande une pizza à deux garnitures, vous
devrez vous assurer d'inclure les deux garnitures sur sa pizza:

toppings.py u required_toppings = ['champignons', 'extra fromage']

v si 'champignons' dans les tables_données:


print ("Ajout de champignons.")
w si 'pepperoni' dans les demandés_toppings:
print ("Ajout de pepperoni.")
X si 'extra cheese' dans les tables_données:
print ("Ajout de fromage supplémentaire.")

print ("\ nTerminé à faire votre pizza!")

Nous commençons à u avec une liste contenant les garnitures demandées. Le si


déclaration à v vérifie si la personne a demandé des champignons sur sa pizza. Si tel est le cas,
un message est imprimé confirmant cette garniture. Le test du pepperoni à w est un autre simple si déclaration,
pas une elif ou autre
, donc ce test est exécuté indépendamment du fait que le test précédent ait réussi ou non. Le code à X vérifie
si un supplément de fromage a été demandé quels que soient les résultats des deux premiers tests. Ces
trois tests indépendants sont exécutés à chaque fois que ce programme est exécuté.

Étant donné que chaque condition de cet exemple est évaluée, les champignons et le fromage
supplémentaire sont ajoutés à la pizza:

Ajout de champignons.
Ajout de fromage supplémentaire.

Fini de faire votre pizza!

if Déclarations 87
Ce code ne fonctionnerait pas correctement si nous utilisions un if-elif-else block, car le code
s'arrêterait de fonctionner après un seul test réussi. Voici à quoi cela ressemblerait:

required_toppings = ['champignons', 'extra fromage']

si 'champignons' dans les tables_données:


print ("Ajout de champignons.")
elif 'pepperoni' dans required_toppings:
print ("Ajout de pepperoni.")
elif 'extra cheese' dans les tables_données:
print ("Ajout de fromage supplémentaire.")

print ("\ nTerminé à faire votre pizza!")

Le test pour ' champignons' est le premier test à réussir, donc les champignons sont ajoutés à la pizza.
Cependant, les valeurs ' fromage supplémentaire' et ' pepperoni' ne sont jamais vérifiés, car Python n'exécute
aucun test au-delà du premier test qui passe dans un if-elif-else chaîne. La première garniture du client
sera ajoutée, mais toutes les autres garnitures seront manquées:

Ajout de champignons.

Fini de faire votre pizza!

En résumé, si vous ne souhaitez qu'un seul bloc de code à exécuter, utilisez un if-elifelse chaîne.
Si plusieurs blocs de code doivent être exécutés, utilisez une série de si déclarations.

essayez-le vous-même

5-3. Couleurs extraterrestres # 1: Imaginez qu'un extraterrestre vient d'être abattu dans un match. Créez une variable

appelée alien_color et attribuez-lui la valeur ' vert jaune', ou ' rouge' .

• Écrire un si pour tester si la couleur de l'alien est verte. Si c'est le cas, imprimez un message indiquant que le

joueur vient de gagner 5 points.

• Écrivez une version de ce programme qui passe le si test et un autre qui échoue. (La version qui
échoue n'aura pas de sortie.)

5-4. Couleurs extraterrestres # 2: Choisissez une couleur pour un extraterrestre comme vous l'avez fait dans l'exercice 5-3 et écrivez un sinon

chaîne .

• Si la couleur de l'extraterrestre est verte, imprimez une déclaration indiquant que le joueur vient de gagner 5 points pour

avoir tiré sur l'extraterrestre.

• Si la couleur de l'alien n'est pas verte, imprimez une déclaration indiquant que le joueur vient de gagner 10 points.

• Écrivez une version de ce programme qui exécute le si bloc et un autre qui exécute le autre bloquer .

88 Chapitre 5
5-5. Couleurs extraterrestres # 3: Transformez votre sinon chaîne de l'exercice 5-4 dans un if-elifelse chaîne .

• Si l'étranger est vert, imprimez un message indiquant que le joueur a gagné 5 points.

• Si l'étranger est jaune, imprimez un message indiquant que le joueur a gagné 10 points.

• Si l'étranger est rouge, imprimez un message indiquant que le joueur a gagné 15 points.

• Écrivez trois versions de ce programme, en vous assurant que chaque message est imprimé pour la couleur

étrangère appropriée.

5-6. Étapes de la vie: Écrire un if-elif-else chaîne qui détermine le stade de la vie d'une personne. Définir

une valeur pour la variable âge, puis:

• Si la personne a moins de 2 ans, imprimez un message indiquant qu'elle est un bébé.

• Si la personne a au moins 2 ans mais moins de 4 ans, imprimez un message indiquant que la personne est un enfant en

bas âge.

• Si la personne a au moins 4 ans mais moins de 13 ans, imprimez un message indiquant que la personne est un

enfant.

• Si la personne a au moins 13 ans mais moins de 20 ans, imprimez un message indiquant que la personne est un

adolescent.

• Si la personne a au moins 20 ans mais moins de 65 ans, imprimez un message indiquant que la personne est un

adulte.

• Si la personne est âgée de 65 ans ou plus, imprimez un message indiquant qu'elle est une personne âgée.

5-7. Fruit préféré: Faites une liste de vos fruits préférés, puis écrivez une série de si des déclarations
qui vérifient certains fruits dans votre liste.

• Faites une liste de vos trois fruits préférés et appelez-la favorite_fruits.

• Écris cinq si déclarations. Chacun devrait vérifier si un certain type de fruit est dans votre liste. Si le fruit est

dans votre liste, le si block doit imprimer une instruction, telle que Vous aimez vraiment les bananes!

utilisation d'instructions if avec des listes

Vous pouvez faire un travail intéressant en combinant des listes et si déclarations. Vous pouvez surveiller les valeurs
spéciales qui doivent être traitées différemment des autres valeurs de la liste. Vous pouvez gérer efficacement les
conditions changeantes, telles que la disponibilité de certains articles dans un restaurant tout au long d'un quart de
travail. Vous pouvez également commencer à prouver que votre code fonctionne comme prévu dans toutes les
situations possibles.

if Déclarations 89
Vérification des articles spéciaux

Ce chapitre a commencé par un exemple simple qui montrait comment gérer une valeur spéciale telle que ' BMW',
qui devait être imprimé dans un format différent des autres valeurs de la liste. Maintenant que vous avez une
compréhension de base des tests conditionnels et si , examinons de plus près comment vous pouvez
surveiller les valeurs spéciales dans une liste et gérer ces valeurs de manière appropriée.

Continuons avec l'exemple de la pizzeria. La pizzeria affiche un message chaque fois qu'une garniture est
ajoutée à votre pizza, au fur et à mesure de sa fabrication. Le code de cette action peut être écrit très efficacement en
faisant une liste des garnitures que le client a demandées et en utilisant une boucle pour annoncer chaque garniture
au fur et à mesure qu'elle est ajoutée à la pizza:

toppings.py required_toppings = ['champignons', 'poivrons verts', 'extra fromage']

pour Request_topping dans Required_toppings:


print ("Ajout" + demandé_topping + ".")

print ("\ nTerminé à faire votre pizza!")

La sortie est simple car ce code n'est qu'un simple pour boucle:

Ajout de champignons.
Ajout de poivrons verts.
Ajout de fromage supplémentaire.

Fini de faire votre pizza!

Mais que faire si la pizzeria est à court de poivrons verts? Une si déclaration à l'intérieur du pour loop
peut gérer cette situation de manière appropriée:

required_toppings = ['champignons', 'poivrons verts', 'extra fromage']

pour Request_topping dans Required_toppings:


u si demandé_topping == 'poivrons verts':
print ("Désolé, nous n'avons plus de poivrons verts pour le moment.") sinon:
v
print ("Ajout" + demandé_topping + ".")

print ("\ nTerminé à faire votre pizza!")

Cette fois, nous vérifions chaque article demandé avant de l'ajouter à la pizza. Le code à u vérifie si la
personne a demandé des poivrons verts. Si tel est le cas, nous affichons un message leur expliquant
pourquoi ils ne peuvent pas avoir de poivrons verts. Le autre bloquer à v s'assure que toutes les autres
garnitures seront ajoutées à la pizza.

90 Chapitre 5
La sortie montre que chaque garniture demandée est gérée de manière appropriée.

Ajout de champignons.
Désolé, nous n'avons plus de poivrons verts pour le moment. Ajout de fromage

supplémentaire.

Fini de faire votre pizza!

Vérifier qu'une liste n'est pas vide

Nous avons fait une simple hypothèse sur chaque liste avec laquelle nous avons travaillé jusqu'à présent; nous avons
supposé que chaque liste contenait au moins un élément. Bientôt, nous laisserons les utilisateurs fournir les informations
stockées dans une liste, nous ne pourrons donc pas supposer qu'une liste contient des éléments à chaque fois qu'une
boucle est exécutée. Dans cette situation, il est utile de vérifier si une liste est vide avant d'exécuter un pour boucle.

A titre d'exemple, vérifions si la liste des garnitures demandées est vide avant de construire la pizza.
Si la liste est vide, nous inviterons l'utilisateur et nous assurerons qu'il veut une pizza ordinaire. Si la liste
n'est pas vide, nous construirons la pizza comme nous l'avons fait dans les exemples précédents:

u request_toppings = []

v si demandé_toppings:
pour Request_topping dans Required_toppings:
print ("Ajout" + demandé_topping + ".") print ("\ nTerminé à faire
votre pizza!")
w autre:
print ("Êtes-vous sûr de vouloir une pizza ordinaire?")

Cette fois, nous commençons avec une liste vide de garnitures demandées à u.
Au lieu de sauter directement dans un pour boucle, nous faisons une vérification rapide à v. Lorsque le nom
d'une liste est utilisé dans un si déclaration, Python retourne Vrai si la liste contient au moins un élément; une
liste vide est évaluée à Faux. Si request_toppings
réussit le test conditionnel, nous exécutons le même pour boucle que nous avons utilisée dans l'exemple précédent. Si
le test conditionnel échoue, nous imprimons un message demandant au client s'il veut vraiment une pizza simple
sans garniture w.
La liste est vide dans ce cas, donc la sortie demande si l'utilisateur veut vraiment une pizza ordinaire:

Êtes-vous sûr de vouloir une pizza ordinaire?

Si la liste n'est pas vide, la sortie affichera chaque garniture demandée ajoutée à la
pizza.

if Déclarations 91
Utilisation de plusieurs listes

Les gens demanderont à peu près n'importe quoi, surtout quand il s'agit de garnitures de pizza. Et si un
client veut réellement des frites sur sa pizza? Vous pouvez utiliser des listes et si pour vous assurer que
votre contribution a du sens avant d’agir en conséquence.

Faisons attention aux demandes de garniture inhabituelles avant de construire une pizza.
L'exemple suivant définit deux listes. Le premier est une liste des garnitures disponibles à la pizzeria, et
le second est la liste des garnitures que l'utilisateur a demandées. Cette fois, chaque élément de request_toppings
est comparé à la liste des garnitures disponibles avant d'être ajouté à la pizza:

u available_toppings = ['champignons', 'olives', 'poivrons verts',


«pepperoni», «ananas», «extra cheese»]

v required_toppings = ['champignons', 'frites', 'extra fromage']

w pour Request_topping dans Required_toppings:


X si demandé_topping dans available_toppings:
print ("Ajout" + demandé_topping + ".") else:
y
print ("Désolé, nous n'avons pas" + demandé_topping + ".")

print ("\ nTerminé à faire votre pizza!")

À u nous définissons une liste de garnitures disponibles dans cette pizzeria. Notez que cela pourrait être
un tuple si la pizzeria a une sélection stable de garnitures. À v,
nous faisons une liste des garnitures qu'un client a demandées. Notez la demande inhabituelle, ' frites'. À w nous
parcourons la liste des garnitures demandées. À l'intérieur de la boucle, nous vérifions d'abord si chaque garniture
demandée est réellement dans la liste des garnitures disponibles X. Si c'est le cas, nous ajoutons cette garniture à la
pizza. Si la garniture demandée ne figure pas dans la liste des garnitures disponibles, le autre le bloc fonctionnera y. Le
autre block imprime un message indiquant à l'utilisateur quelles garnitures ne sont pas disponibles.

Cette syntaxe de code produit une sortie claire et informative:

Ajout de champignons.
Désolé, nous n'avons pas de frites. Ajout de fromage
supplémentaire.

Fini de faire votre pizza!

En seulement quelques lignes de code, nous avons géré une situation du monde réel assez efficacement!

92 Chapitre 5
essayez-le vous-même

5-8. Bonjour Admin: Faites une liste d'au moins cinq noms d'utilisateur, y compris le nom

«admin». Imaginez que vous écrivez un code qui imprimera un message d'accueil à chaque utilisateur après sa connexion à

un site Web. Parcourez la liste et imprimez un message d'accueil à chaque utilisateur:

• Si le nom d'utilisateur est ' admin ', imprimer un message d'accueil spécial, tel que Bonjour administrateur, souhaitez-vous

voir un rapport d'état?

• Sinon, imprimez un message d'accueil générique, tel que Bonjour Eric, merci de vous reconnecter.

5-9. Aucun utilisateur: Ajouter un si tester à bonjour_admin.py pour vous assurer que la liste des utilisateurs n'est pas vide.

• Si la liste est vide, imprimez le message Nous devons trouver des utilisateurs!

• Supprimez tous les noms d'utilisateur de votre liste et assurez-vous que le message correct est

imprimé.

5-10. Vérification des noms d'utilisateur: Procédez comme suit pour créer un programme qui simule la façon dont les sites Web

garantissent que tout le monde a un nom d'utilisateur unique.

• Faites une liste de cinq noms d'utilisateur ou plus appelés Utilisateurs actuels .

• Faites une autre liste de cinq noms d'utilisateurs appelés nouveaux utilisateurs . Assurez-vous qu'un ou deux des nouveaux

noms d'utilisateur sont également dans le Utilisateurs actuels liste .

• Parcourez le nouveaux utilisateurs list pour voir si chaque nouveau nom d'utilisateur a déjà été utilisé. Si c'est le cas,

imprimez un message indiquant que la personne devra entrer un nouveau nom d'utilisateur. Si aucun nom d'utilisateur

n'a été utilisé, imprimez un message indiquant que le nom d'utilisateur est disponible.

• Assurez-vous que votre comparaison est insensible à la casse. Si ' John' a été utilisé,

'JOHN' ne doit pas être accepté.

5-11. Nombres ordinaux: Les nombres ordinaux indiquent leur position dans une liste, comme 1er ou 2ème. La plupart

des nombres ordinaux se terminent par e, sauf 1, 2 et 3.

• Stockez les nombres 1 à 9 dans une liste.

• Parcourez la liste.

• Utilisez un if-elif-else chaîne à l'intérieur de la boucle pour imprimer la fin ordinale appropriée pour
chaque nombre. Votre sortie devrait lire " 1er 2e 3e 4e 5e 6e 7e 8e 9e ", et chaque résultat doit être
sur une ligne distincte.

if Déclarations 93
styliser vos déclarations if
Dans chaque exemple de ce chapitre, vous avez vu de bonnes habitudes de style. La seule recommandation que
PEP 8 fournit pour styliser les tests conditionnels est d'utiliser un espace unique autour des opérateurs de
comparaison, tels que ==,> =, <=. Par exemple:

si âge <4:

est mieux que:

si âge <4:

Un tel espacement n'affecte pas la façon dont Python interprète votre code; cela rend simplement votre code
plus facile à lire pour vous et les autres.

essayez-le vous-même

5-12. Coiffant si déclarations: Passez en revue les programmes que vous avez écrits dans ce chapitre et assurez-vous

d'avoir correctement conçu vos tests conditionnels.

5-13. Tes idées: À ce stade, vous êtes un programmeur plus compétent que vous ne l'étiez lorsque vous avez commencé ce livre.

Maintenant que vous avez une meilleure idée de la façon dont les situations du monde réel sont modélisées dans les programmes,

vous pensez peut-être à certains problèmes que vous pourriez résoudre avec vos propres programmes. Enregistrez toutes les

nouvelles idées que vous avez sur les problèmes que vous voudrez peut-être résoudre à mesure que vos compétences en

programmation continuent de s'améliorer. Pensez aux jeux que vous voudrez peut-être écrire, aux ensembles de données que vous

voudrez peut-être explorer et aux applications Web que vous aimeriez créer.

résumé
Dans ce chapitre, vous avez appris à écrire des tests conditionnels, qui évaluent toujours Vrai ou Faux.
Tu as appris à écrire simple si déclarations, sinon
chaînes, et if-elif-else Chaînes. Vous avez commencé à utiliser ces structures pour identifier les conditions
particulières que vous deviez tester et pour savoir quand ces conditions ont été remplies dans vos programmes.
Vous avez appris à gérer certains éléments d'une liste différemment de tous les autres éléments tout en continuant à
utiliser l'efficacité d'un pour boucle. Vous avez également revisité les recommandations de style de Python pour vous
assurer que vos programmes de plus en plus complexes sont encore relativement faciles à lire et à comprendre.

Dans le chapitre 6, vous découvrirez les dictionnaires de Python. Un dictionnaire est similaire à une
liste, mais il vous permet de relier des informations. Vous apprendrez à créer des dictionnaires, à les
parcourir en boucle et à les utiliser en combinaison avec des listes et si déclarations. L'apprentissage des
dictionnaires vous permettra de modéliser une plus grande variété de situations réelles.

94 Chapitre 5
6
DICt Ionar I es

Dans ce chapitre, vous apprendrez à utiliser les dictionnaires de


Python, qui vous permettent de connecter des informations connexes.
Vous apprendrez comment accéder aux informations une fois qu'elles
sont dans un dictionnaire et comment modifier ces informations. Parce
que les dictionnaires peuvent stocker une

quantité d'informations, je vais vous montrer comment parcourir les données dans un dictionnaire. De plus,
vous apprendrez à imbriquer des dictionnaires dans des listes, des listes dans des dictionnaires et même des
dictionnaires dans d'autres dictionnaires.
La compréhension des dictionnaires vous permet de modéliser une variété d'objets du monde réel avec
plus de précision. Vous pourrez créer un dictionnaire représentant une personne, puis stocker autant
d'informations que vous le souhaitez sur cette personne. Vous pouvez stocker son nom, son âge, son
emplacement, sa profession et tout autre aspect d'une personne que vous pouvez décrire. Vous serez en
mesure de stocker deux types d'informations pouvant être associées, telles qu'une liste de mots et leur
signification, une liste de noms de personnes et de leurs numéros préférés, une liste de montagnes et de leurs
altitudes, etc.
un dictionnaire simple
Considérez un jeu avec des extraterrestres qui peuvent avoir différentes couleurs et valeurs de points. Ce
dictionnaire simple stocke des informations sur un extraterrestre particulier:

extraterrestre.py alien_0 = {'couleur': 'vert', 'points': 5}

print (alien_0 ['couleur'])


print (alien_0 ['points'])

Le dictionnaire extraterrestre_0 stocke la couleur et la valeur en points de l'alien. Les deux


impression les instructions accèdent et affichent ces informations, comme indiqué ici:

vert
5

Comme pour la plupart des nouveaux concepts de programmation, l'utilisation de dictionnaires demande de la

pratique. Une fois que vous aurez travaillé un peu avec les dictionnaires, vous verrez bientôt avec quelle efficacité ils

peuvent modéliser des situations réelles.

travailler avec des dictionnaires

UNE dictionnaire en Python est une collection de paires clé-valeur. Chaque clé est connecté à une valeur et vous pouvez
utiliser une clé pour accéder à la valeur associée à cette clé. La valeur d'une clé peut être un nombre, une chaîne, une liste
ou même un autre dictionnaire. En fait, vous pouvez utiliser n'importe quel objet que vous pouvez créer en Python comme
valeur dans un dictionnaire.

En Python, un dictionnaire est entouré d'accolades, {}, avec une série de paires de valeurs clés à l'intérieur
des accolades, comme indiqué dans l'exemple précédent:

alien_0 = {'couleur': 'vert', 'points': 5}

UNE paire clé-valeur est un ensemble de valeurs associées les unes aux autres. Lorsque vous fournissez une clé,
Python renvoie la valeur associée à cette clé. Chaque clé est connectée à sa valeur par un signe deux-points et les
paires clé-valeur individuelles sont séparées par des virgules. Vous pouvez stocker autant de paires clé-valeur que vous
le souhaitez dans un dictionnaire.

Le dictionnaire le plus simple a exactement une paire clé-valeur, comme indiqué dans cette version modifiée
du extraterrestre_0 dictionnaire:

alien_0 = {'color': 'green'}

Ce dictionnaire stocke une information sur extraterrestre_0, à savoir la couleur de l'étranger. La


chaîne ' Couleur' est une clé dans ce dictionnaire, et sa valeur associée est ' vert'.

96 Chapitre 6
Accéder aux valeurs dans un dictionnaire

Pour obtenir la valeur associée à une clé, donnez le nom du dictionnaire, puis placez la clé
dans un ensemble de crochets, comme indiqué ici:

alien_0 = {'color': 'green'}


print (alien_0 ['couleur'])

Cela renvoie la valeur associée à la clé ' Couleur' de la diction


ary alien_0:

vert

Vous pouvez avoir un nombre illimité de paires clé-valeur dans un dictionnaire. Par exemple, voici
l'original extraterrestre_0 dictionnaire avec deux paires clé-valeur:

alien_0 = {'couleur': 'vert', 'points': 5}

Vous pouvez maintenant accéder à la couleur ou à la valeur en points de alien_0. Si un joueur abat cet extraterrestre,
vous pouvez rechercher le nombre de points qu'il devrait gagner en utilisant un code comme celui-ci:

alien_0 = {'couleur': 'vert', 'points': 5}

u new_points = alien_0 ['points']


v print ("Vous venez de gagner" + str (new_points) + "points!")

Une fois le dictionnaire défini, le code à u extrait la valeur associée à la clé ' points' du
dictionnaire. Cette valeur est ensuite stockée dans la variable new_points. La ligne à v convertit
cette valeur entière en une chaîne et affiche une déclaration sur le nombre de points que le
joueur vient de gagner:

Vous venez de gagner 5 points!

Si vous exécutez ce code chaque fois qu'un extraterrestre est abattu, la valeur en points de l'alien sera
récupérée.

Ajout de nouvelles paires clé-valeur

Les dictionnaires sont des structures dynamiques et vous pouvez à tout moment ajouter de nouvelles paires
clé-valeur à un dictionnaire. Par exemple, pour ajouter une nouvelle paire clé-valeur, vous devez donner le
nom du dictionnaire suivi de la nouvelle clé entre crochets avec la nouvelle valeur.

Ajoutons deux nouvelles informations au extraterrestre_0 dictionnaire: les coordonnées x et y de


l'extraterrestre, qui nous aideront à afficher l'extraterrestre dans une position particulière sur l'écran. Plaçons
l'extraterrestre sur le bord gauche de l'écran, à 25 pixels du haut. Parce que les coordonnées de l'écran
commencent généralement dans le coin supérieur gauche de l'écran, nous placerons l'extraterrestre sur la
gauche

Dictionnaires 97
bord de l'écran en définissant la coordonnée x sur 0 et 25 pixels à partir du haut en définissant sa
coordonnée y sur positive 25, comme indiqué ici:

alien_0 = {'couleur': 'vert', 'points': 5}


imprimer (alien_0)

u alien_0 ['x_position'] = 0
v alien_0 ['y_position'] = 25
imprimer (alien_0)

Nous commençons par définir le même dictionnaire avec lequel nous avons travaillé. Nous imprimons
ensuite ce dictionnaire, affichant un instantané de ses informations. À u nous ajoutons une nouvelle paire
clé-valeur au dictionnaire: key ' x_position '
et valeur 0. Nous faisons la même chose pour la clé ' y_position ' à v. Lorsque nous imprimons le dictionnaire modifié,
nous voyons les deux paires clé-valeur supplémentaires:

{'color': 'green', 'points': 5}


{'color': 'green', 'points': 5, 'y_position': 25, 'x_position': 0}

La version finale du dictionnaire contient quatre paires clé-valeur. Les deux originaux spécifient la
couleur et la valeur du point, et deux autres spécifient la position de l'étranger. Notez que l'ordre des
paires clé-valeur ne correspond pas à l'ordre dans lequel nous les avons ajoutées. Python ne se soucie
pas de l'ordre dans lequel vous stockez chaque paire clé-valeur; il ne se soucie que de la connexion
entre chaque clé et sa valeur.

Commencer par un dictionnaire vide

Il est parfois pratique, voire nécessaire, de commencer avec un dictionnaire vide, puis d'y ajouter chaque nouvel
élément. Pour commencer à remplir un dictionnaire vide, définissez un dictionnaire avec un ensemble
d'accolades vide, puis ajoutez chaque paire clé-valeur sur sa propre ligne. Par exemple, voici comment construire
le extraterrestre_0 dictionnaire utilisant cette approche:

alien_0 = {}

alien_0 ['color'] = 'vert'


alien_0 ['points'] = 5

imprimer (alien_0)

Ici, nous définissons un vide extraterrestre_0 dictionnaire, puis ajoutez-lui des valeurs de couleur et de point. Le
résultat est le dictionnaire que nous avons utilisé dans les exemples précédents:

{'color': 'green', 'points': 5}

En règle générale, vous utiliserez des dictionnaires vides lors du stockage de données fournies par l'utilisateur dans

un dictionnaire ou lorsque vous écrivez du code qui génère automatiquement un grand nombre de paires clé-valeur.

98 Chapitre 6
Modification des valeurs dans un dictionnaire

Pour modifier une valeur dans un dictionnaire, donnez le nom du dictionnaire avec la clé entre crochets,
puis la nouvelle valeur que vous souhaitez associer à cette clé. Par exemple, considérons un extraterrestre
qui passe du vert au jaune au fur et à mesure que le jeu progresse:

alien_0 = {'color': 'green'}


print ("L'alien est" + alien_0 ['color'] + ".")

alien_0 ['color'] = 'jaune'


print ("L'alien est maintenant" + alien_0 ['color'] + ".")

Nous définissons d'abord un dictionnaire pour extraterrestre_0 qui ne contient que la couleur de
l'étranger; puis on change la valeur associée à la clé ' Couleur' à ' jaune'.
La sortie montre que l'extraterrestre est en effet passé du vert au jaune:

L'étranger est vert.


L'étranger est maintenant jaune.

Pour un exemple plus intéressant, suivons la position d'un extraterrestre qui peut se déplacer à différentes
vitesses. Nous allons stocker une valeur représentant la vitesse actuelle de l'extraterrestre, puis l'utiliser pour
déterminer à quelle distance vers la droite l'alien doit se déplacer:

alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'} print ("Original x-position:" + str
(alien_0 ['x_position']))

# Déplacez l'extraterrestre vers la droite.


# Déterminez la distance à parcourir pour déplacer l'extraterrestre en fonction de sa vitesse actuelle.

u if alien_0 ['speed'] == 'slow':


x_increment = 1
elif alien_0 ['speed'] == 'medium':
x_increment = 2
autre:
# Cela doit être un extraterrestre rapide.
x_increment = 3

# La nouvelle position est l'ancienne position plus l'incrément.


v alien_0 ['x_position'] = alien_0 ['x_position'] + x_increment

print ("Nouvelle position x:" + str (alien_0 ['x_position']))

Nous commençons par définir un extraterrestre avec une initiale X position et y position, et une vitesse de ' moyen'.
Nous avons omis les valeurs de couleur et de point par souci de simplicité, mais cet exemple fonctionnerait de la
même manière si vous incluiez également ces paires clé-valeur. Nous imprimons également la valeur d'origine de x_position
pour voir jusqu'où l'extraterrestre se déplace vers la droite.

À u, une if-elif-else La chaîne détermine jusqu'où l'extraterrestre doit se déplacer vers la droite et stocke
cette valeur dans la variable x_increment. Si la vitesse de l'alien est ' lent', il se déplace d'une unité vers la droite;
si la vitesse est ' moyen', ça bouge deux

Dictionnaires 99
unités à droite; et si c'est ' vite', il déplace trois unités vers la droite. Une fois que l'incrément a
été calculé, il est ajouté à la valeur de x_position à v,
et le résultat est stocké dans le dictionnaire x_position.
Comme il s'agit d'un extraterrestre à vitesse moyenne, sa position décale de deux unités vers la droite:

Position x d'origine: 0
Nouvelle position x: 2

Cette technique est plutôt cool: en changeant une valeur dans le dictionnaire de l'alien, vous pouvez
changer le comportement général de l'alien. Par exemple, pour transformer cet extraterrestre à vitesse moyenne
en extraterrestre rapide, vous ajouteriez la ligne:

alien_0 ['speed'] = rapide

Le if-elif-else block attribuerait alors une valeur plus grande à x_increment


la prochaine fois que le code s'exécute.

Suppression de paires clé-valeur

Lorsque vous n'avez plus besoin d'une information stockée dans un dictionnaire, vous pouvez
utiliser le del pour supprimer complètement une paire clé-valeur. Tout del besoins est le nom du
dictionnaire et la clé que vous souhaitez supprimer.

Par exemple, supprimons la clé ' points' du extraterrestre_0 dictionnaire avec sa valeur:

alien_0 = {'color': 'green', 'points': 5} print (alien_0)

u del alien_0 ['points']


imprimer (alien_0)

La ligne à u dit à Python de supprimer la clé ' points' du dictionnaire


extraterrestre_0 et pour supprimer également la valeur associée à cette clé. La sortie montre que la
clé ' points' et sa valeur de 5 sont supprimés du dictionnaire, mais le reste du dictionnaire n'est pas
affecté:

{'color': 'green', 'points': 5} {'color': 'green'}

Remarque Sachez que la paire clé-valeur supprimée est supprimée définitivement.

Un dictionnaire d'objets similaires

L'exemple précédent impliquait de stocker différents types d'informations sur un objet, un extraterrestre dans un jeu.
Vous pouvez également utiliser un dictionnaire pour stocker un type d'informations sur de nombreux objets. Par
exemple, disons que vous souhaitez interroger un

100 Chapitre 6
nombre de personnes et demandez-leur quel est leur langage de programmation préféré. Un dictionnaire est
utile pour stocker les résultats d'un simple sondage, comme ceci:

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rubis',
'phil': 'python',
}

Comme vous pouvez le voir, nous avons divisé un dictionnaire plus volumineux en plusieurs lignes. Chaque clé est le

nom d'une personne qui a répondu au sondage, et chaque valeur correspond à son choix de langue. Lorsque vous savez que

vous aurez besoin de plus d'une ligne pour définir un dictionnaire, appuyez sur Entrer après l'accolade d'ouverture. Mettez

ensuite en retrait la ligne suivante d'un niveau (quatre espaces) et écrivez la première paire clé-valeur, suivie d'une virgule. À

partir de ce moment, lorsque vous appuyez sur Entrer, votre éditeur de texte doit automatiquement mettre en retrait toutes les

paires clé-valeur suivantes pour qu'elles correspondent à la première paire clé-valeur.

Une fois que vous avez fini de définir le dictionnaire, ajoutez une accolade fermante sur une nouvelle ligne après
la dernière paire clé-valeur et indentez-la d'un niveau pour qu'elle s'aligne avec les clés du dictionnaire. Il est
recommandé d'inclure également une virgule après la dernière paire clé-valeur, afin que vous soyez prêt à ajouter une
nouvelle paire clé-valeur sur la ligne suivante.

Remarque La plupart des éditeurs ont des fonctionnalités qui vous aident à formater des listes étendues et des dictionnaires d'une
manière similaire à cet exemple. D'autres moyens acceptables de formater de longs dictionnaires sont également
disponibles, de sorte que vous pouvez voir un formatage légèrement différent dans votre éditeur ou dans d'autres sources.

Pour utiliser ce dictionnaire, étant donné le nom d'une personne qui a répondu au sondage, vous pouvez
facilement rechercher sa langue préférée:

favori_ favorite_languages = {
languages.py 'jen': 'python',
'sarah': 'c',
'edward': 'rubis',
'phil': 'python',
}

u print ("La langue préférée de Sarah est" +


v favorite_languages ['sarah']. title () +
w ".")

Pour voir quelle langue Sarah a choisi, nous demandons la valeur à:

favorite_languages ['sarah']

Cette syntaxe est utilisée dans le impression déclaration à v, et la sortie montre la langue préférée de
Sarah:

La langue préférée de Sarah est C.

Dictionnaires 101
Cet exemple montre également comment vous pouvez rompre un long impression déclaration sur plusieurs
lignes. Le mot impression est plus court que la plupart des noms de dictionnaire, il est donc logique d'inclure la
première partie de ce que vous voulez imprimer juste après la parenthèse ouvrante u. Choisissez un point
approprié pour interrompre ce qui est imprimé et ajoutez un opérateur de concaténation (+) à la fin de la
première ligne v. presse Entrer puis appuyez sur languette pour aligner toutes les lignes suivantes à un niveau
d'indentation sous le impression déclaration. Lorsque vous avez fini de composer votre sortie, vous pouvez
placer la parenthèse fermante sur la dernière ligne du impression bloquer w.

essayez-le vous-même

6-1. La personne: Utilisez un dictionnaire pour stocker des informations sur une personne que vous connaissez.

Stockez leur prénom, leur nom, leur âge et la ville dans laquelle ils vivent. Vous devriez avoir des clés telles que prénom,

nom, âge, et ville . Imprimez chaque information stockée dans votre dictionnaire.

6-2. Numéros préférés: Utilisez un dictionnaire pour stocker les numéros préférés des gens. Pensez à cinq noms et

utilisez-les comme clés dans votre dictionnaire. Pensez à un numéro préféré pour chaque personne et enregistrez-le sous

forme de valeur dans votre dictionnaire. Imprimez le nom de chaque personne et son numéro préféré. Pour encore plus de

plaisir, interrogez quelques amis et obtenez des données réelles pour votre programme.

6-3. Glossaire: Un dictionnaire Python peut être utilisé pour modéliser un dictionnaire réel. Cependant, pour éviter toute

confusion, appelons cela un glossaire.

• Pensez à cinq mots de programmation que vous avez appris dans les chapitres précédents. Utilisez ces

mots comme clés dans votre glossaire et stockez leur signification sous forme de valeurs.

• Imprimez chaque mot et sa signification sous forme de sortie soigneusement formatée. Vous pouvez imprimer le

mot suivi de deux points puis de sa signification, ou imprimer le mot sur une ligne, puis imprimer sa signification en

retrait sur une deuxième ligne. Utilisez le caractère de nouvelle ligne (\ n) pour insérer une ligne vide entre chaque

paire mot-signification dans votre sortie.

parcourir un dictionnaire en boucle

Un seul dictionnaire Python peut contenir seulement quelques paires clé-valeur ou des millions de paires. Étant donné
qu'un dictionnaire peut contenir de grandes quantités de données, Python vous permet de parcourir un dictionnaire en
boucle. Les dictionnaires peuvent être utilisés pour stocker des informations de différentes manières; par conséquent,
il existe plusieurs façons différentes de les parcourir. Vous pouvez parcourir toutes les paires clé-valeur d'un
dictionnaire, ses clés ou ses valeurs.

102 Chapitre 6
Boucle sur toutes les paires clé-valeur

Avant d'explorer les différentes approches de la boucle, considérons un nouveau dictionnaire conçu
pour stocker des informations sur un utilisateur sur un site Web. Le dictionnaire suivant stockerait le
nom d'utilisateur, le prénom et le nom d'une personne:

user_0 = {
'nom d'utilisateur': 'efermi',
'premier': 'enrico',
'dernier': 'fermi',
}

Vous pouvez accéder à n'importe quelle information sur user_0 basé


sur ce que vous avez déjà appris dans ce chapitre. Mais que faire si vous vouliez voir tout ce qui est stocké
dans le dictionnaire de cet utilisateur? Pour ce faire, vous pouvez parcourir le dictionnaire en utilisant un pour boucle:

user.py user_0 = {
'nom d'utilisateur': 'efermi',
'premier': 'enrico',
'dernier': 'fermi',
}

u pour la clé, valeur dans user_0.items ():


v print ("\ nClé:" + touche)
w print ("Valeur:" + valeur)

Comme montré à u, écrire un pour boucle pour un dictionnaire, vous créez des noms pour les deux variables
qui contiendront la clé et la valeur dans chaque paire clé-valeur. Vous pouvez choisir les noms de votre choix pour
ces deux variables. Ce code fonctionnerait aussi bien si vous aviez utilisé des abréviations pour les noms de
variables, comme ceci:

pour k, v dans user_0.items ()

La seconde moitié de la pour déclaration à u inclut le nom du dictionnaire suivi de la méthode éléments(),
qui renvoie une liste de paires clé-valeur. Le pour loop stocke ensuite chacune de ces paires dans les
deux variables fournies. Dans l'exemple précédent, nous utilisons les variables pour imprimer
chaque clé v, suivi de l'associé évaluer w. Le "\ n " en premier impression garantit qu'une ligne vide est
insérée avant chaque paire clé-valeur dans la sortie:

Clé: dernier
Valeur: fermi

Clé: première
Valeur: enrico

Clé: nom d'utilisateur

Valeur: efermi

Dictionnaires 103
Notez à nouveau que les paires clé-valeur ne sont pas renvoyées dans l'ordre dans lequel elles
ont été stockées, même lors d'une boucle dans un dictionnaire. Python ne se soucie pas de l'ordre dans
lequel les paires clé-valeur sont stockées; il ne suit que les connexions entre les clés individuelles et
leurs valeurs.
La lecture en boucle de toutes les paires clé-valeur fonctionne particulièrement bien pour les dictionnaires
tels que favorite_languages.py exemple à la page 101, qui stocke le même type d'informations pour de
nombreuses touches différentes. Si vous parcourez le
favorite_languages dictionnaire, vous obtenez le nom de chaque personne dans le dictionnaire et leur
langage de programmation préféré. Parce que les clés font toujours référence au nom d'une personne et
que la valeur est toujours une langue, nous utiliserons les variables Nom et Langue dans la boucle au lieu de
clé et évaluer. Cela facilitera le suivi de ce qui se passe à l'intérieur de la boucle:

favori_ favorite_languages = {
languages.py 'jen': 'python',
'sarah': 'c',
'edward': 'rubis',
'phil': 'python',
}

u pour le nom, la langue dans favorite_languages.items ():


v print (name.title () + la langue préférée de "est" +
language.title () + ".")

Le code à u indique à Python de parcourir chaque paire clé-valeur du dictionnaire. Comme il


fonctionne à travers chaque paire, la clé est stockée dans la variable Nom, et la valeur est stockée dans la
variable Langue. Ces noms descriptifs permettent de voir beaucoup plus facilement ce que le impression déclaration
à v fait.
Maintenant, en quelques lignes de code, nous pouvons afficher toutes les informations du sondage:

Le langage préféré de Jen est Python. La langue


préférée de Sarah est la langue préférée de C. Phil
est Python. La langue préférée d'Edward est Ruby.

Ce type de boucle fonctionnerait tout aussi bien si notre dictionnaire stockait les résultats de
l'interrogation d'un millier, voire d'un million de personnes.

Lecture en boucle de toutes les touches d'un dictionnaire

Le clés() est utile lorsque vous n'avez pas besoin de travailler avec toutes les valeurs d'un dictionnaire.
Passons en revue le favorite_languages dictionnaire et imprimez les noms de toutes les personnes qui ont
participé au sondage:

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rubis',
'phil': 'python',
}

104 Chapitre 6
u pour le nom dans favorite_languages.keys ():
imprimer (nom.titre ())

La ligne à u dit à Python d'extraire toutes les clés du dictionnaire


favorite_languages et stockez-les un par un dans la variable Nom. La sortie affiche les noms de toutes les
personnes qui ont participé au sondage:

Jen
Sarah
Phil
Edward

Faire une boucle sur les touches est en fait le comportement par défaut lors de la boucle dans un
dictionnaire, donc ce code aurait exactement la même sortie si vous écriviez. . .

pour le nom dans favorite_languages:

plutôt que . . .

pour le nom dans favorite_languages.keys ():

Vous pouvez choisir d'utiliser le clés() explicitement si cela rend votre code plus facile à lire, ou vous pouvez
l'omettre si vous le souhaitez.
Vous pouvez accéder à la valeur associée à n'importe quelle clé qui vous intéresse dans la boucle en
utilisant la clé actuelle. Imprimons un message à quelques amis sur les langues qu'ils ont choisies. Nous
allons parcourir les noms dans le dictionnaire comme nous l'avons fait précédemment, mais lorsque le nom
correspond à l'un de nos amis, nous afficherons un message sur sa langue préférée:

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rubis',
'phil': 'python',
}

u amis = ['phil', 'sarah']


pour le nom dans favorite_languages.keys ():
imprimer (nom.titre ())

v si le nom entre amis:


print ("Salut" + nom.titre () +
", Je vois que votre langue préférée est" +
w favorite_languages [nom] .title () + "!")

À u nous faisons une liste d'amis auxquels nous voulons imprimer un message. À l'intérieur de la boucle,
nous imprimons le nom de chaque personne. Puis à v nous vérifions si le Nom nous travaillons est dans la liste copains.
Si c'est le cas, nous imprimons un message d'accueil spécial, y compris une référence à leur choix de langue.
Accéder

Dictionnaires 105
la langue préférée à w, nous utilisons le nom du dictionnaire et la valeur actuelle de Nom comme
clé. Le nom de chacun est imprimé, mais nos amis reçoivent un message spécial:

Edward
Phil
Salut Phil, je vois que votre langage préféré est Python! Sarah

Salut Sarah, je vois que ta langue préférée est C! Jen

Vous pouvez également utiliser le clés() méthode pour savoir si une personne en particulier a été interrogée.
Cette fois, découvrons si Erin a répondu au sondage:

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rubis',
'phil': 'python',
}

u si 'erin' n'est pas dans favorite_languages.keys ():


print ("Erin, veuillez répondre à notre sondage!")

Le clés() n'est pas seulement pour la boucle: elle renvoie en fait une liste de toutes les clés, et la ligne à u
vérifie simplement si ' erin ' est dans cette liste. Parce qu'elle ne l'est pas, un message est imprimé l'invitant à
participer au sondage:

Erin, répondez à notre sondage!

Lecture en boucle des clés d'un dictionnaire dans l'ordre

Un dictionnaire maintient toujours une connexion claire entre chaque clé et sa valeur associée, mais
vous n'obtenez jamais les éléments d'un dictionnaire dans un ordre prévisible. Ce n'est pas un
problème, car vous souhaiterez généralement simplement obtenir la valeur correcte associée à
chaque clé.
Une façon de renvoyer les éléments dans un certain ordre consiste à trier les clés lorsqu'elles sont renvoyées dans
le pour boucle. Vous pouvez utiliser le trié () fonction pour obtenir une copie des clés dans l'ordre:

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rubis',
'phil': 'python',
}

pour le nom dans sorted (favorite_languages.keys ()):


print (name.title () + ", merci d'avoir répondu au sondage.")

106 Chapitre 6
Ce pour la déclaration est comme les autres pour déclarations sauf que nous avons enveloppé le trié () fonction
autour du dictionary.keys () méthode. Cela indique à Python de lister toutes les clés du dictionnaire et de trier cette
liste avant de la parcourir en boucle. La sortie montre toutes les personnes qui ont répondu au sondage avec les
noms affichés dans l'ordre:

Edward, merci d'avoir répondu au sondage. Jen, merci


d'avoir participé au sondage. Phil, merci d'avoir participé
au sondage. Sarah, merci d'avoir participé au sondage.

Lecture en boucle de toutes les valeurs d'un dictionnaire

Si vous êtes principalement intéressé par les valeurs contenues dans un dictionnaire, vous pouvez utiliser le valeurs()
pour renvoyer une liste de valeurs sans aucune clé. Par exemple, disons que nous voulons simplement une liste
de toutes les langues choisies dans notre sondage de langage de programmation sans le nom de la personne qui
a choisi chaque langue:

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rubis',
'phil': 'python',
}

print ("Les langues suivantes ont été mentionnées:") pour la langue dans
favorite_languages.values ():
imprimer (language.title ())

Le pour l'instruction ici extrait chaque valeur du dictionnaire et la stocke dans la variable Langue. Lorsque
ces valeurs sont imprimées, nous obtenons une liste de toutes les langues choisies:

Les langages suivants ont été mentionnés: Python

Python
Rubis

Cette approche extrait toutes les valeurs du dictionnaire sans vérifier les répétitions. Cela pourrait bien
fonctionner avec un petit nombre de valeurs, mais dans un sondage avec un grand nombre de répondants,
cela aboutirait à une liste très répétitive. Pour voir chaque langue choisie sans répétition, nous pouvons
utiliser un ensemble.
Un ensemble est similaire à une liste sauf que chaque élément de l'ensemble doit être unique:

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rubis',

Dictionnaires 107
'phil': 'python',
}

print ("Les langues suivantes ont été mentionnées:")


u pour la langue dans set (favorite_languages.values ()):
imprimer (language.title ())

Lorsque vous enveloppez ensemble() autour d'une liste contenant des éléments en double, Python identifie les

éléments uniques de la liste et construit un ensemble à partir de ces éléments. À u

nous utilisons ensemble() pour sortir les langues uniques de favorite_languages.values ().
Le résultat est une liste non répétitive de langues qui ont été mentionnées par les personnes participant au
sondage:

Les langages suivants ont été mentionnés: Python

Rubis

Au fur et à mesure que vous continuez à découvrir Python, vous trouverez souvent une fonctionnalité intégrée du

langage qui vous aide à faire exactement ce que vous voulez avec vos données.

essayez-le vous-même

6-4. Glossaire 2: Maintenant que vous savez comment parcourir un dictionnaire, nettoyez le code de
l'exercice 6-3 (page 102) en remplaçant votre série de impression
instructions avec une boucle qui parcourt les clés et les valeurs du dictionnaire. Lorsque vous êtes sûr que votre

boucle fonctionne, ajoutez cinq autres termes Python à votre glossaire. Lorsque vous exécutez à nouveau votre

programme, ces nouveaux mots et significations doivent automatiquement être inclus dans la sortie.

6-5. Rivières: Faites un dictionnaire contenant trois grands fleuves et le pays traversé par chaque
fleuve. Une paire clé-valeur pourrait être " nil »:« Égypte ».

• Utilisez une boucle pour imprimer une phrase sur chaque rivière, telle que Le Nil traverse l'Égypte.

• Utilisez une boucle pour imprimer le nom de chaque rivière incluse dans le dictionnaire. Utilisez une boucle

• pour imprimer le nom de chaque pays inclus dans le dictionnaire.

6-6. Vote: Utilisez le code dans favorite_languages.py ( page 104).

• Faites une liste de personnes qui devraient participer au sondage sur les langues préférées. Incluez certains noms

qui sont déjà dans le dictionnaire et d'autres qui ne le sont pas.

• Parcourez la liste des personnes qui devraient participer au sondage. S'ils ont déjà répondu au sondage,

imprimez un message les remerciant d'avoir répondu. S'ils n'ont pas encore répondu au sondage, imprimez

un message les invitant à participer au sondage.

108 Chapitre 6
nidification

Parfois, vous souhaiterez stocker un ensemble de dictionnaires dans une liste ou une liste d'éléments en tant que valeur
dans un dictionnaire. C'est appelé nidification. Vous pouvez imbriquer un ensemble de dictionnaires dans une liste, une
liste d'éléments dans un dictionnaire ou même un dictionnaire dans un autre dictionnaire. L'imbrication est une
fonctionnalité puissante, comme le démontrent les exemples suivants.

Une liste de dictionnaires

Le extraterrestre_0 Le dictionnaire contient une variété d'informations sur un extraterrestre, mais il n'a pas de place pour stocker
des informations sur un deuxième extraterrestre, et encore moins un écran plein d'aliens. Comment pouvez-vous gérer une
flotte d'étrangers? Une façon est de faire une liste des extraterrestres dans laquelle chaque extraterrestre est un dictionnaire
d'informations sur cet extraterrestre. Par exemple, le code suivant crée une liste de trois extraterrestres:

extraterrestres.py alien_0 = {'color': 'green', 'points': 5} alien_1 = {'color': 'yellow',


'points': 10} alien_2 = {'color': 'red', 'points': 15 }

u extraterrestres = [extraterrestre_0, extraterrestre_1, extraterrestre_2]

pour les extraterrestres chez les extraterrestres:

imprimer (extraterrestre)

Nous créons d'abord trois dictionnaires, chacun représentant un extraterrestre différent. À u nous regroupons
chacun de ces dictionnaires dans une liste appelée extraterrestres. Enfin, nous parcourons la liste et imprimons chaque
extraterrestre:

{'color': 'green', 'points': 5} {'color': 'yellow', 'points':


10} {'color': 'red', 'points': 15}

Un exemple plus réaliste impliquerait plus de trois extraterrestres avec un code qui génère
automatiquement chaque extraterrestre. Dans l'exemple suivant, nous utilisons gamme() pour créer une flotte de 30
extraterrestres:

# Faites une liste vide pour stocker les extraterrestres. extraterrestres = []

# Faites 30 extraterrestres verts.

u pour alien_number dans la plage (30):


v new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
w aliens.append (new_alien)

# Montrez les 5 premiers extraterrestres:

X pour alien in aliens [: 5]:


imprimer (extraterrestre)

impression("...")

# Montrez combien d'étrangers ont été créés.


y print ("Nombre total d'étrangers:" + str (len (extraterrestres)))

Dictionnaires 109
Cet exemple commence par une liste vide contenant tous les extraterrestres qui seront créés. À u gamme() renvoie
un ensemble de nombres, qui indique simplement à Python combien de fois nous voulons que la boucle se répète.
Chaque fois que la boucle tourne, nous créons un nouvel extraterrestre v puis ajoutez chaque nouvel extraterrestre
à la liste
extraterrestres w. À X nous utilisons une tranche pour imprimer les cinq premiers extraterrestres, puis à y nous imprimons la

longueur de la liste pour prouver que nous avons réellement généré la flotte complète de 30 extraterrestres:

{'speed': 'slow', 'color': 'green', 'points': 5} {'speed': 'slow', 'color': 'green',


'points': 5} {'speed' : 'slow', 'color': 'green', 'points': 5} {'speed': 'slow',
'color': 'green', 'points': 5} {'speed': 'slow' , 'couleur': 'vert', 'points': 5}

...

Nombre total d'étrangers: 30

Ces extraterrestres ont tous les mêmes caractéristiques, mais Python considère chacun comme un objet distinct, ce
qui nous permet de modifier chaque extraterrestre individuellement.
Comment pourriez-vous travailler avec un groupe d'extraterrestres comme celui-ci? Imaginez qu'un aspect d'un jeu ait

des extraterrestres qui changent de couleur et se déplacent plus rapidement à mesure que le jeu progresse. Lorsqu'il est

temps de changer de couleur, nous pouvons utiliser un pour boucle et un si déclaration pour changer la couleur des

extraterrestres. Par exemple, pour changer les trois premiers extraterrestres en extraterrestres jaunes à vitesse moyenne

valant 10 points chacun, nous pourrions faire ceci:

# Faites une liste vide pour stocker les extraterrestres. extraterrestres = []

# Faites 30 extraterrestres verts.

pour alien_number dans la plage (0,30):


new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'} aliens.append (new_alien)

pour alien in aliens [0: 3]:


if alien ['color'] == 'green':
alien ['color'] = 'jaune'
alien ['speed'] = 'moyen'
extraterrestre ['points'] = 10

# Montrez les 5 premiers extraterrestres: pour les


extraterrestres dans les extraterrestres [0: 5]:

imprimer (extraterrestre)

impression("...")

Parce que nous voulons modifier les trois premiers extraterrestres, nous parcourons une tranche qui ne comprend

que les trois premiers extraterrestres. Tous les extraterrestres sont verts maintenant mais ce ne sera pas toujours le cas,

alors nous écrivons un si déclaration pour s'assurer

110 Chapitre 6
nous ne modifions que les extraterrestres verts. Si l'étranger est vert, nous changeons la couleur en ' jaune', la
vitesse à ' moyen', et la valeur en points à dix, comme indiqué dans la sortie suivante:

{'speed': 'medium', 'color': 'yellow', 'points': 10} {'speed': 'medium', 'color':


'yellow', 'points': 10} {'speed' : 'moyen', 'couleur': 'jaune', 'points': 10} {'vitesse':
'lent', 'couleur': 'vert', 'points': 5} {'vitesse': 'lent' , 'couleur': 'vert', 'points': 5}

...

Vous pouvez étendre cette boucle en ajoutant un elif bloc qui transforme les extraterrestres jaunes en extraterrestres
rouges et rapides d'une valeur de 15 points chacun. Sans afficher à nouveau l'ensemble du programme, cette boucle
ressemblerait à ceci:

pour alien in aliens [0: 3]:


if alien ['color'] == 'green':
alien ['color'] = 'jaune'
alien ['speed'] = 'moyen'
extraterrestre ['points'] = 10
elif alien ['color'] == 'jaune':
alien ['color'] = 'rouge'
alien ['speed'] = 'rapide'
extraterrestre ['points'] = 15

Il est courant de stocker un certain nombre de dictionnaires dans une liste lorsque chaque dictionnaire contient de
nombreux types d'informations sur un objet. Par exemple, vous pouvez créer un dictionnaire pour chaque utilisateur d'un
site Web, comme nous l'avons fait dans user.py
à la page 103, et enregistrez les dictionnaires individuels dans une liste appelée utilisateurs. Tous les dictionnaires
de la liste doivent avoir une structure identique pour que vous puissiez parcourir la liste et travailler avec chaque
objet dictionnaire de la même manière.

Une liste dans un dictionnaire

Plutôt que de mettre un dictionnaire dans une liste, il est parfois utile de mettre une liste dans un dictionnaire.
Par exemple, réfléchissez à la manière dont vous pourriez décrire une pizza que quelqu'un commande. Si vous
n'utilisez qu'une liste, tout ce que vous pourriez vraiment stocker est une liste des garnitures de la pizza. Avec
un dictionnaire, une liste de garnitures ne peut être qu'un aspect de la pizza que vous décrivez.

Dans l'exemple suivant, deux types d'informations sont stockées pour chaque pizza: un type de croûte et
une liste de garnitures. La liste des garnitures est une valeur associée à la clé ' garnitures ». Pour utiliser les
éléments de la liste, nous donnons le nom du dictionnaire et la clé ' garnitures », comme nous le ferions pour toute
valeur dans le dictionnaire. Au lieu de renvoyer une seule valeur, nous obtenons une liste de garnitures:

pizza.py # Stockez des informations sur une pizza commandée.


u pizza = {
'croûte': 'épaisse',
'garnitures': ['champignons', 'extra fromage'],}

Dictionnaires 111
# Résumez la commande.
v print ("Vous avez commandé une" + pizza ['crust'] + "-crust pizza" +
"avec les garnitures suivantes:")

w pour garnir les pizzas ['garnitures']:


impression ("\ t" + garniture)

Nous commençons à u avec un dictionnaire contenant des informations sur une pizza commandée.
L'une des clés du dictionnaire est ' croûte', et la valeur associée est la chaîne ' épais'. La clé suivante, ' garnitures
», a une liste comme valeur qui stocke toutes les garnitures demandées. À v nous résumons la commande
avant de construire la pizza. Pour imprimer les garnitures, nous écrivons un pour boucle w. Pour accéder à la
liste des garnitures, nous utilisons la touche ' garnitures », et Python saisit la liste des garnitures du
dictionnaire.

La sortie suivante résume la pizza que nous prévoyons de construire:

Vous avez commandé une pizza à croûte épaisse avec les garnitures suivantes:
champignons

fromage supplémentaire

Vous pouvez imbriquer une liste dans un dictionnaire chaque fois que vous souhaitez que plusieurs
valeurs soient associées à une seule clé dans un dictionnaire. Dans l'exemple précédent des langages de
programmation préférés, si nous devions stocker les réponses de chaque personne dans une liste, les
gens pourraient choisir plus d'une langue préférée. Lorsque nous parcourons le dictionnaire, la valeur
associée à chaque personne serait une liste de langues plutôt qu'une seule langue. Dans le dictionnaire pour
boucle, nous en utilisons une autre pour boucle pour parcourir la liste des langues associées à chaque
personne:

favori_ u favorite_languages = {
languages.py 'jen': ['python', 'ruby'],
'sarah': ['c'],
'edward': ['ruby', 'go'],
'phil': ['python', 'haskell'],
}

v pour le nom, les langues dans favorite_languages.items ():


print ("\ n" + name.title () + "Les langues préférées de" sont: ") pour la langue dans les
w langues:
print ("\ t" + language.title ())

Comme vous pouvez le voir sur u la valeur associée à chaque nom est maintenant une liste. Notez que
certaines personnes ont une langue préférée et d'autres ont plusieurs favoris. Lorsque nous parcourons le
dictionnaire à v, nous utilisons le nom de la variable les langues pour contenir chaque valeur du dictionnaire, car
nous savons que chaque valeur sera une liste. Dans la boucle principale du dictionnaire, nous utilisons

112 Chapitre 6
un autre pour boucle w pour parcourir la liste des langues préférées de chaque personne. Désormais, chaque personne
peut lister autant de langues préférées qu'elle le souhaite:

Les langues préférées de Jen sont:


Python
Rubis

Les langues préférées de Sarah sont:


C

Les langues préférées de Phil sont:


Python
Haskell

Les langues préférées d'Edward sont:


Rubis
Aller

Pour affiner encore plus ce programme, vous pouvez inclure un si déclaration au début
du dictionnaire pour boucle pour voir si chaque personne a plus d'une langue préférée en
examinant la valeur de len (langues).
Si une personne a plus d'un favori, la sortie restera la même. Si la personne n'a qu'une seule
langue préférée, vous pouvez modifier le libellé pour refléter cela. Par exemple, vous pourriez
dire La langue préférée de Sarah est C.

Remarque Vous ne devez pas imbriquer les listes et les dictionnaires trop profondément. Si vous imbriquez des éléments beaucoup
plus profondément que ce que vous voyez dans les exemples précédents ou si vous travaillez avec le code de quelqu'un
d'autre avec des niveaux d'imbrication significatifs, il existe probablement un moyen plus simple de résoudre le problème.

Un dictionnaire dans un dictionnaire

Vous pouvez imbriquer un dictionnaire dans un autre dictionnaire, mais votre code peut se compliquer rapidement
lorsque vous le faites. Par exemple, si vous avez plusieurs utilisateurs pour un site Web, chacun avec un nom
d'utilisateur unique, vous pouvez utiliser les noms d'utilisateur comme clés dans un dictionnaire. Vous pouvez
ensuite stocker des informations sur chaque utilisateur en utilisant un dictionnaire comme valeur associée à leur
nom d'utilisateur. Dans la liste suivante, nous stockons trois informations sur chaque utilisateur: son prénom, son
nom et son emplacement. Nous accèderons à ces informations en parcourant les noms d'utilisateur et le
dictionnaire d'informations associés à chaque nom d'utilisateur:

many_users.py utilisateurs = {

'aeinstein': {
'premier': 'albert',
'dernier': 'einstein',
'emplacement': 'princeton',
},

Dictionnaires 113
'mcurie': {
'premier': 'marie',
'dernier': 'curie',
'emplacement': 'paris',
},

u pour le nom d'utilisateur, user_info dans users.items ():


v print ("\ nUsername:" + username)
w full_name = user_info ['first'] + "" + user_info ['last'] location = user_info ['location']

X print ("\ tNom complet:" + nom_titre.titre ()) print ("\


tLocalisation:" + location.title ())

Nous définissons d'abord un dictionnaire appelé utilisateurs avec deux clés: une pour les noms d'utilisateur ' aeinstein
' et ' mcurie '. La valeur associée à chaque clé est un dictionnaire qui comprend le prénom, le nom et l'emplacement
de chaque utilisateur. À u nous bouclons à travers le utilisateurs dictionnaire. Python stocke chaque clé dans la
variable Nom d'utilisateur, et le dictionnaire associé à chaque nom d'utilisateur entre dans la variable informations
utilisateur. Une fois à l'intérieur de la boucle principale du dictionnaire, nous imprimons le nom d'utilisateur à v.

À w nous commençons à accéder au dictionnaire interne. La variable informations utilisateur,

qui contient le dictionnaire des informations utilisateur, a trois clés: ' premier Dernier', et ' lieu'. Nous utilisons
chaque clé pour générer un nom complet et un emplacement soigneusement formatés pour chaque
personne, puis imprimons un résumé de ce que nous savons de chaque utilisateur. X:

Nom d'utilisateur: aeinstein


Nom complet: Albert Einstein Lieu:
Princeton

Nom d'utilisateur: mcurie

Nom complet: Marie Curie Lieu:


Paris

Notez que la structure du dictionnaire de chaque utilisateur est identique. Bien que non requise par
Python, cette structure facilite l'utilisation des dictionnaires imbriqués. Si le dictionnaire de chaque utilisateur
avait des clés différentes, le code à l'intérieur du
pour boucle serait plus compliquée.

essayez-le vous-même

6-7. Gens: Commencez par le programme que vous avez écrit pour l'exercice 6-1 (page 102). Créez deux nouveaux

dictionnaires représentant des personnes différentes et stockez les trois dictionnaires dans une liste appelée gens . Parcourez

votre liste de personnes. Au fur et à mesure que vous parcourez la liste, imprimez tout ce que vous savez sur chaque

personne.

114 Chapitre 6
6-8. Animaux domestiques: Faites plusieurs dictionnaires, où le nom de chaque dictionnaire est le nom d'un animal de

compagnie. Dans chaque dictionnaire, indiquez le type d'animal et le nom du propriétaire. Stockez ces dictionnaires dans

une liste appelée animaux domestiques . Ensuite, parcourez votre liste et imprimez tout ce que vous savez sur chaque

animal.

6-9. Lieux préférés: Créer un dictionnaire appelé Lieux préférés . Pensez à trois noms à utiliser comme clés

dans le dictionnaire et enregistrez un à trois endroits préférés pour chaque personne. Pour rendre cet exercice

un peu plus intéressant, demandez à des amis de citer quelques-uns de leurs endroits préférés. Parcourez le

dictionnaire et imprimez le nom de chaque personne et ses lieux préférés.

6-10. Numéros préférés: Modifiez votre programme à partir de l'exercice 6-2 (page 102) afin que chaque personne

puisse avoir plus d'un numéro favori. Ensuite, imprimez le nom de chaque personne avec ses numéros préférés.

6-11. Villes: Créer un dictionnaire appelé villes . Utilisez les noms de trois villes comme clés dans votre

dictionnaire. Créez un dictionnaire d'informations sur chaque ville et incluez le pays dans lequel se trouve la

ville, sa population approximative et un fait sur cette ville. Les clés du dictionnaire de chaque ville devraient être

quelque chose comme

pays, population, et fait . Imprimez le nom de chaque ville et toutes les informations que vous avez stockées
à son sujet.

6-12. Extensions: Nous travaillons maintenant avec des exemples suffisamment complexes pour pouvoir
être étendus de plusieurs façons. Utilisez l'un des programmes d'exemple de ce chapitre et étendez-le en
ajoutant de nouvelles clés et valeurs, en modifiant le contexte du programme ou en améliorant le
formatage de la sortie.

résumé
Dans ce chapitre, vous avez appris à définir un dictionnaire et à utiliser les informations stockées dans un
dictionnaire. Vous avez appris à accéder et à modifier des éléments individuels dans un dictionnaire et à
parcourir en boucle toutes les informations d'un dictionnaire. Vous avez appris à parcourir les paires clé-valeur
d'un dictionnaire, ses clés et ses valeurs. Vous avez également appris à imbriquer plusieurs dictionnaires dans
une liste, à imbriquer des listes dans un dictionnaire et à imbriquer un dictionnaire dans un dictionnaire.

Dans le chapitre suivant, vous en apprendrez plus sur tandis que boucles et comment accepter les
commentaires des personnes qui utilisent vos programmes. Ce sera un chapitre passionnant, car vous
apprendrez à rendre tous vos programmes interactifs: ils pourront répondre aux entrées des utilisateurs.

Dictionnaires 115
7
entrée utilisateur et recherche

La plupart des programmes sont écrits pour résoudre le


problème d'un utilisateur final. Pour ce faire, vous devez généralement
obtenir des informations de l'utilisateur. Pour un exemple simple,
disons que quelqu'un veut savoir s'il est assez vieux pour voter. Si vous
écrivez un
programme pour répondre à cette question, vous devez connaître l'âge de l'utilisateur avant de pouvoir fournir
une réponse. Le programme devra demander à l'utilisateur d'entrer, ou saisir, leur age; une fois que le
programme a cette entrée, il peut la comparer à l'âge de vote pour déterminer si l'utilisateur est assez âgé,
puis rapporter le résultat.
Dans ce chapitre, vous apprendrez comment accepter les entrées de l'utilisateur afin que votre programme puisse
ensuite fonctionner avec. Lorsque votre programme a besoin d'un nom, vous serez en mesure de demander un nom à
l'utilisateur. Lorsque votre programme a besoin d'une liste de noms, vous pourrez inviter l'utilisateur à saisir une série de
noms. Pour ce faire, vous utiliserez le saisir() fonction.

Vous apprendrez également comment faire fonctionner les programmes aussi longtemps que les utilisateurs le

souhaitent, afin qu'ils puissent entrer autant d'informations qu'ils en ont besoin; ensuite, votre programme peut travailler

avec ces informations. Vous utiliserez Python tandis que loop pour maintenir les programmes en cours d'exécution tant que

certaines conditions restent vraies.


Avec la possibilité de travailler avec les entrées de l'utilisateur et la capacité de contrôler la durée d'exécution de

vos programmes, vous serez en mesure d'écrire des programmes entièrement interactifs.

comment fonctionne la fonction input ()

Le saisir() La fonction met votre programme en pause et attend que l'utilisateur entre du texte. Une
fois que Python reçoit l'entrée de l'utilisateur, il la stocke dans une variable pour vous faciliter le
travail.
Par exemple, le programme suivant demande à l'utilisateur de saisir du texte, puis
affiche ce message à l'utilisateur:

parrot.py message = input ("Dites-moi quelque chose et je vous le répéterai:") print (message)

Le saisir() fonction prend un argument: la rapide, ou des instructions, que nous voulons afficher
à l'utilisateur afin qu'il sache quoi faire. Dans cet exemple, lorsque Python exécute la première ligne,
l'utilisateur voit l'invite Dites-moi quelque chose, et je vous le répète:. Le programme attend pendant que
l'utilisateur entre sa réponse et continue après que l'utilisateur appuie sur Entrer. La réponse est
stockée dans la variable un message, alors imprimer (message) affiche l'entrée à l'utilisateur:

Dites-moi quelque chose et je vous le répète: Bonjour à tous!


Bonjour à tous!

Remarque Sublime Text n'exécute pas les programmes qui invitent l'utilisateur à entrer. Vous pouvez utiliser Sublime Text pour écrire
des programmes qui invitent à entrer, mais vous devrez exécuter ces programmes à partir d'un terminal. Voir «Exécution de
programmes Python à partir d'un terminal» à la page 16.

Ecrire des invites claires

Chaque fois que vous utilisez le saisir() , vous devez inclure une invite claire et facile à suivre qui indique à
l'utilisateur exactement le type d'informations que vous recherchez. Toute instruction indiquant à l'utilisateur
ce qu'il doit saisir devrait fonctionner. Par exemple:

greeter.py name = input ("Veuillez entrer votre nom:") print ("Bonjour,"


+ nom + "!")

Ajoutez un espace à la fin de vos invites (après les deux points dans l'exemple précédent)
pour séparer l'invite de la réponse de l'utilisateur et indiquer clairement à votre utilisateur où saisir
son texte. Par exemple:

S'il vous plaît entrez votre nom: Eric


Bonjour Eric!

Parfois, vous voudrez écrire une invite de plus d'une ligne. Par exemple, vous voudrez peut-être
dire à l'utilisateur pourquoi vous demandez certaines entrées.

118 Chapitre 7
Vous pouvez stocker votre invite dans une variable et la transmettre au saisir()
fonction. Cela vous permet de construire votre invite sur plusieurs lignes, puis d'écrire un clean saisir() déclaration.

greeter.py prompt = "Si vous nous dites qui vous êtes, nous pouvons personnaliser les messages que vous voyez." prompt + = "\
nQuel est votre prénom?"

nom = entrée (invite)


print ("\ nBonjour," + nom + "!")

Cet exemple montre une façon de créer une chaîne multiligne. La première ligne stocke la
première partie du message dans la variable rapide. Dans la deuxième ligne, l'opérateur + = prend la
chaîne qui a été stockée dans rapide et ajoute la nouvelle chaîne à la fin.

L'invite s'étend maintenant sur deux lignes, toujours avec un espace après le point d'interrogation pour plus de

clarté:

Si vous nous dites qui vous êtes, nous pouvons personnaliser les messages que vous voyez. Quel est votre
prénom? Eric

Bonjour Eric!

Utilisation de int () pour accepter une entrée numérique

Lorsque vous utilisez le saisir() fonction, Python interprète tout ce que l'utilisateur entre comme une chaîne.
Considérez la session d'interprétation suivante, qui demande l'âge de l'utilisateur:

>>> age = input ("Quel âge avez-vous?")


Quel âge as-tu? 21
>>> âge
«21»

L'utilisateur entre le nombre 21, mais quand on demande à Python la valeur de


âge, il retourne ' 21 ', la représentation sous forme de chaîne de la valeur numérique saisie. Nous savons que Python a
interprété l'entrée comme une chaîne car le nombre est maintenant entre guillemets. Si tout ce que vous voulez faire est
d'imprimer l'entrée, cela fonctionne bien. Mais si vous essayez d'utiliser l'entrée comme un nombre, vous obtiendrez une
erreur:

>>> age = input ("Quel âge avez-vous?")


Quel âge as-tu? 21
u >>> âge> = 18
Traceback (dernier appel le plus récent):
Fichier "<stdin>", ligne 1, dans <module>
v TypeError: types non ordonnables: str ()> = int ()

Lorsque vous essayez d'utiliser l'entrée pour effectuer une comparaison numérique u, Python produit une
erreur car il ne peut pas comparer une chaîne à un entier: la chaîne
«21» qui est stocké dans âge ne peut pas être comparé à la valeur numérique 18 v.

Entrée utilisateur et boucles while 119


Nous pouvons résoudre ce problème en utilisant le int () , qui indique à Python de traiter l'entrée
comme une valeur numérique. Le int () La fonction convertit une représentation sous forme de chaîne d'un
nombre en une représentation numérique, comme illustré ici:

>>> age = input ("Quel âge avez-vous?")


Quel âge as-tu? 21
u >>> age = int (âge)
>>> âge> = 18
Vrai

Dans cet exemple, lorsque nous entrons 21 à l'invite, Python interprète le nombre comme une chaîne,
mais la valeur est ensuite convertie en une représentation numérique par int () u. Maintenant, Python peut
exécuter le test conditionnel: il compare âge
(qui contient maintenant la valeur numérique 21) et 18 Pour voir si âge est supérieur ou égal à
18. Ce test évalue à Vrai.
Comment utilisez-vous le int () fonctionner dans un programme réel? Considérez un programme qui
détermine si les gens sont assez grands pour faire des montagnes russes:

rollercoaster.py height = input ("Quelle est votre taille, en pouces?") height = int
(height)

si hauteur> = 36:
print ("\ nTu es assez grand pour rouler!") sinon:

print ("\ nVous pourrez rouler quand vous serez un peu plus âgé.")

Le programme peut comparer la taille à 36 car height = int (hauteur)


convertit la valeur d'entrée en une représentation numérique avant que la comparaison ne soit effectuée. Si
le nombre saisi est supérieur ou égal à 36, nous disons à l'utilisateur qu'il est suffisamment grand:

Quelle est votre taille, en pouces? 71

Vous êtes assez grand pour rouler!

Lorsque vous utilisez une entrée numérique pour effectuer des calculs et des comparaisons, assurez-vous de
convertir d'abord la valeur d'entrée en une représentation numérique.

L'opérateur Modulo
Un outil utile pour travailler avec des informations numériques est le opérateur modulo (%),
qui divise un nombre par un autre nombre et renvoie le reste:

>>> 4% 3
1
>>> 5% 3
2
>>> 6% 3
0

120 Chapitre 7
>>> 7% 3
1

L'opérateur modulo ne vous dit pas combien de fois un nombre s'insère dans un autre; il
vous dit simplement quel est le reste.
Lorsqu'un nombre est divisible par un autre nombre, le reste est 0, donc l'opérateur modulo
renvoie toujours 0. Vous pouvez utiliser ce fait pour déterminer si un nombre est pair ou impair:

even_or_odd.py number = input ("Entrez un nombre, et je vous dirai s'il est pair ou impair:") number = int (number)

si numéro% 2 == 0:
print ("\ nLe nombre" + str (nombre) + "est pair.") sinon:

print ("\ nLe nombre" + str (nombre) + "est impair.")

Les nombres pairs sont toujours divisibles par deux, donc si le modulo d'un nombre et de deux
est nul (ici, si nombre% 2 == 0) le nombre est pair. Sinon, c'est bizarre.

Entrez un nombre et je vous dirai s'il est pair ou impair: 42

Le nombre 42 est pair.

Accepter l'entrée dans Python 2.7

Si vous utilisez Python 2.7, vous devez utiliser le entrée brute() fonction lors de l'invitation à saisir l'utilisateur.
Cette fonction interprète toutes les entrées comme une chaîne, tout comme saisir() fait en Python 3.

Python 2.7 a un saisir() fonction également, mais cette fonction interprète l'entrée de l'utilisateur comme du
code Python et tente d'exécuter l'entrée. Au mieux, vous obtiendrez une erreur indiquant que Python ne comprend
pas l'entrée; au pire, vous exécuterez du code que vous n'aviez pas l'intention d'exécuter. Si vous utilisez Python
2.7, utilisez entrée brute()
au lieu de saisir().

essayez-le vous-même

7-1. Voiture de location: Écrivez un programme qui demande à l'utilisateur quel type de voiture de location il souhaite. Imprimez

un message à propos de cette voiture, tel que "Voyons si je peux vous trouver une Subaru."

7-2. Sièges du restaurant: Écrivez un programme qui demande à l'utilisateur combien de personnes sont dans son

groupe de dîner. Si la réponse est supérieure à huit, imprimez un message indiquant qu'ils devront attendre une

table. Sinon, signalez que leur table est prête.

7-3. Multiples de dix: Demandez à l'utilisateur un nombre, puis indiquez si le nombre est un multiple
de 10 ou non.

Entrée utilisateur et boucles while 121


Présentation des boucles while

Le pour loop prend une collection d'éléments et exécute un bloc de code une fois pour chaque élément de la collection.
En revanche, le tandis que la boucle s'exécute aussi longtemps que, ou tandis que, une certaine condition est vraie.

La boucle while en action

Vous pouvez utiliser un tandis que boucle pour compter à travers une série de nombres. Par exemple, ce
qui suit tandis que boucle compte de 1 à 5:

counting.py numéro_actuel = 1
tandis que numéro_actuel <= 5:
print (numéro_actuel)
numéro_actuel + = 1

Dans la première ligne, nous commençons à compter à partir de 1 en définissant la valeur de

Numéro actuel à 1. Le tandis que loop est alors configuré pour continuer à fonctionner tant que la valeur
de Numéro actuel est inférieur ou égal à 5. Le code à l'intérieur de la boucle imprime la valeur de Numéro
actuel puis ajoute 1 à cette valeur
avec numéro_actuel + = 1. ( L'opérateur + = est un raccourci pour numéro_actuel = numéro_actuel + 1.)

Python répète la boucle aussi longtemps que la condition numéro_actuel <= 5


est vrai. Parce que 1 est inférieur à 5, Python imprime 1 puis ajoute 1, rendant le nombre actuel
2. Parce que 2 est inférieur à 5, Python imprime 2
et ajoute 1 à nouveau, ce qui rend le nombre actuel 3, etc. Une fois la valeur de Numéro
actuel est supérieur à 5, la boucle s'arrête et le programme se termine:

1
2
3
4
5

Les programmes que vous utilisez tous les jours contiennent probablement tandis que boucles. Par exemple, un

jeu a besoin d'un tandis que loop pour continuer à fonctionner aussi longtemps que vous voulez continuer à jouer, et ainsi

il peut s'arrêter de fonctionner dès que vous lui demandez de quitter. Les programmes ne seraient pas amusants à

utiliser s’ils s’arrêtaient avant que nous leur disions de le faire ou s’ils continuaient à fonctionner même après que nous

voulions quitter, alors tandis que les boucles sont très utiles.

Laisser l'utilisateur choisir quand quitter

Nous pouvons faire le parrot.py le programme s'exécute aussi longtemps que l'utilisateur le souhaite en plaçant la majeure

partie du programme dans un tandis que boucle. Nous définirons un quitter la valeur puis maintenez le programme en cours

d'exécution tant que l'utilisateur n'a pas entré la valeur de sortie:

parrot.py u prompt = "\ nDites-moi quelque chose et je vous le répéterai:"


prompt + = "\ nEntrez 'quit' pour terminer le programme."

122 Chapitre 7
v message = ""
w while message! = 'quitter':
message = entrée (invite)
imprimer (message)

À u, nous définissons une invite qui indique à l'utilisateur ses deux options: entrer un message ou entrer la
valeur de quitter (dans ce cas, ' quitter'). Ensuite, nous configurons une variable un message v pour stocker la valeur
saisie par l'utilisateur. Nous définissons
un message comme une chaîne vide, "", donc Python a quelque chose à vérifier la première fois qu'il atteint le tandis
que ligne. La première fois que le programme s'exécute et que Python atteint le tandis que déclaration, il doit
comparer la valeur de un message à
'quitter', mais aucune entrée utilisateur n'a encore été saisie. Si Python n'a rien à comparer, il ne pourra pas
continuer à exécuter le programme. Pour résoudre ce problème, nous nous assurons de donner un message une
valeur initiale. Bien qu'il ne s'agisse que d'une chaîne vide, cela aura du sens pour Python et lui permettra
d'effectuer la comparaison qui rend le tandis que travail en boucle. Ce tandis que boucle w s'exécute aussi longtemps
que la valeur de un message n'est pas ' quitter'.

La première fois dans la boucle, un message est juste une chaîne vide, donc Python entre dans la
boucle. À message = entrée (invite), Python affiche l'invite et attend que l'utilisateur entre son entrée. Tout ce
qu'ils entrent est stocké dans un message
et imprimé; puis, Python réévalue la condition dans le tandis que déclaration. Tant que
l'utilisateur n'a pas saisi le mot ' quitter', l'invite s'affiche à nouveau et Python attend d'autres
entrées. Quand l'utilisateur entre enfin ' quitter',
Python arrête d'exécuter le tandis que boucle et le programme se termine:

Dites-moi quelque chose, et je vous le répète: entrez «quit» pour terminer le


programme. Bonjour à tous!
Bonjour à tous!

Dites-moi quelque chose, et je vous le répète: entrez «quit» pour terminer le


programme. Bonjour encore.
Bonjour encore.

Dites-moi quelque chose, et je vous le répète: entrez «quit» pour terminer le


programme. quitter
quitter

Ce programme fonctionne bien, sauf qu'il imprime le mot ' quitter' comme s'il s'agissait d'un
message réel. Un simple si test corrige ceci:

prompt = "\ nDites-moi quelque chose, et je vous le répéterai:" prompt + = "\ nEntrez 'quit' pour
terminer le programme."

message = ""
while message! = 'quitter':
message = entrée (invite)

if message! = 'quitter':
imprimer (message)

Entrée utilisateur et boucles while 123


Maintenant, le programme effectue une vérification rapide avant d'afficher le message et n'imprime le
message que s'il ne correspond pas à la valeur de fermeture:

Dites-moi quelque chose, et je vous le répète: entrez «quit» pour terminer le


programme. Bonjour à tous!
Bonjour à tous!

Dites-moi quelque chose, et je vous le répète: entrez «quit» pour terminer le


programme. Bonjour encore.
Bonjour encore.

Dites-moi quelque chose, et je vous le répète: entrez «quit» pour terminer le


programme. quitter

Utiliser un drapeau

Dans l'exemple précédent, nous avons demandé au programme d'effectuer certaines tâches alors qu'une condition
donnée était vraie. Mais qu'en est-il des programmes plus compliqués dans lesquels de nombreux événements
différents pourraient entraîner l'arrêt du programme?
Par exemple, dans un jeu, plusieurs événements différents peuvent mettre fin au jeu. Lorsque le joueur
est à court de navires, que son temps est écoulé ou que les villes qu'il était censé protéger sont toutes
détruites, le jeu doit se terminer. Il doit prendre fin si l'un de ces événements se produit. Si de nombreux
événements peuvent se produire pour arrêter le programme, essayez de tester toutes ces conditions en un tandis
que

la déclaration devient compliquée et difficile.


Pour un programme qui ne doit s'exécuter que tant que de nombreuses conditions sont vraies, vous pouvez
définir une variable qui détermine si le programme entier est actif ou non. Cette variable, appelée a drapeau, agit comme
un signal pour le programme. Nous pouvons écrire nos programmes pour qu'ils s'exécutent alors que l'indicateur est
défini sur Vrai et arrêtez de fonctionner lorsque l'un des nombreux événements définit la valeur de l'indicateur sur Faux. En
conséquence, notre tandis que l'instruction n'a besoin de vérifier qu'une seule condition: si le drapeau est actuellement Vrai.
Ensuite, tous nos autres tests (pour voir si un événement s'est produit qui devrait définir le drapeau sur Faux) peuvent
être soigneusement organisés dans le reste du programme.

Ajoutons un drapeau à parrot.py de la section précédente. Ce drapeau, que nous appellerons actif ( bien
que vous puissiez l'appeler n'importe quoi), surveillera si le programme doit continuer à fonctionner ou
non:

prompt = "\ nDites-moi quelque chose, et je vous le répéterai:" prompt + = "\ nEntrez 'quit' pour
terminer le programme."

u active = Vrai
v pendant qu'il est actif:

message = entrée (invite)

w si message == 'quitter':
active = Faux
X autre:
imprimer (message)

124 Chapitre 7
Nous définissons la variable actif à Vrai u donc le programme démarre dans un état actif. Cela rend le tandis
que instruction plus simple car aucune comparaison n'est faite dans le tandis que déclaration elle-même; la
logique est prise en compte dans d'autres parties du programme. Tant que le actif la variable reste Vrai, la
boucle continuera à fonctionner v.

Dans le si déclaration à l'intérieur du tandis que boucle, nous vérifions la valeur de un message

une fois que l'utilisateur a entré son entrée. Si l'utilisateur entre ' quitter' w, nous fixons actif
à Faux, et le tandis que la boucle s'arrête. Si l'utilisateur entre autre chose que
'quitter' X, nous imprimons leur entrée sous forme de message.

Ce programme a la même sortie que l'exemple précédent où nous avons placé le test conditionnel
directement dans le tandis que déclaration. Mais maintenant que nous avons un indicateur pour indiquer si le
programme global est dans un état actif, il serait facile d'ajouter plus de tests (tels que elif instructions) pour
les événements qui devraient provoquer actif devenir Faux. Ceci est utile dans les programmes compliqués
comme les jeux dans lesquels il peut y avoir de nombreux événements qui devraient chacun arrêter le
programme. Lorsque l'un de ces événements fait que l'indicateur actif devient Faux, la boucle de jeu principale
se terminera, un Jeu terminé Le message peut être affiché et le joueur peut avoir la possibilité de jouer à
nouveau.

Utiliser break pour quitter une boucle

Pour quitter un tandis que boucle immédiatement sans exécuter le code restant dans la boucle, quels que soient les
résultats de tout test conditionnel, utilisez le Pause déclaration. Le Pause instruction dirige le flux de votre programme;
vous pouvez l'utiliser pour contrôler quelles lignes de code sont exécutées et lesquelles ne le sont pas, de sorte
que le programme n'exécute que le code que vous voulez, quand vous le souhaitez.

Par exemple, considérons un programme qui interroge l'utilisateur sur les lieux qu'il a visités. Nous pouvons
arrêter le tandis que boucle dans ce programme en appelant Pause dès que l'utilisateur entre dans le ' quitter' évaluer:

cities.py prompt = "\ nVeuillez entrer le nom d'une ville que vous avez visitée:" prompt + = "\ n (Entrez
'quit' lorsque vous avez terminé.)"

u tandis que Vrai:


ville = entrée (invite)

si ville == 'quitter':
Pause
autre:
print ("J'adorerais aller à" + city.title () + "!")

Une boucle qui commence par tandis que Vrai u fonctionnera pour toujours à moins qu'il n'atteigne un

Pause déclaration. La boucle de ce programme continue de demander à l'utilisateur d'entrer les noms des villes
où il s'est rendu jusqu'à ce qu'il entre ' quitter'. Quand ils entrent
'quitter', le Pause l'instruction s'exécute, ce qui oblige Python à quitter la boucle:

Veuillez entrer le nom d'une ville que vous avez visitée: (Entrez «quitter»
lorsque vous avez terminé.) New York
J'adorerais aller à New York!

Entrée utilisateur et boucles while 125


Veuillez entrer le nom d'une ville que vous avez visitée: (Entrez «quitter»
lorsque vous avez terminé.) San Francisco
J'adorerais aller à San Francisco!

Veuillez entrer le nom d'une ville que vous avez visitée: (Entrez «quitter»
lorsque vous avez terminé.) quitter

Remarque Vous pouvez utiliser le Pause déclaration dans l'une des boucles de Python. Par exemple, vous pouvez utiliser
Pause quitter un pour boucle qui fonctionne à travers une liste ou un dictionnaire.

Utilisation de continuer dans une boucle

Plutôt que de sortir complètement d'une boucle sans exécuter le reste de son code, vous pouvez
utiliser le Continuez pour revenir au début de la boucle en fonction du résultat d'un test conditionnel.
Par exemple, considérons une boucle qui compte de 1 à 10 mais n'imprime que les nombres impairs
dans cette plage:

counting.py numéro_actuel = 0
tandis que numéro_actuel <10:
u numéro_actuel + = 1
si numéro_actuel% 2 == 0:
Continuez

print (numéro_actuel)

D'abord nous définissons Numéro actuel à 0. Comme il est inférieur à 10, Python entre dans le tandis que boucle.
Une fois à l'intérieur de la boucle, on incrémente le décompte de 1 à u, alors Numéro actuel est 1. Le si instruction
vérifie ensuite le modulo de
Numéro actuel et2. Si le modulo est 0 (ce qui signifie Numéro actuel est divisible par 2), le Continuez
L'instruction indique à Python d'ignorer le reste de la boucle et de revenir au début. Si le
nombre actuel n'est pas divisible par 2, le reste de la boucle est exécuté et Python imprime
le nombre actuel:

1
3
5
7
9

Éviter les boucles infinies

Chaque tandis que loop a besoin d'un moyen d'arrêter de fonctionner pour ne pas continuer à fonctionner indéfiniment. Par
exemple, cette boucle de comptage doit compter de 1 à 5:

counting.py x=1
tandis que x <= 5:
imprimer (x)

x+=1

126 Chapitre 7
Mais si vous omettez accidentellement la ligne x + = 1 ( comme indiqué ci-dessous), la boucle fonctionnera pour

toujours:

# Cette boucle tourne pour toujours! x = 1

tandis que x <= 5:


imprimer (x)

Maintenant la valeur de X commencera à 1 mais ne changez jamais. En conséquence, le test conditionnel x <=
5 évaluera toujours à Vrai et le tandis que loop fonctionnera pour toujours, imprimant une série de 1, comme ceci:

1
1
1
1
- - couper--

Chaque programmeur écrit accidentellement une infinité tandis que boucle de temps en temps, en particulier
lorsque les boucles d'un programme ont des conditions de sortie subtiles. Si votre programme reste bloqué dans une
boucle infinie, appuyez sur ctrl- C ou fermez simplement la fenêtre du terminal affichant la sortie de votre programme.

Pour éviter d'écrire des boucles infinies, testez chaque tandis que loop et assurez-vous que la boucle s'arrête
lorsque vous vous y attendez. Si vous souhaitez que votre programme se termine lorsque l'utilisateur entre une
certaine valeur d'entrée, exécutez le programme et entrez cette valeur. Si le programme ne se termine pas,
examinez la manière dont votre programme gère la valeur qui devrait provoquer la fermeture de la boucle.
Assurez-vous qu'au moins une partie du programme peut rendre l'état de la boucle Faux ou l'amener à atteindre un Pause
déclaration.

Remarque Certains éditeurs, tels que Sublime Text, ont une fenêtre de sortie intégrée. Cela peut rendre difficile l'arrêt
d'une boucle infinie et vous devrez peut-être fermer l'éditeur pour terminer la boucle.

essayez-le vous-même

7-4. Garnitures de pizza: Écrivez une boucle qui invite l'utilisateur à entrer une série de garnitures de pizza jusqu'à ce qu'il

entre un ' quitter' évaluer . Au fur et à mesure qu'ils entrent dans chaque garniture, imprimez un message disant que vous

ajouterez cette garniture à leur pizza.

7-5. Tickets de film: Une salle de cinéma facture des prix de billets différents en fonction de l'âge d'une personne.

Si une personne a moins de 3 ans, le billet est gratuit; s'ils ont entre 3 et 12, le billet est de 10 $; et s'ils ont plus

de 12 ans, le billet coûte 15 $. Écrivez une boucle dans laquelle vous demandez aux utilisateurs leur âge, puis

dites-leur le coût de leur billet de cinéma.

(a continué)

Entrée utilisateur et boucles while 127


7-6. Trois sorties: Écrivez différentes versions de l'exercice 7-4 ou de l'exercice 7-5 qui exécutent chacune des opérations

suivantes au moins une fois:

• Utilisez un test conditionnel dans le tandis que instruction pour arrêter la boucle.

• Utilisez un actif variable pour contrôler la durée de la boucle.

• Utiliser un Pause instruction pour quitter la boucle lorsque l'utilisateur entre un ' quitter' évaluer .

7-7. Infini: Écrivez une boucle qui ne se termine jamais et exécutez-la. (Pour terminer la boucle, appuyez sur

ctrl- C ou fermez la fenêtre affichant la sortie.)

en utilisant une boucle while avec des listes et des dictionnaires

Jusqu'à présent, nous n'avons travaillé qu'avec une seule information utilisateur à la fois. Nous avons reçu l'entrée de
l'utilisateur, puis nous avons imprimé l'entrée ou une réponse à celle-ci. La prochaine fois à travers le tandis que boucle,
nous recevrions une autre valeur d'entrée et y répondrions. Mais pour garder une trace de nombreux utilisateurs et
éléments d'information, nous devrons utiliser des listes et des dictionnaires avec notre tandis que boucles.

UNE pour loop est efficace pour parcourir une liste, mais vous ne devez pas modifier une liste à l'intérieur d'un pour boucle
car Python aura du mal à suivre les éléments de la liste. Pour modifier une liste au fur et à mesure que vous la parcourez,
utilisez un tandis que boucle. Utilisant tandis que Les boucles avec des listes et des dictionnaires vous permettent de collecter,
stocker et organiser un grand nombre d'entrées à examiner et à faire rapport plus tard.

Déplacement d'éléments d'une liste à une autre

Considérez une liste d'utilisateurs nouvellement enregistrés mais non vérifiés d'un site Web. Après avoir vérifié ces

utilisateurs, comment pouvons-nous les déplacer vers une liste distincte d'utilisateurs confirmés? Une façon serait d'utiliser un tandis
que boucle pour extraire les utilisateurs de la liste des utilisateurs non confirmés au fur et à mesure que nous les vérifions,

puis les ajouter à une liste distincte d'utilisateurs confirmés. Voici à quoi pourrait ressembler ce code:

confirmé_ # Commencez par les utilisateurs qui doivent être vérifiés,


users.py # et une liste vide pour contenir les utilisateurs confirmés.
u unconfirmed_users = ['alice', 'brian', 'candace']
Confirmé_users = []

# Vérifiez chaque utilisateur jusqu'à ce qu'il n'y ait plus d'utilisateurs non confirmés.
# Déplacez chaque utilisateur vérifié dans la liste des utilisateurs confirmés.
v pendant unconfirmed_users:
w current_user = unconfirmed_users.pop ()

print ("Vérification de l'utilisateur:" + utilisateur_actuel.title ())


X confirmé_users.append (utilisateur_actuel)

128 Chapitre 7
# Afficher tous les utilisateurs confirmés.
print ("\ nLes utilisateurs suivants ont été confirmés:") pour Confirm_user
dans Confirmé_users:
imprimer (confirmé_user.title ())

Nous commençons par une liste d'utilisateurs non confirmés à l'adresse u ( Alice, Brian et Candace) et une liste
vide pour contenir les utilisateurs confirmés. Le tandis que boucle à v
s'exécute aussi longtemps que la liste unconfirmed_users n'est pas vide. Dans cette boucle, le
pop() fonction à w supprime les utilisateurs non vérifiés un par un à partir de la fin de
unconfirmed_users. Ici, parce que Candace est la dernière unconfirmed_users liste, son nom sera le
premier à être supprimé, stocké dans utilisateur actuel, et ajouté au confirmés_users liste à X. Vient
ensuite Brian, puis Alice.
Nous simulons la confirmation de chaque utilisateur en imprimant un message de vérification puis en les ajoutant
à la liste des utilisateurs confirmés. Au fur et à mesure que la liste des utilisateurs non confirmés se réduit, la liste des
utilisateurs confirmés s'allonge. Lorsque la liste des utilisateurs non confirmés est vide, la boucle s'arrête et la liste des
utilisateurs confirmés est imprimée:

Vérification de l'utilisateur: Candace

Vérification de l'utilisateur: Brian

Vérification de l'utilisateur: Alice

Les utilisateurs suivants ont été confirmés: Candace

Brian
Alice

Suppression de toutes les instances de valeurs spécifiques d'une liste

Au chapitre 3, nous avons utilisé supprimer() pour supprimer une valeur spécifique d'une liste. Le

supprimer() fonction a fonctionné parce que la valeur qui nous intéressait n'apparaissait qu'une seule fois dans la liste. Mais
que se passe-t-il si vous souhaitez supprimer toutes les instances d'une valeur d'une liste?

Disons que vous avez une liste d'animaux avec la valeur " chat' répété plusieurs fois. Pour supprimer toutes les

instances de cette valeur, vous pouvez exécuter un tandis que boucle jusqu'à ce que ' chat' n'est plus dans la liste, comme

indiqué ici:

pets.py pets = ['chien', 'chat', 'chien', 'poisson rouge', 'chat', 'lapin', 'chat'] imprimer (animaux de compagnie)

tandis que `` chat '' chez les animaux:

pets.remove ('chat')

imprimer (animaux de compagnie)

Nous commençons par une liste contenant plusieurs instances de ' chat'. Après avoir imprimé la liste, Python
entre dans le tandis que boucle car il trouve la valeur ' chat' dans la liste

Entrée utilisateur et boucles while 129


au moins une fois. Une fois à l'intérieur de la boucle, Python supprime la première instance de ' chat',
retourne au tandis que ligne, puis rentre dans la boucle quand il trouve que ' chat' est toujours dans la liste. Il
supprime chaque instance de ' chat' jusqu'à ce que la valeur ne soit plus dans la liste, point auquel Python quitte
la boucle et imprime à nouveau la liste:

['chien', 'chat', 'chien', 'poisson rouge', 'chat', 'lapin', 'chat'] ['chien', 'chien', 'poisson
rouge', 'lapin']

Remplir un dictionnaire avec une entrée utilisateur

Vous pouvez demander autant d'entrée que nécessaire à chaque passage à travers un tandis que
boucle. Créons un programme d'interrogation dans lequel chaque passage dans la boucle demande le nom et
la réponse du participant. Nous allons stocker les données que nous recueillons dans un dictionnaire, car nous
voulons connecter chaque réponse à un utilisateur particulier:

montagne_ réponses = {}
poll.py
# Définissez un indicateur pour indiquer que l'interrogation est active.
polling_active = Vrai

pendant polling_active:
# Demander le nom et la réponse de la personne. name = input ("\
nQuel est votre nom?")
u
response = input ("Quelle montagne aimeriez-vous gravir un jour?")

# Stockez la réponse dans le dictionnaire: answers [nom] =


réponse
v

# Découvrez si quelqu'un d'autre va participer au sondage.


w repeat = input ("Souhaitez-vous laisser une autre personne répondre? (oui / non)") if repeat == 'no':

polling_active = Faux

# L'interrogation est terminée. Montrez les résultats. print ("\ n ---


Résultats du sondage ---")

X pour nom, réponse dans answers.items ():


print (nom + "aimerait monter" + réponse + ".")

Le programme définit d'abord un dictionnaire vide ( réponses) et définit un drapeau ( polling_active) pour
indiquer que l'interrogation est active. Aussi longtemps que polling_active est
Vrai, Python exécutera le code dans le tandis que boucle.
Dans la boucle, l'utilisateur est invité à entrer son nom d'utilisateur et une montagne qu'il aimerait
gravir u. Ces informations sont stockées dans le réponses
dictionnaire v, et l'utilisateur est invité à maintenir ou non le sondage en cours d'exécution w. S'ils entrent Oui, le
programme entre dans le tandis que boucle à nouveau. S'ils entrent non, le polling_active l'indicateur est défini sur Faux,
le tandis que boucle s'arrête de fonctionner et le bloc de code final à X affiche les résultats du sondage.

130 Chapitre 7
Si vous exécutez ce programme et entrez des exemples de réponses, vous devriez voir une sortie comme

celle-ci:

Quel est ton nom? Eric


Quelle montagne aimeriez-vous escalader un jour? Denali
Souhaitez-vous laisser une autre personne répondre? (Oui Non) Oui

Quel est ton nom? Lynn


Quelle montagne aimeriez-vous escalader un jour? Le pouce du diable
Souhaitez-vous laisser une autre personne répondre? (Oui Non) non

- - - Résultats du sondage ---

Lynn aimerait grimper au Devil's Thumb. Eric aimerait


gravir Denali.

essayez-le vous-même

7-8. Épicerie: Faire une liste appelée sandwich_orders et remplissez-le avec les noms de divers sandwichs. Ensuite,

créez une liste vide appelée finis_sandwiches. Parcourez la liste des commandes sandwich et imprimez un

message pour chaque commande, tel que J'ai fait ton sandwich au thon. Au fur et à mesure que chaque sandwich

est préparé, placez-le dans la liste des sandwichs finis. Une fois que tous les sandwichs ont été préparés, imprimez

un message répertoriant chaque sandwich préparé.

7-9. Pas de pastrami: Utilisation de la liste sandwich_orders de l'exercice 7-8, assurez-vous que le sandwich ' pastrami

' apparaît dans la liste au moins trois fois. Ajoutez du code au début de votre programme pour imprimer un message

indiquant que l'épicerie est à court de pastrami, puis utilisez un tandis que boucle pour supprimer toutes les

occurrences de

'pastrami' de sandwich_orders. Assurez-vous qu'aucun sandwich au pastrami ne se retrouve

dans finis_sandwiches.

7-10. Vacances de rêve: Rédigez un programme qui interroge les utilisateurs sur leurs vacances de rêve. Écrivez

une invite semblable à Si vous pouviez visiter un endroit dans le monde, où iriez-vous? Incluez un bloc de code

qui imprime les résultats du sondage.

résumé
Dans ce chapitre, vous avez appris à utiliser saisir() pour permettre aux utilisateurs de fournir leurs propres informations dans
vos programmes. Vous avez appris à travailler à la fois avec du texte et des entrées numériques et à utiliser tandis que boucles
pour faire fonctionner vos programmes aussi longtemps que vos utilisateurs le souhaitent. Vous avez vu plusieurs façons de
contrôler le flux d'un tandis que boucle en définissant un actif drapeau, en utilisant le Pause déclaration, et

Entrée utilisateur et boucles while 131


en utilisant le Continuez déclaration. Vous avez appris à utiliser un tandis que boucle pour déplacer des éléments d'une liste à

une autre et comment supprimer toutes les instances d'une valeur d'une liste. Vous avez également appris comment tandis

que les boucles peuvent être utilisées avec des dictionnaires.

Au chapitre 8, vous en apprendrez plus sur les fonctions. Les fonctions vous permettent de diviser vos
programmes en petites parties, chacune effectuant un travail spécifique. Vous pouvez appeler une fonction autant
de fois que vous le souhaitez et vous pouvez stocker vos fonctions dans des fichiers séparés. En utilisant des
fonctions, vous serez en mesure d'écrire un code plus efficace, plus facile à dépanner et à maintenir et qui peut être
réutilisé dans de nombreux programmes différents.

132 Chapitre 7
8
les fonctions

Dans ce chapitre, vous apprendrez à écrire


les fonctions, qui sont des blocs de code nommés conçus
pour effectuer un travail spécifique. Lorsque vous souhaitez effectuer
une tâche particulière que vous avez définie dans une fonction, vous appeler
le nom de la fonction qui en est responsable. Si vous avez besoin

effectuez cette tâche plusieurs fois tout au long de votre programme, vous n'avez pas besoin de taper tout le
code pour la même tâche encore et encore; vous appelez simplement la fonction dédiée à la gestion de cette
tâche, et l'appel indique à Python d'exécuter le code à l'intérieur de la fonction. Vous constaterez que l'utilisation
de fonctions facilite l'écriture, la lecture, le test et la correction de vos programmes.

Dans ce chapitre, vous apprendrez également comment transmettre des informations aux fonctions. Vous apprendrez

à écrire certaines fonctions dont la tâche principale consiste à afficher des informations et d'autres fonctions conçues pour

traiter des données et renvoyer une valeur ou un ensemble de valeurs. Enfin, vous apprendrez à stocker les fonctions dans

des fichiers séparés appelés modules pour vous aider à organiser vos principaux fichiers de programme.
définir une fonction
Voici une fonction simple nommée Greet_user () qui imprime un message d'accueil:

greeter.py u def greet_user ():


v "" "Afficher un message d'accueil simple." ""
w print ("Bonjour!")

X Greet_user ()

Cet exemple montre la structure la plus simple d'une fonction. La ligne à u


utilise le mot-clé def pour informer Python que vous définissez une fonction. C'est le définition de fonction, qui
indique à Python le nom de la fonction et, le cas échéant, le type d'informations dont la fonction a besoin
pour faire son travail. Les parenthèses contiennent ces informations. Dans ce cas, le nom de la fonction est greet_user
(), et il n'a besoin d'aucune information pour faire son travail, donc ses parenthèses sont vides. (Même
ainsi, les parenthèses sont obligatoires.) Enfin, la définition se termine par deux points.

Toutes les lignes en retrait qui suivent def greet_user (): composent le corps de la fonction. Le texte à v
est un commentaire appelé un docstring, qui décrit ce que fait la fonction. Les docstrings sont entourés
de guillemets triples, ce que Python recherche lorsqu'il génère de la documentation pour les fonctions
de vos programmes.

La ligne print ("Bonjour!") w est la seule ligne de code réel dans le corps de cette fonction, donc Greet_user
() n'a qu'un seul travail: print ("Bonjour!").
Lorsque vous souhaitez utiliser cette fonction, vous l'appelez. UNE appel de fonction dit à Python
d'exécuter le code dans la fonction. À appeler une fonction, vous écrivez le nom de la fonction, suivi de toutes
les informations nécessaires entre parenthèses, comme indiqué à X. Parce qu'aucune information n'est
nécessaire ici, appeler notre fonction est aussi simple que d'entrer greet_user (). Comme prévu, il imprime Bonjour!:

Bonjour!

Transmission d'informations à une fonction

Modifié légèrement, la fonction Greet_user () ne peut pas seulement dire à l'utilisateur Bonjour!
mais aussi les saluer par leur nom. Pour que la fonction fasse cela, vous entrez Nom d'utilisateur
entre parenthèses de la définition de la fonction à def greet_user (). En ajoutant Nom d'utilisateur ici, vous autorisez la
fonction à accepter toute valeur de Nom d'utilisateur vous spécifiez. La fonction attend maintenant que vous fournissiez
une valeur pour Nom d'utilisateur chaque fois que vous l'appelez. Quand vous appelez greet_user (), vous pouvez lui
donner un nom, tel que
«jesse», à l'intérieur des parenthèses:

def greet_user (nom d'utilisateur):


"" "Afficher un message d'accueil simple." ""
print ("Bonjour", + username.title () + "!")

greet_user ('jesse')

134 Chapitre 8
Entrer greet_user ('jesse') appels Greet_user () et donne à la fonction les informations dont elle a besoin pour
exécuter le impression déclaration. La fonction accepte le nom que vous lui avez transmis et affiche le
message d'accueil pour ce nom:

Bonjour Jesse!

De même, entrer greet_user ('sarah') appels greet_user (), le passe ' sarah ',
et impressions Bonjour Sarah! Tu peux appeler Greet_user () aussi souvent que vous le souhaitez et donnez-lui le nom que
vous souhaitez pour produire une sortie prévisible à chaque fois.

Arguments et paramètres
Dans le précédent Greet_user () fonction, nous avons défini Greet_user () pour exiger une valeur pour la variable Nom d'utilisateur.
Une fois que nous avons appelé la fonction et lui avons donné les informations (le nom d'une personne), elle a imprimé le
bon message d'accueil.
La variable Nom d'utilisateur dans la définition de Greet_user () est un exemple de
paramètre, une information dont la fonction a besoin pour faire son travail. La valeur
'jesse' dans greet_user ('jesse') est un exemple de argument. Un argument est une information qui est passée
d'un appel de fonction à une fonction. Lorsque nous appelons la fonction, nous plaçons la valeur avec
laquelle nous voulons que la fonction fonctionne entre parenthèses. Dans ce cas, l'argument ' jesse ' a été
passé à la fonction greet_user (), et la valeur a été stockée dans le paramètre Nom d'utilisateur.

Remarque Les gens parlent parfois d'arguments et de paramètres de manière interchangeable. Ne soyez pas surpris si vous voyez
les variables dans une définition de fonction appelées arguments ou les variables dans un appel de fonction appelées
paramètres.

essayez-le vous-même

8-1. Un message: Ecrire une fonction appelée display_message () qui imprime une phrase expliquant à tout

le monde ce que vous apprenez dans ce chapitre. Appelez la fonction et assurez-vous que le message

s'affiche correctement.

8-2. Livre préféré: Ecrire une fonction appelée Livre préféré() qui accepte un paramètre, Titre . La
fonction doit imprimer un message, tel que Un de mes
les livres préférés sont Alice au pays des merveilles. Appelez la fonction en vous assurant de

inclure un titre de livre comme argument dans l'appel de fonction.

Passer des arguments

Étant donné qu'une définition de fonction peut avoir plusieurs paramètres, un appel de fonction peut nécessiter
plusieurs arguments. Vous pouvez transmettre des arguments à vos fonctions de plusieurs manières. Vous pouvez
utiliser arguments positionnels, qui doivent être dans

Les fonctions 135


dans le même ordre que les paramètres ont été écrits; arguments de mots clés, où chaque argument se compose
d'un nom de variable et d'une valeur; et listes et dictionnaires de valeurs. Examinons chacun de ces éléments à tour
de rôle.

Arguments de position

Lorsque vous appelez une fonction, Python doit faire correspondre chaque argument de l'appel de fonction avec un
paramètre dans la définition de fonction. La manière la plus simple de procéder est basée sur l'ordre des arguments
fournis. Les valeurs mises en correspondance de cette manière sont appelées arguments de position.

Pour voir comment cela fonctionne, envisagez une fonction qui affiche des informations sur les animaux
domestiques. La fonction nous indique le type d'animal de chaque animal et le nom de l'animal, comme indiqué ici:

pets.py u def describe_pet (type_animal, nom_animal):


"" "Afficher des informations sur un animal domestique." ""
Print ("\ nJ'ai un" + type_animal + ".")
print (Le nom de "Mon" + type_animal + "est" + nom_animal.title () + ".")

v describe_pet ('hamster', 'harry')

La définition montre que cette fonction nécessite un type d'animal et le nom de l'animal u. Quand
nous appelons describe_pet (), nous devons fournir un type d'animal et un nom, dans cet ordre. Par
exemple, dans l'appel de fonction, l'argument ' hamster' est stocké dans le paramètre type_animal et
l'argument ' harry ' est stocké dans le paramètre nom d'animal domestique v. Dans le corps de la fonction, ces
deux paramètres sont utilisés pour afficher des informations sur l'animal en cours de description.

La sortie décrit un hamster nommé Harry:

J'ai un hamster.
Le nom de mon hamster est Harry.

Appels de fonctions multiples

Vous pouvez appeler une fonction autant de fois que nécessaire. Décrire un deuxième animal de compagnie différent ne
nécessite qu'un seul appel de plus describe_pet ():

def describe_pet (type_animal, nom_animal):


"" "Afficher des informations sur un animal domestique." ""
Print ("\ nJ'ai un" + type_animal + ".")
print (Le nom de "Mon" + type_animal + "est" + nom_animal.title () + ".")

describe_pet ('hamster', 'harry')


describe_pet ('chien', 'willie')

Dans ce deuxième appel de fonction, nous passons describe_pet () les arguments ' chien'
et ' Willie '. Comme pour l'ensemble d'arguments précédent que nous avons utilisé, Python correspond

'chien' avec le paramètre type_animal et ' Willie ' avec le paramètre nom d'animal domestique.

136 Chapitre 8
Comme auparavant, la fonction fait son travail, mais cette fois, elle imprime les valeurs d'un chien nommé Willie.
Maintenant, nous avons un hamster nommé Harry et un chien nommé Willie:

J'ai un hamster.
Le nom de mon hamster est Harry.

J'ai un chien.
Le nom de mon chien est Willie.

Appeler une fonction plusieurs fois est un moyen très efficace de travailler. Le code décrivant un animal de
compagnie est écrit une fois dans la fonction. Ensuite, chaque fois que vous souhaitez décrire un nouvel animal, vous
appelez la fonction avec les informations sur le nouvel animal. Même si le code pour décrire un animal de compagnie
devait s'étendre à dix lignes, vous pourriez toujours décrire un nouvel animal en une seule ligne en appelant à nouveau
la fonction.

Vous pouvez utiliser autant d'arguments de position que nécessaire dans vos fonctions. Python
utilise les arguments que vous fournissez lors de l'appel de la fonction et fait correspondre chacun
d'eux avec le paramètre correspondant dans la définition de la fonction.

Ordonner les questions dans les arguments positionnels

Vous pouvez obtenir des résultats inattendus si vous mélangez l'ordre des arguments dans un appel de fonction lors
de l'utilisation d'arguments positionnels:

def describe_pet (type_animal, nom_animal):


"" "Afficher des informations sur un animal domestique." ""
Print ("\ nJ'ai un" + type_animal + ".")
print (Le nom de "Mon" + type_animal + "est" + nom_animal.title () + ".")

describe_pet ('harry', 'hamster')

Dans cet appel de fonction, nous listons le nom en premier et le type d'animal en second. Parce que l'argument ' harry
' est répertorié en premier cette fois, cette valeur est stockée dans le paramètre type_animal. De même, ' hamster' est stocké
dans nom d'animal domestique. Maintenant, nous avons un «harry» nommé «Hamster»:

J'ai un harry.
Le nom de mon harry est Hamster.

Si vous obtenez des résultats amusants comme celui-ci, vérifiez que l'ordre des arguments dans votre
appel de fonction correspond à l'ordre des paramètres dans la définition de la fonction.

Arguments de mots-clés

UNE argument de mot-clé est une paire nom-valeur que vous passez à une fonction. Vous associez
directement le nom et la valeur dans l'argument, donc lorsque vous passez l'argument à la fonction, il n'y
a pas de confusion (vous ne finirez pas

Les fonctions 137


avec un harry nommé Hamster). Les arguments de mots-clés vous évitent d'avoir à vous soucier de
l'ordre correct de vos arguments dans l'appel de fonction, et ils clarifient le rôle de chaque valeur dans
l'appel de fonction.
Réécrivons pets.py utiliser des arguments de mots clés pour appeler describe_pet ():

def describe_pet (type_animal, nom_animal):


"" "Afficher des informations sur un animal domestique." ""
Print ("\ nJ'ai un" + type_animal + ".")
print (Le nom de "Mon" + type_animal + "est" + nom_animal.title () + ".")

describe_pet (animal_type = 'hamster', pet_name = 'harry')

La fonction describe_pet () n'a pas changé. Mais lorsque nous appelons la fonction, nous indiquons
explicitement à Python avec quel paramètre chaque argument doit être mis en correspondance.
Lorsque Python lit l'appel de fonction, il sait stocker l'argument ' hamster' dans le paramètre type_animal et
l'argument ' harry '
dans nom d'animal domestique. La sortie montre correctement que nous avons un hamster nommé Harry.

L'ordre des arguments de mot-clé n'a pas d'importance car Python sait où chaque valeur
doit aller. Les deux appels de fonction suivants sont équivalents:

describe_pet (animal_type = 'hamster', pet_name = 'harry')


describe_pet (pet_name = 'harry', animal_type = 'hamster')

Remarque Lorsque vous utilisez des arguments de mot-clé, veillez à utiliser les noms exacts des paramètres dans la définition de la
fonction.

Les valeurs par défaut

Lors de l'écriture d'une fonction, vous pouvez définir un valeur par défaut pour chaque paramètre. Si un argument
pour un paramètre est fourni dans l'appel de fonction, Python utilise la valeur de l'argument. Sinon, il utilise la valeur
par défaut du paramètre. Ainsi, lorsque vous définissez une valeur par défaut pour un paramètre, vous pouvez
exclure l'argument correspondant que vous écririez habituellement dans l'appel de fonction. L'utilisation des valeurs
par défaut peut simplifier vos appels de fonction et clarifier la manière dont vos fonctions sont généralement utilisées.

Par exemple, si vous remarquez que la plupart des appels à describe_pet () sont utilisés pour décrire les
chiens, vous pouvez définir la valeur par défaut de type_animal à
'chien'. Maintenant quiconque appelle describe_pet () pour un chien peut omettre cette information:

def describe_pet (pet_name, animal_type = 'dog'):


"" "Afficher des informations sur un animal domestique." ""
Print ("\ nJ'ai un" + type_animal + ".")
print (Le nom de "Mon" + type_animal + "est" + nom_animal.title () + ".")

describe_pet (pet_name = 'willie')

138 Chapitre 8
Nous avons changé la définition de describe_pet () pour inclure une valeur par défaut,
'chien', pour type_animal. Maintenant, quand la fonction est appelée sans type_animal
spécifié, Python sait utiliser la valeur ' chien' pour ce paramètre:

J'ai un chien.
Le nom de mon chien est Willie.

Notez que l'ordre des paramètres dans la définition de la fonction a dû être modifié. Étant donné que la
valeur par défaut rend inutile la spécification d'un type d'animal comme argument, le seul argument restant
dans l'appel de fonction est le nom de l'animal. Python l'interprète toujours comme un argument de position,
donc si la fonction est appelée avec juste le nom d'un animal de compagnie, cet argument correspondra au
premier paramètre répertorié dans la définition de la fonction. C'est la raison pour laquelle le premier
paramètre doit être nom d'animal domestique.

Le moyen le plus simple d'utiliser cette fonction maintenant est de fournir uniquement le nom d'un chien dans

l'appel de fonction:

describe_pet ('willie')

Cet appel de fonction aurait la même sortie que l'exemple précédent. Le seul argument fourni
est ' willie ', il correspond donc au premier paramètre de la définition, nom d'animal domestique. Parce
qu'aucun argument n'est fourni pour
type_animal, Python utilise la valeur par défaut ' chien'.
Pour décrire un animal autre qu'un chien, vous pouvez utiliser un appel de fonction comme celui-ci:

describe_pet (pet_name = 'harry', animal_type = 'hamster')

Parce qu'un argument explicite pour type_animal est fourni, Python ignorera la valeur par
défaut du paramètre.

Remarque Lorsque vous utilisez des valeurs par défaut, tout paramètre avec une valeur par défaut doit être répertorié après tous les
paramètres qui n'ont pas de valeurs par défaut. Cela permet à Python de continuer à interpréter correctement les
arguments de position.

Appels de fonction équivalents

Étant donné que les arguments de position, les arguments de mots-clés et les valeurs par défaut peuvent tous être
utilisés ensemble, vous aurez souvent plusieurs façons équivalentes d'appeler une fonction. Considérez la définition
suivante pour describe_pets () avec une valeur par défaut fournie:

def describe_pet (pet_name, animal_type = 'dog'):

Avec cette définition, un argument doit toujours être fourni


nom d'animal domestique, et cette valeur peut être fournie à l'aide de la position ou du mot-clé

Les fonctions 139


format. Si l'animal décrit n'est pas un chien, un argument pour
type_animal doit être inclus dans l'appel, et cet argument peut également être spécifié en utilisant
le format positionnel ou mot-clé.
Tous les appels suivants fonctionneraient pour cette fonction:

# Un chien nommé Willie.


describe_pet ('willie')

describe_pet (pet_name = 'willie')

# Un hamster nommé Harry.


describe_pet ('harry', 'hamster')
describe_pet (pet_name = 'harry', animal_type = 'hamster')
describe_pet (animal_type = 'hamster', pet_name = 'harry')

Chacun de ces appels de fonction aurait la même sortie que les exemples précédents.

Remarque Le style d'appel que vous utilisez n'a pas vraiment d'importance. Tant que vos appels de fonction produisent le résultat
souhaité, utilisez simplement le style que vous trouvez le plus facile à comprendre.

Éviter les erreurs d'argument

Lorsque vous commencez à utiliser des fonctions, ne soyez pas surpris si vous rencontrez des erreurs concernant des

arguments sans correspondance. Des arguments sans correspondance se produisent lorsque vous fournissez moins ou

plus d'arguments que ce dont une fonction a besoin pour faire son travail. Par exemple, voici ce qui se passe si nous

essayons d'appeler describe_pet () sans arguments:

def describe_pet (type_animal, nom_animal):


"" "Afficher des informations sur un animal domestique." ""
Print ("\ nJ'ai un" + type_animal + ".")
print (Le nom de "Mon" + type_animal + "est" + nom_animal.title () + ".")

describe_pet ()

Python reconnaît que certaines informations sont manquantes dans l'appel de fonction, et le
traçage nous dit que:

Traceback (dernier appel le plus récent):


u Fichier "pets.py", ligne 6, dans <module>
v describe_pet ()
w TypeError: describe_pet () manquant 2 arguments positionnels requis: 'animal_
type 'et' pet_name '

À u le retraçage nous indique l'emplacement du problème, nous permettant de regarder en arrière et de voir
que quelque chose s'est mal passé dans notre appel de fonction. À v
l'appel de fonction incriminé est écrit pour que nous puissions le voir. À w le retraçage

140 Chapitre 8
nous indique qu'il manque deux arguments à l'appel et indique les noms des arguments manquants. Si
cette fonction était dans un fichier séparé, nous pourrions probablement réécrire correctement l'appel sans
avoir à ouvrir ce fichier et lire le code de la fonction.

Python est utile en ce qu'il lit le code de la fonction pour nous et nous indique les noms des
arguments que nous devons fournir. C'est une autre motivation pour donner des noms descriptifs à vos
variables et fonctions. Si vous le faites, les messages d'erreur de Python seront plus utiles pour vous et
toute autre personne susceptible d'utiliser votre code.

Si vous fournissez trop d'arguments, vous devriez obtenir un suivi similaire qui peut vous aider à faire
correspondre correctement votre appel de fonction à la définition de fonction.

essayez-le vous-même

8-3. T-shirt: Ecrire une fonction appelée make_shirt () qui accepte une taille et le texte d'un message
qui doit être imprimé sur la chemise. La fonction doit imprimer une phrase résumant la taille de la
chemise et le message imprimé dessus.
Appelez la fonction une fois en utilisant des arguments de position pour créer une chemise. Appelez la fonction une deuxième

fois en utilisant des arguments de mot-clé.

8-4. Grandes chemises: Modifier le make_shirt () fonction pour que les chemises soient grandes par défaut avec un

message qui lit J'adore Python. Faites une grande chemise et une chemise moyenne avec le message par défaut, et une

chemise de n'importe quelle taille avec un message différent.

8-5. Villes: Ecrire une fonction appelée describe_city () qui accepte le nom d'une ville et de son pays.
La fonction doit imprimer une phrase simple, telle que
Reykjavik est en Islande. Donnez au paramètre du pays une valeur par défaut. Appelez votre fonction
pour trois villes différentes, dont au moins une n'est pas dans le pays par défaut.

valeurs de retour

Une fonction n'a pas toujours à afficher directement sa sortie. Au lieu de cela, il peut traiter certaines données, puis
renvoyer une valeur ou un ensemble de valeurs. La valeur renvoyée par la fonction s'appelle un valeur de retour. Le revenir
L'instruction prend une valeur à l'intérieur d'une fonction et la renvoie à la ligne qui a appelé la fonction. Les valeurs
de retour vous permettent de déplacer une grande partie du travail grognon de votre programme dans des fonctions,
ce qui peut simplifier le corps de votre programme.

Les fonctions 141


Renvoyer une valeur simple

Regardons une fonction qui prend un prénom et un nom, et renvoie un nom complet parfaitement
formaté:

formaté_ u def get_formatted_name (prénom, nom):


name.py "" "Renvoie un nom complet, soigneusement formaté." ""
v Full_name = first_name + '' + last_name return full_name.title ()
w

X musicien = get_formatted_name ('jimi', 'hendrix')


print (musicien)

La définition de get_formatted_name () prend comme paramètres un prénom et un nom u. La


fonction combine ces deux noms, ajoute un espace entre eux et stocke le résultat dans nom complet v.
La valeur de nom complet est converti en casse du titre, puis renvoyé à la ligne appelante à w.

Lorsque vous appelez une fonction qui renvoie une valeur, vous devez fournir une variable dans
laquelle la valeur de retour peut être stockée. Dans ce cas, la valeur retournée est stockée dans la variable musicien
à X. La sortie affiche un nom parfaitement formaté composé des parties du nom d'une personne:

Jimi Hendrix

Cela peut sembler beaucoup de travail pour obtenir un nom parfaitement formaté alors que nous aurions pu
juste écrire:

impression ("Jimi Hendrix")

Mais lorsque vous envisagez de travailler avec un programme volumineux qui doit stocker plusieurs noms et
prénoms séparément, des fonctions telles que get_formatted_name ()
devenir très utile. Vous stockez les prénoms et les noms séparément, puis appelez cette fonction chaque fois
que vous souhaitez afficher un nom complet.

Rendre un argument facultatif

Parfois, il est judicieux de rendre un argument facultatif afin que les personnes utilisant la fonction puissent choisir
de fournir des informations supplémentaires uniquement si elles le souhaitent. Vous pouvez utiliser les valeurs par
défaut pour rendre un argument facultatif.
Par exemple, disons que nous voulons développer get_formatted_name () pour gérer également les prénoms.
Une première tentative d'inclure des prénoms pourrait ressembler à ceci:

def get_formatted_name (first_name, middle_name, last_name):


"" "Renvoie un nom complet, soigneusement formaté." ""
full_name = first_name + '' + middle_name + '' + last_name return full_name.title ()

musicien = get_formatted_name ('john', 'lee', 'hooker') print (musicien)

142 Chapitre 8
Cette fonction fonctionne lorsqu'on lui donne un prénom, un deuxième prénom et un nom de famille. La
fonction prend les trois parties d'un nom, puis crée une chaîne à partir de celles-ci. La fonction ajoute des
espaces le cas échéant et convertit le nom complet en casse du titre:

John Lee Hooker

Mais les prénoms ne sont pas toujours nécessaires, et cette fonction telle qu'elle est écrite ne
fonctionnerait pas si vous essayiez de l'appeler avec seulement un prénom et un nom de famille. Pour rendre le
deuxième prénom facultatif, nous pouvons donner le deuxième nom argument une valeur par défaut vide et ignorez
l'argument sauf si l'utilisateur fournit une valeur. Faire get_formatted_name () travailler sans deuxième prénom, nous
définissons la valeur par défaut de deuxième nom vers une chaîne vide et déplacez-la à la fin de la liste des
paramètres:

u def get_formatted_name (first_name, last_name, middle_name = ''):


"" "Renvoie un nom complet, soigneusement formaté." ""
v si deuxième_nom:
full_name = first_name + '' + middle_name + '' + last_name else:
w
full_name = first_name + '' + last_name
retourne full_name.title ()

musician = get_formatted_name ('jimi', 'hendrix') print (musicien)

X musicien = get_formatted_name ('john', 'hooker', 'lee')


print (musicien)

Dans cet exemple, le nom est construit à partir de trois parties possibles. Comme il y a toujours un
prénom et un nom, ces paramètres sont répertoriés en premier dans la définition de la fonction. Le deuxième
prénom est facultatif, il est donc répertorié en dernier dans la définition et sa valeur par défaut est une chaîne
vide u.
Dans le corps de la fonction, nous vérifions si un deuxième prénom a été fourni. Python
interprète les chaînes non vides comme Vrai, alors si deuxième_nom
évalue à Vrai si un argument de deuxième prénom est dans l'appel de fonction v. Si un deuxième prénom est
fourni, le prénom, le deuxième prénom et le nom de famille sont combinés pour former un nom complet. Ce
nom est ensuite changé en casse du titre et renvoyé à la ligne d'appel de fonction où il est stocké dans la
variable musicien et imprimé. Si aucun deuxième prénom n'est fourni, la chaîne vide échoue si test et le autre

bloc exécute w. Le nom complet est fait avec juste un prénom et un nom, et le nom formaté est
renvoyé à la ligne appelante où il est stocké dans musicien
et imprimé.
L'appel de cette fonction avec un prénom et un nom est simple. Si nous utilisons un deuxième
prénom, cependant, nous devons nous assurer que le deuxième prénom est le dernier argument passé
afin que Python corresponde correctement aux arguments de position X.

Les fonctions 143


Cette version modifiée de notre fonction fonctionne pour les personnes n'ayant qu'un prénom et un nom de famille,

et elle fonctionne également pour les personnes qui ont un deuxième prénom:

Jimi Hendrix
John Lee Hooker

Les valeurs facultatives permettent aux fonctions de gérer un large éventail de cas d'utilisation tout en laissant

les appels de fonction rester aussi simples que possible.

Retourner un dictionnaire

Une fonction peut renvoyer n'importe quel type de valeur dont vous avez besoin, y compris des structures de données
plus complexes telles que des listes et des dictionnaires. Par exemple, la fonction suivante prend des parties d'un nom
et renvoie un dictionnaire représentant une personne:

person.py def build_person (prénom, nom):


"" "Renvoie un dictionnaire d'informations sur une personne." "" Person = {'first':
u first_name, 'last': last_name} return person
v

musicien = build_person ('jimi', 'hendrix')


w print (musicien)

La fonction build_person () prend un prénom et un nom, et regroupe ces valeurs dans un


dictionnaire à l'adresse u. La valeur de Prénom est stocké avec la clé ' première', et la valeur de nom de
famille est stocké avec la clé ' dernier'. L'ensemble du dictionnaire représentant la personne est renvoyé à v.
La valeur de retour est imprimée à w avec les deux informations textuelles d'origine désormais
stockées dans un dictionnaire:

{'premier': 'jimi', 'dernier': 'hendrix'}

Cette fonction prend des informations textuelles simples et les place dans une structure de données plus
significative qui vous permet de travailler avec les informations au-delà de leur simple impression. Les cordes ' jimi ' et ' Hendrix
' sont maintenant étiquetés comme un prénom et un nom de famille. Vous pouvez facilement étendre cette fonction
pour accepter des valeurs facultatives comme un deuxième prénom, un âge, une profession ou toute autre
information que vous souhaitez stocker sur une personne. Par exemple, la modification suivante vous permet
également d'enregistrer l'âge d'une personne:

def build_person (first_name, last_name, age = ''):


"" "Renvoie un dictionnaire d'informations sur une personne." "" Person = {'first':
first_name, 'last': last_name}
si l'âge:
personne ['age'] = âge
retour personne

musicien = build_person ('jimi', 'hendrix', âge = 27)


print (musicien)

144 Chapitre 8
Nous ajoutons un nouveau paramètre facultatif âge à la définition de fonction et attribuez au paramètre une
valeur par défaut vide. Si l'appel de fonction inclut une valeur pour ce paramètre, la valeur est stockée dans le
dictionnaire. Cette fonction stocke toujours le nom d'une personne, mais elle peut également être modifiée pour
stocker toute autre information que vous souhaitez sur une personne.

Utilisation d'une fonction avec une boucle while

Vous pouvez utiliser des fonctions avec toutes les structures Python que vous avez apprises jusqu'à présent. Par
exemple, utilisons le get_formatted_name () fonction avec un tandis que
boucle pour saluer les utilisateurs de manière plus formelle. Voici une première tentative pour saluer les gens en utilisant

leur prénom et leur nom:

greeter.py def get_formatted_name (prénom, nom):


"" "Renvoie un nom complet, soigneusement formaté." ""
Full_name = first_name + '' + last_name return full_name.title ()

# C'est une boucle infinie! tandis que


Vrai:

u print ("\ nVeuillez me dire votre nom:") f_name = input


("First name:") l_name = input ("Last name:")

nom_formaté = get_nom_formaté (nom_f, nom_l) print ("\ nBonjour," +


nom_formaté + "!")

Pour cet exemple, nous utilisons une version simple de get_formatted_name () cela n'implique pas
des prénoms. Le tandis que loop demande à l'utilisateur d'entrer son nom, et nous demandons son
prénom et son nom séparément u.
Mais il y a un problème avec ça tandis que boucle: Nous n'avons pas défini de condition d'arrêt. Où
placez-vous une condition d'arrêt lorsque vous demandez une série d'entrées? Nous voulons que l'utilisateur
puisse quitter le plus facilement possible, de sorte que chaque invite devrait offrir un moyen de quitter. Le Pause L'instruction
offre un moyen simple de quitter la boucle à l'une ou l'autre des invites:

def get_formatted_name (prénom, nom):


"" "Renvoie un nom complet, soigneusement formaté." ""
Full_name = first_name + '' + last_name return full_name.title ()

tandis que Vrai:


print ("\ nVeuillez me dire votre nom:")
print ("(entrez 'q' à tout moment pour quitter)")

f_name = input ("Prénom:")


si f_name == 'q':
Pause

l_name = input ("Nom de famille:")


si l_name == 'q':
Pause

Les fonctions 145


nom_formaté = get_nom_formaté (nom_f, nom_l) print ("\ nBonjour," +
nom_formaté + "!")

Nous ajoutons un message qui informe l'utilisateur comment quitter, puis nous sortons de la boucle si
l'utilisateur entre la valeur de quitter à l'une ou l'autre des invites. Maintenant, le programme continuera à saluer
les gens jusqu'à ce que quelqu'un entre ' q '
pour l'un ou l'autre nom:

Veuillez me dire votre nom: (entrez 'q' à tout


moment pour quitter) Prénom: Eric

Nom de famille: matthes

Bonjour Eric Matthes!

Veuillez me dire votre nom: (entrez 'q' à tout


moment pour quitter) Prénom: q

essayez-le vous-même

8-6. Noms de ville: Ecrire une fonction appelée ville Pays() cela prend le nom d'une ville et de son pays.
La fonction doit renvoyer une chaîne au format suivant:

"Santiago, Chili"

Appelez votre fonction avec au moins trois paires ville-pays et imprimez la valeur renvoyée.

8-7. Album: Ecrire une fonction appelée make_album () qui construit un dictionnaire décrivant un album de
musique. La fonction doit prendre un nom d'artiste et un titre d'album, et elle doit renvoyer un dictionnaire
contenant ces deux informations. Utilisez la fonction pour créer trois dictionnaires représentant différents
albums. Imprimez chaque valeur de retour pour montrer que les dictionnaires stockent correctement les
informations de l'album.

Ajouter un paramètre facultatif à make_album () qui vous permet de stocker le nombre de pistes sur
un album. Si la ligne appelante inclut une valeur pour le nombre de pistes, ajoutez cette valeur au
dictionnaire de l'album. Effectuez au moins un nouvel appel de fonction qui inclut le nombre de pistes d'un
album.

8-8. Albums utilisateurs: Commencez par votre programme de l'exercice 8-7. Écrire un tandis que

boucle qui permet aux utilisateurs de saisir l'artiste et le titre d'un album. Une fois que vous avez cette information,

appelez make_album () avec l'entrée de l'utilisateur et imprimez le dictionnaire créé. Assurez-vous d'inclure une valeur

d'arrêt dans le tandis que boucle .

146 Chapitre 8
Passer une liste

Vous trouverez souvent utile de transmettre une liste à une fonction, qu'il s'agisse d'une liste de noms, de
nombres ou d'objets plus complexes, tels que des dictionnaires. Lorsque vous passez une liste à une fonction, la
fonction obtient un accès direct au contenu de la liste. Utilisons des fonctions pour rendre le travail avec des
listes plus efficace.
Supposons que nous ayons une liste d'utilisateurs et que nous souhaitons imprimer un message d'accueil à

chacun. L'exemple suivant envoie une liste de noms à une fonction appelée greet_users (),

qui accueille chaque personne de la liste individuellement:

greet_users.py def greet_users (noms):


"" "Imprimez un message d'accueil simple à chaque utilisateur de la liste." "" Pour le nom dans les
noms:
msg = "Bonjour," + nom.title () + "!" imprimer (msg)

u noms d'utilisateur = ['hannah', 'ty', 'margot']


greet_users (noms d'utilisateur)

Nous définissons greet_users () il attend donc une liste de noms, qu'il stocke dans le paramètre noms. La
fonction parcourt la liste qu'elle reçoit et imprime un message d'accueil à chaque utilisateur. À u nous
définissons une liste d'utilisateurs puis passons la liste noms d'utilisateur à greet_users () dans notre appel de
fonction:

Bonjour Hannah!
Bonjour, Ty!
Bonjour Margot!

C'est la sortie que nous voulions. Chaque utilisateur voit un message d'accueil personnalisé et vous pouvez

appeler la fonction à chaque fois que vous souhaitez saluer un groupe spécifique d'utilisateurs.

Modifier une liste dans une fonction

Lorsque vous passez une liste à une fonction, la fonction peut modifier la liste. Toutes les modifications apportées à la
liste à l'intérieur du corps de la fonction sont permanentes, ce qui vous permet de travailler efficacement même lorsque
vous traitez de grandes quantités de données.
Prenons l'exemple d'une entreprise qui crée des modèles imprimés en 3D de conceptions que les utilisateurs

soumettent. Les dessins qui doivent être imprimés sont stockés dans une liste et après avoir été imprimés, ils sont déplacés

vers une liste distincte. Le code suivant effectue cette opération sans utiliser de fonctions:

impression_ # Commencez par quelques dessins qui doivent être imprimés.


models.py unprinted_designs = ['coque iphone', 'pendentif robot', 'dodécaèdre'] completed_models = []

# Simulez l'impression de chaque dessin, jusqu'à ce qu'il n'en reste plus.


# Déplacez chaque dessin vers completed_models après l'impression. pendant
unprinted_designs:

current_design = unprinted_designs.pop ()

Les fonctions 147


# Simulez la création d'une impression 3D à partir de la conception. print
("Modèle d'impression:" + conception_actuelle) completed_models.append
(conception_actuelle)

# Afficher tous les modèles terminés.


print ("\ nLes modèles suivants ont été imprimés:") pour completed_model
dans completed_models:
print (modèle_fini)

Ce programme commence par une liste de dessins à imprimer et une liste vide appelée complete_models
que chaque dessin sera déplacé après avoir été imprimé. Tant que les dessins restent unprinted_designs,
le tandis que
loop simule l'impression de chaque dessin en supprimant un dessin à la fin de la liste et en le stockant
dans conception actuelle, et afficher un message indiquant que le dessin actuel est en cours d'impression.
Il ajoute ensuite le dessin à la liste des modèles terminés. Lorsque la boucle est terminée, une liste
des motifs qui ont été imprimés s'affiche:

Modèle d'impression: dodécaèdre


Modèle d'impression: pendentif robot Modèle
d'impression: coque iphone

Les modèles suivants ont été imprimés: dodécaèdre

pendentif robot
étui iphone

Nous pouvons réorganiser ce code en écrivant deux fonctions, chacune faisant un travail
spécifique. La plupart du code ne changera pas; nous le rendons simplement plus efficace. La
première fonction gérera l'impression des dessins et la seconde résumera les impressions qui ont été
réalisées:

u def print_models (unprinted_designs, completed_models):


"" "
Simulez l'impression de chaque dessin, jusqu'à ce qu'il n'en reste plus. Déplacez
chaque dessin vers completed_models après l'impression. "" "

pendant unprinted_designs:
current_design = unprinted_designs.pop ()

# Simulez la création d'une impression 3D à partir de la conception. print


("Modèle d'impression:" + conception_actuelle) completed_models.append
(conception_actuelle)

v def show_completed_models (completed_models):


"" "Afficher tous les modèles qui ont été imprimés." "" Print ("\ nLes
modèles suivants ont été imprimés:") pour le modèle_fini dans les
modèles_accomplis:
print (modèle_fini)

unprinted_designs = ['coque iphone', 'pendentif robot', 'dodécaèdre'] completed_models = []

148 Chapitre 8
print_models (unprinted_designs, completed_models)
show_completed_models (modèles_complétés)

À u nous définissons la fonction print_models () avec deux paramètres: une liste des modèles à
imprimer et une liste des modèles terminés. Compte tenu de ces deux listes, la fonction simule
l'impression de chaque dessin en vidant la liste des dessins non imprimés et en remplissant la liste des
modèles terminés. À v nous définissons la fonction show_completed_models () avec un paramètre: la liste
des modèles terminés. Compte tenu de cette liste, show_completed_models () affiche le nom de chaque
modèle imprimé.

Ce programme a le même résultat que la version sans fonctions, mais le code est beaucoup plus
organisé. Le code qui effectue la majeure partie du travail a été déplacé vers deux fonctions distinctes,
ce qui rend la partie principale du programme plus facile à comprendre. Regardez le corps du
programme pour voir à quel point il est plus facile de comprendre ce que fait ce programme:

unprinted_designs = ['coque iphone', 'pendentif robot', 'dodécaèdre'] completed_models = []

print_models (unprinted_designs, completed_models)


show_completed_models (modèles_complétés)

Nous avons mis en place une liste de modèles non imprimés et une liste vide qui contiendra les
modèles terminés. Ensuite, comme nous avons déjà défini nos deux fonctions, il suffit de les appeler et de
leur passer les bons arguments. Nous appelons
print_models () et transmettez-lui les deux listes dont il a besoin; comme prévu, print_models ()
simule l'impression des dessins. Puis nous appelons show_completed_models () et transmettez-lui la liste des
modèles terminés afin qu'il puisse rapporter les modèles qui ont été imprimés. Les noms de fonction
descriptifs permettent aux autres de lire ce code et de le comprendre, même sans commentaires.

Ce programme est plus facile à étendre et à maintenir que la version sans fonctions. Si nous avons besoin
d'imprimer plus de modèles plus tard, nous pouvons simplement appeler
print_models () de nouveau. Si nous réalisons que le code d'impression doit être modifié, nous pouvons
changer le code une fois, et nos modifications auront lieu partout où la fonction est appelée. Cette technique
est plus efficace que d'avoir à mettre à jour le code séparément à plusieurs endroits du programme.

Cet exemple démontre également l'idée que chaque fonction doit avoir un travail spécifique. La
première fonction imprime chaque motif et la seconde affiche les modèles terminés. C'est plus avantageux
que d'utiliser une seule fonction pour effectuer les deux tâches. Si vous écrivez une fonction et remarquez
que la fonction effectue trop de tâches différentes, essayez de diviser le code en deux fonctions. N'oubliez
pas que vous pouvez toujours appeler une fonction à partir d'une autre fonction, ce qui peut être utile lors
de la division d'une tâche complexe en une série d'étapes.

Empêcher une fonction de modifier une liste

Parfois, vous voudrez empêcher une fonction de modifier une liste. Par exemple, disons que vous
commencez par une liste de dessins non imprimés et que vous écrivez un

Les fonctions 149


pour les déplacer vers une liste de modèles terminés, comme dans l'exemple précédent. Vous pouvez
décider que même si vous avez imprimé tous les motifs, vous souhaitez conserver la liste originale des
motifs non imprimés pour vos dossiers. Mais parce que vous avez déplacé tous les noms de design hors de unprinted_designs,
la liste est maintenant vide et la liste vide est la seule version dont vous disposez; l'original est parti. Dans ce
cas, vous pouvez résoudre ce problème en transmettant à la fonction une copie de la liste, pas l'original.
Toute modification apportée à la liste par la fonction n'affectera que la copie, laissant la liste d'origine intacte.

Vous pouvez envoyer une copie d'une liste à une fonction comme celle-ci:

nom_fonction (nom_liste [:])

La notation de tranche [:] fait une copie de la liste à envoyer à la fonction. Si nous ne voulions pas
vider la liste des dessins non imprimés dans print_models.py,
nous pourrions appeler print_models () comme ça:

print_models (unprinted_designs [:], completed_models)

La fonction print_models () peut faire son travail car il reçoit toujours les noms de tous les dessins
non imprimés. Mais cette fois, il utilise une copie de la liste des dessins originaux non imprimés, pas le
véritable unprinted_designs liste. La liste
complete_models se remplira avec les noms des modèles imprimés comme avant, mais la liste
d'origine des dessins non imprimés ne sera pas affectée par la fonction.

Même si vous pouvez conserver le contenu d'une liste en transmettant une copie de celle-ci à vos fonctions,
vous devez transmettre la liste d'origine aux fonctions à moins que vous n'ayez une raison spécifique de transmettre
une copie. Il est plus efficace pour une fonction de travailler avec une liste existante pour éviter d'utiliser le temps et la
mémoire nécessaires pour faire une copie séparée, en particulier lorsque vous travaillez avec de grandes listes.

essayez-le vous-même

8-9. Magiciens: Faites une liste des noms des magiciens. Passez la liste à une fonction appelée show_magicians

(), qui imprime le nom de chaque magicien dans la liste.

8-10. Grands magiciens: Commencez par une copie de votre programme de l'exercice 8-9. Ecrire une fonction

appelée make_great () qui modifie la liste des magiciens en ajoutant la phrase le grand au nom de chaque

magicien. Appeler show_magicians () pour voir que la liste a effectivement été modifiée.

8-11. Magiciens inchangés: Commencez par votre travail de l'exercice 8-10. Appeler la fonction make_great () avec

une copie de la liste des noms des magiciens. Étant donné que la liste d'origine restera inchangée, renvoyez la

nouvelle liste et stockez-la dans une liste distincte. Appeler show_magicians () avec chaque liste pour montrer que

vous avez une liste des noms originaux et une liste avec le grand ajouté au nom de chaque magicien.

150 Chapitre 8
Passer un nombre arbitraire d'arguments
Parfois, vous ne saurez pas à l'avance combien d'arguments une fonction doit accepter.
Heureusement, Python permet à une fonction de collecter un nombre arbitraire d'arguments à
partir de l'instruction appelante.
Par exemple, considérons une fonction qui construit une pizza. Il doit accepter un certain nombre
de garnitures, mais vous ne pouvez pas savoir à l'avance combien de garnitures une personne voudra.
La fonction de l'exemple suivant a un paramètre, * garnitures, mais ce paramètre recueille autant
d'arguments que la ligne appelante en fournit:

pizza.py def make_pizza (* garnitures):


"" "Imprimer la liste des garnitures qui ont été demandées." "" Imprimer (garnitures)

make_pizza ('pepperoni')
make_pizza ('champignons', 'poivrons verts', 'extra fromage')

L'astérisque dans le nom du paramètre * garnitures dit à Python de créer un tuple vide appelé garnitures et
emballer toutes les valeurs qu'il reçoit dans ce tuple. Le impression L'instruction dans le corps de la fonction
produit une sortie montrant que Python peut gérer un appel de fonction avec une valeur et un appel avec
trois valeurs. Il traite les différents appels de la même manière. Notez que Python emballe les arguments
dans un tuple, même si la fonction ne reçoit qu'une seule valeur:

('pepperoni',)
('champignons', 'poivrons verts', 'extra fromage')

Maintenant, nous pouvons remplacer le impression instruction avec une boucle qui parcourt la liste
des garnitures et décrit la pizza commandée:

def make_pizza (* garnitures):


"" "Résumez la pizza que nous sommes sur le point de faire." "" Print ("\ nFaire
une pizza avec les garnitures suivantes:") pour garnir les garnitures:

impression ("-" + garniture)

make_pizza ('pepperoni')
make_pizza ('champignons', 'poivrons verts', 'extra fromage')

La fonction répond de manière appropriée, qu'elle reçoive une ou trois valeurs:

Faire une pizza avec les garnitures suivantes:


- pepperoni

Faire une pizza avec les garnitures suivantes:


- champignons

- poivrons verts
- fromage supplémentaire

Les fonctions 151


Cette syntaxe fonctionne quel que soit le nombre d'arguments reçus par la fonction.

Mélange d'arguments positionnels et arbitraires

Si vous souhaitez qu'une fonction accepte plusieurs types d'arguments différents, le paramètre qui
accepte un nombre arbitraire d'arguments doit être placé en dernier dans la définition de la fonction.
Python fait d'abord correspondre les arguments de position et de mot-clé, puis collecte tous les
arguments restants dans le paramètre final.

Par exemple, si la fonction doit prendre une taille pour la pizza, ce paramètre doit
venir avant le paramètre * garnitures:

def make_pizza (taille, * garnitures):


"" "Résumez la pizza que nous sommes sur le point de faire." ""
print ("\ nCréation d'un" + str (taille) +
"une pizza en pouces avec les garnitures suivantes:")
pour garnir les garnitures:
impression ("-" + garniture)

make_pizza (16, 'pepperoni')


make_pizza (12, 'champignons', 'poivrons verts', 'extra fromage')

Dans la définition de fonction, Python stocke la première valeur qu'il reçoit dans le paramètre Taille. Toutes
les autres valeurs qui suivent sont stockées dans le tuple
garnitures. Les appels de fonction incluent d'abord un argument pour la taille, suivi d'autant de garnitures
que nécessaire.
Maintenant, chaque pizza a une taille et un certain nombre de garnitures, et chaque information est
imprimée au bon endroit, montrant la taille en premier et les garnitures après:

Faire une pizza de 16 pouces avec les garnitures suivantes:


- pepperoni

Faire une pizza de 12 pouces avec les garnitures suivantes:


- champignons

- poivrons verts
- fromage supplémentaire

Utilisation d'arguments de mots-clés arbitraires

Parfois, vous voudrez accepter un nombre arbitraire d'arguments, mais vous ne saurez pas à l'avance
quel type d'informations sera passé à la fonction. Dans ce cas, vous pouvez écrire des fonctions qui
acceptent autant de paires clé-valeur que le fournit l'instruction appelante. Un exemple consiste à créer
des profils d'utilisateurs: vous savez que vous obtiendrez des informations sur un utilisateur, mais vous
ne savez pas quel type d'informations vous recevrez. La fonction build_profile () dans le

152 Chapitre 8
L'exemple suivant prend toujours un prénom et un nom, mais il accepte également un nombre
arbitraire d'arguments de mot-clé:

user_profile.py def build_profile (premier, dernier, ** user_info):


"" "Créez un dictionnaire contenant tout ce que nous savons sur un utilisateur." "" Profile = {}

u profile ['first_name'] = premier


profile ['last_name'] = dernier
v pour la clé, valeur dans user_info.items ():
profil [clé] = valeur
profil de retour

user_profile = build_profile ('albert', 'einstein',


location = 'princeton',
field = 'physique')
print (profil_utilisateur)

La définition de build_profile () attend un prénom et un nom, puis il permet à l'utilisateur de transmettre


autant de paires nom-valeur qu'il le souhaite. Les doubles astérisques avant le paramètre ** informations
utilisateur amener Python à créer un dictionnaire vide appelé informations utilisateur et emballer toutes les paires
nom-valeur qu'il reçoit dans ce dictionnaire. Dans la fonction, vous pouvez accéder aux paires nomvaleur
dans informations utilisateur comme vous le feriez pour n'importe quel dictionnaire.

Dans le corps de build_profile (), nous faisons un dictionnaire vide appelé


profil pour contenir le profil de l'utilisateur. À u nous ajoutons le prénom et le nom à ce dictionnaire car
nous recevrons toujours ces deux informations de l'utilisateur. À v nous parcourons les paires clé-valeur
supplémentaires dans le dictionnaire informations utilisateur et ajoutez chaque paire au profil dictionnaire.
Enfin, nous retournons le profil dictionnaire vers la ligne d'appel de fonction.

Nous appelons build_profile (), en lui passant le prénom ' albert ', le nom de famille ' einstein
', et les deux paires clé-valeur location = 'princeton' et
field = 'physique'. Nous stockons le retour profil dans profil de l'utilisateur et imprimer
profil de l'utilisateur:

{'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field':


'physique'}

Le dictionnaire renvoyé contient le prénom et le nom de l'utilisateur et, dans ce cas, le lieu et
le domaine d'étude également. La fonction fonctionnerait quel que soit le nombre de paires
clé-valeur supplémentaires fournies dans l'appel de fonction.

Vous pouvez mélanger des valeurs de position, de mot-clé et arbitraires de différentes manières lors de
l'écriture de vos propres fonctions. Il est utile de savoir que tous ces types d'arguments existent car vous les verrez
souvent lorsque vous commencerez à lire le code d'autres personnes. Il faut de la pratique pour apprendre à utiliser
correctement les différents types et pour savoir quand utiliser chaque type. Pour l'instant, n'oubliez pas d'utiliser
l'approche la plus simple pour faire le travail. Au fur et à mesure que vous progressez, vous apprendrez à utiliser
l'approche la plus efficace à chaque fois.

Les fonctions 153


essayez-le vous-même

8-12. Sandwichs: Écrivez une fonction qui accepte une liste d'articles qu'une personne veut sur un
sandwich. La fonction doit avoir un paramètre qui collecte autant d'éléments que l'appel de fonction
fournit, et elle doit imprimer un résumé du sandwich qui est commandé. Appelez la fonction trois fois, en
utilisant un nombre d'arguments différent à chaque fois.

8-13. Profil de l'utilisateur: Commencez avec une copie de user_profile.py à partir de la page 153. Créez un profil de

vous-même en appelant build_profile (), en utilisant vos nom et prénom et trois autres paires clé-valeur qui vous

décrivent.

8-14. Voitures: Écrivez une fonction qui stocke des informations sur une voiture dans un dictionnaire. La

fonction doit toujours recevoir un fabricant et un nom de modèle. Il doit alors accepter un nombre arbitraire

d'arguments de mot-clé. Appelez la fonction avec les informations requises et deux autres paires nom-valeur,

telles qu'une couleur ou une fonction facultative. Votre fonction devrait fonctionner pour un appel comme

celui-ci:

voiture = make_car ('subaru', 'outback', color = 'blue', tow_package = True)

Imprimez le dictionnaire renvoyé pour vous assurer que toutes les informations ont été correctement stockées.

stocker vos fonctions dans des modules

L'un des avantages des fonctions est la façon dont elles séparent les blocs de code de votre programme
principal. En utilisant des noms descriptifs pour vos fonctions, votre programme principal sera beaucoup
plus facile à suivre. Vous pouvez aller plus loin en stockant vos fonctions dans un fichier séparé appelé module
puis importation
ce module dans votre programme principal. Une importer indique à Python de rendre le code d'un module
disponible dans le fichier programme en cours d'exécution.
Le stockage de vos fonctions dans un fichier séparé vous permet de masquer les détails du code de votre programme

et de vous concentrer sur sa logique de niveau supérieur. Il vous permet également de réutiliser des fonctions dans de

nombreux programmes différents. Lorsque vous stockez vos fonctions dans des fichiers séparés, vous pouvez partager ces

fichiers avec d'autres programmeurs sans avoir à partager l'intégralité de votre programme. Savoir comment importer des

fonctions vous permet également d'utiliser des bibliothèques de fonctions que d'autres programmeurs ont écrites.

Il existe plusieurs façons d'importer un module, et je vais vous montrer chacune d'elles brièvement.

Importer un module entier

Pour commencer à importer des fonctions, nous devons d'abord créer un module. UNE module

est un fichier se terminant par. py qui contient le code que vous souhaitez importer dans votre

154 Chapitre 8
programme. Faisons un module qui contient la fonction make_pizza (). Pour créer ce module, nous
supprimerons tout du fichier pizza.py à l'exception du
fonction make_pizza ():

pizza.py def make_pizza (taille, * garnitures):


"" "Résumez la pizza que nous sommes sur le point de faire." "" Print ("\
nCréation d'un" + str (taille) +
"pizza en pouces avec les garnitures suivantes:") pour garnir les
garnitures:
impression ("-" + garniture)

Maintenant, nous allons créer un fichier séparé appelé making_pizzas.py dans le même répertoire que pizza.py.
Ce fichier importe le module que nous venons de créer puis effectue deux appels à make_pizza ():

fabrication_ importer une pizza

pizzas.py
u pizza.make_pizza (16, 'pepperoni')
pizza.make_pizza (12, 'champignons', 'poivrons verts', 'extra fromage')

Lorsque Python lit ce fichier, la ligne importer une pizza dit à Python d'ouvrir le fichier pizza.py et copiez
toutes les fonctions de celui-ci dans ce programme. Vous ne voyez pas réellement de code copié entre
les fichiers car Python copie le code en arrière-plan pendant que le programme s'exécute. Tout ce que
vous devez savoir, c'est que toute fonction définie dans pizza.py sera désormais disponible dans

making_pizzas.py.
Pour appeler une fonction depuis un module importé, saisissez le nom du module que
vous avez importé, Pizza, suivi du nom de la fonction,
faire_pizza (), séparés par un point u. Ce code produit la même sortie que le programme
d'origine qui n'a pas importé de module:

Faire une pizza de 16 pouces avec les garnitures suivantes:


- pepperoni

Faire une pizza de 12 pouces avec les garnitures suivantes:


- champignons

- poivrons verts
- fromage supplémentaire

Cette première approche de l'importation, dans laquelle vous écrivez simplement importer suivi du
nom du module, rend toutes les fonctions du module disponibles dans votre programme. Si vous
utilisez ce type de importer instruction pour importer un module entier nommé nom_module.py, chaque
fonction du module est disponible via la syntaxe suivante:

nom_module.fonction_nom ()

Les fonctions 155


Importer des fonctions spécifiques

Vous pouvez également importer une fonction spécifique à partir d'un module. Voici la syntaxe générale de cette
approche:

de nom_module importer nom_fonction

Vous pouvez importer autant de fonctions que vous le souhaitez à partir d'un module en séparant le nom de
chaque fonction par une virgule:

de nom_module importer fonction_0, fonction_1, fonction_2

Le making_pizzas.py L'exemple ressemblerait à ceci si nous voulons importer uniquement la fonction que
nous allons utiliser:

à partir de l'importation de pizza make_pizza

make_pizza (16, 'pepperoni')


make_pizza (12, 'champignons', 'poivrons verts', 'extra fromage')

Avec cette syntaxe, vous n'avez pas besoin d'utiliser la notation par points lorsque vous appelez une fonction.
Parce que nous avons importé explicitement la fonction faire_pizza () dans le
importer déclaration, nous pouvons l'appeler par son nom lorsque nous utilisons la fonction.

Utiliser as pour attribuer un alias à une fonction

Si le nom d'une fonction que vous importez peut entrer en conflit avec un nom existant dans votre
programme ou si le nom de la fonction est long, vous pouvez utiliser un nom court et unique alias : Un
autre nom similaire à un surnom pour la fonction. Vous attribuerez à la fonction ce surnom spécial
lorsque vous importerez la fonction.

Ici nous donnons la fonction faire_pizza () un alias, mp (), en important


make_pizza comme mp. Le comme mot-clé renomme une fonction en utilisant l'alias que vous fournissez:

à partir de l'importation de pizza make_pizza en tant que mp

mp (16, «pepperoni»)
mp (12, 'champignons', 'poivrons verts', 'extra fromage')

Le importer l'instruction montrée ici renomme la fonction faire_pizza () à


mp () dans ce programme. Chaque fois que nous voulons appeler faire_pizza () on peut simplement écrire mp () à la
place, et Python exécutera le code dans faire_pizza () tout en évitant toute confusion avec un autre faire_pizza () fonction
que vous avez peut-être écrite dans ce fichier programme.

La syntaxe générale pour fournir un alias est:

de nom_module importer nom_fonction comme fn

156 Chapitre 8
Utiliser as pour attribuer un alias à un module

Vous pouvez également fournir un alias pour un nom de module. Donner à un module un alias court, comme p pour Pizza,
vous permet d'appeler plus rapidement les fonctions du module.
Appel p.make_pizza () est plus concis que d'appeler pizza.make_pizza ():

importer la pizza en tant que p

p.make_pizza (16, 'pepperoni')


p.make_pizza (12, 'champignons', 'poivrons verts', 'extra fromage')

Le module Pizza reçoit l'alias p dans le importer mais toutes les fonctions du module conservent
leurs noms d'origine. Appeler les fonctions en écrivant p.make_pizza () n'est pas seulement plus concis
que l'écriture pizza.make_pizza (),
mais redirige également votre attention du nom du module et vous permet de vous concentrer sur les
noms descriptifs de ses fonctions. Ces noms de fonction, qui vous indiquent clairement ce que fait
chaque fonction, sont plus importants pour la lisibilité de votre code que l'utilisation du nom complet du
module.
La syntaxe générale de cette approche est:

importer nom_module comme mn

Importation de toutes les fonctions d'un module

Vous pouvez dire à Python d'importer chaque fonction d'un module en utilisant l'opérateur astérisque (*):

de l'importation de pizza *

make_pizza (16, 'pepperoni')


make_pizza (12, 'champignons', 'poivrons verts', 'extra fromage')

L'astérisque dans le importer l'instruction dit à Python de copier chaque fonction du module Pizza dans
ce fichier programme. Étant donné que chaque fonction est importée, vous pouvez appeler chaque
fonction par son nom sans utiliser la notation par points. Cependant, il est préférable de ne pas utiliser
cette approche lorsque vous travaillez avec des modules plus volumineux que vous n'avez pas écrits: si le
module a un nom de fonction qui correspond à un nom existant dans votre projet, vous pouvez obtenir des
résultats inattendus. Python peut voir plusieurs fonctions ou variables avec le même nom, et au lieu
d'importer toutes les fonctions séparément, il écrasera les fonctions.

La meilleure approche consiste à importer la ou les fonctions souhaitées, ou à importer le module


entier et à utiliser la notation par points. Cela conduit à un code clair, facile à lire et à comprendre. J'inclus
cette section pour que vous reconnaissiez importer des déclarations comme les suivantes lorsque vous les
voyez dans le code d'autres personnes:

de nom_module importer *

Les fonctions 157


fonctions de style
Vous devez garder quelques détails à l'esprit lorsque vous stylisez des fonctions. Les fonctions doivent avoir des
noms descriptifs, et ces noms doivent utiliser des lettres minuscules et des traits de soulignement. Les noms
descriptifs vous aident, vous et les autres, à comprendre ce que votre code essaie de faire. Les noms de module
doivent également utiliser ces conventions.

Chaque fonction doit avoir un commentaire qui explique de manière concise ce que fait la
fonction. Ce commentaire doit apparaître immédiatement après la définition de la fonction et utiliser
le format docstring. Dans une fonction bien documentée, d'autres programmeurs peuvent utiliser la
fonction en ne lisant que la description dans la docstring. Ils devraient pouvoir être sûrs que le code
fonctionne comme décrit, et tant qu'ils connaissent le nom de la fonction, les arguments dont elle a
besoin et le type de valeur qu'elle renvoie, ils devraient pouvoir l'utiliser dans leurs programmes.

Si vous spécifiez une valeur par défaut pour un paramètre, aucun espace ne doit être utilisé de chaque
côté du signe égal:

def nom_fonction (paramètre_0, paramètre_1 = 'valeur par défaut')

La même convention doit être utilisée pour les arguments de mot-clé dans les appels de fonction:

nom_fonction (valeur_0, paramètre_1 = 'valeur')

PEP 8 ( https://www.python.org/dev/peps/pep-0008/) vous recommande de limiter les lignes de code à


79 caractères afin que chaque ligne soit visible dans une fenêtre d'éditeur de taille raisonnable. Si un
ensemble de paramètres fait que la définition d'une fonction dépasse 79 caractères, appuyez sur Entrer après
la parenthèse ouvrante sur la ligne de définition. Sur la ligne suivante, appuyez sur languette deux fois pour
séparer la liste des arguments du corps de la fonction, qui ne sera en retrait que d'un niveau.

La plupart des éditeurs alignent automatiquement toutes les lignes supplémentaires de paramètres pour correspondre

à l'indentation que vous avez établie sur la première ligne:

def nom_fonction (
paramètre_0, paramètre_1, paramètre_2,
paramètre_3, paramètre_4, paramètre_5):
corps de fonction ...

Si votre programme ou module a plus d'une fonction, vous pouvez séparer chacune par deux lignes
vides pour vous permettre de voir plus facilement où une fonction se termine et la suivante commence.

Tout importer les instructions doivent être écrites au début d'un fichier. La seule exception est si
vous utilisez des commentaires au début de votre fichier pour décrire l'ensemble du programme.

158 Chapitre 8
essayez-le vous-même

8-15. Modèles d'impression: Mettez les fonctions pour l'exemple print_models.py dans un fichier séparé appelé Printing_functions.py.

Écrire un importer déclaration en haut de print_models.py, et modifiez le fichier pour utiliser les fonctions

importées.

8-16. Importations: À l'aide d'un programme que vous avez écrit et qui contient une fonction, stockez cette fonction dans un

fichier séparé. Importez la fonction dans votre fichier programme principal et appelez la fonction en utilisant chacune de ces

approches:

importer nom_module
de nom_module importer nom_fonction
de nom_module importer nom_fonction comme fn
importer nom_module comme mn

de nom_module importer *

8-17. Fonctions de style: Choisissez les trois programmes que vous avez écrits pour ce chapitre et assurez-vous

qu'ils suivent les directives de style décrites dans cette section.

résumé
Dans ce chapitre, vous avez appris à écrire des fonctions et à transmettre des arguments afin que vos fonctions
aient accès aux informations dont elles ont besoin pour faire leur travail. Vous avez appris à utiliser des arguments
de position et de mots-clés et à accepter un nombre arbitraire d'arguments. Vous avez vu des fonctions qui
affichent la sortie et des fonctions qui renvoient des valeurs. Vous avez appris à utiliser des fonctions avec des
listes, des dictionnaires, si déclarations, et tandis que boucles. Vous avez également vu comment stocker vos
fonctions dans des fichiers séparés appelés modules, ainsi vos fichiers de programme seront plus simples et plus
faciles à comprendre. Enfin, vous avez appris à styliser vos fonctions afin que vos programmes continuent d'être
bien structurés et aussi faciles que possible à lire pour vous et les autres.

L'un de vos objectifs en tant que programmeur devrait être d'écrire un code simple qui fait ce que vous voulez,
et des fonctions vous aident à le faire. Ils vous permettent d'écrire des blocs de code et de les laisser seuls une fois
que vous savez qu'ils fonctionnent. Lorsque vous savez qu'une fonction fait correctement son travail, vous pouvez être
sûr qu'elle continuera à fonctionner et passera à votre prochaine tâche de codage.

Les fonctions vous permettent d'écrire du code une fois, puis de réutiliser ce code autant de fois que vous le
souhaitez. Lorsque vous avez besoin d'exécuter le code dans une fonction, tout ce que vous avez à faire est
d'écrire un appel sur une ligne et la fonction fait son travail. Lorsque vous devez modifier le comportement d'une
fonction, vous n'avez qu'à modifier un bloc de code, et votre modification prend effet partout où vous avez fait un
appel à cette fonction.

L'utilisation de fonctions facilite la lecture de vos programmes et les bons noms de fonction résument ce
que fait chaque partie d'un programme. La lecture d'une série d'appels de fonction vous donne une idée
beaucoup plus rapide de ce que fait un programme que la lecture d'une longue série de blocs de code.

Les fonctions 159


Les fonctions facilitent également le test et le débogage de votre code. Lorsque la majeure partie du travail de
votre programme est effectuée par un ensemble de fonctions, dont chacune a un travail spécifique, il est beaucoup plus
facile de tester et de maintenir le code que vous avez écrit. Vous pouvez écrire un programme distinct qui appelle
chaque fonction et teste si chaque fonction fonctionne dans toutes les situations qu'elle peut rencontrer. Lorsque vous
faites cela, vous pouvez être sûr que vos fonctions fonctionneront correctement chaque fois que vous les appelez.

Au chapitre 9, vous apprendrez à écrire des cours. Des classes combinez les fonctions et les données dans un
package soigné qui peut être utilisé de manière flexible et efficace.

160 Chapitre 8
9
Des classes

Programmation orientée objet est l'un des


les approches les plus efficaces pour écrire des logiciels. Dans la
programmation orientée objet, vous écrivez Des classes qui représentent des
choses et des situations du monde réel, et vous créez objets basé sur ces
classes. Lorsque vous écrivez une classe, vous définissez le comportement
général que toute une catégorie d'objets peut avoir.

Lorsque vous créez des objets individuels à partir de la classe, chaque objet est automatiquement équipé du
comportement général; vous pouvez alors donner à chaque objet les traits uniques que vous désirez. Vous serez
étonné de voir à quel point des situations du monde réel peuvent être modélisées avec une programmation
orientée objet.
Créer un objet à partir d'une classe s'appelle instanciation, et vous travaillez avec
les instances d'une classe. Dans ce chapitre, vous allez écrire des classes et créer des instances de ces classes. Vous
spécifierez le type d'informations qui peuvent être stockées dans les instances, et vous définirez les actions qui peuvent
être entreprises avec ces instances. Vous allez également écrire des classes qui étendent les fonctionnalités des
classes existantes, donc
des classes similaires peuvent partager le code efficacement. Vous stockerez vos classes dans des modules et

importerez des classes écrites par d'autres programmeurs dans vos propres fichiers programme.

Comprendre la programmation orientée objet vous aidera à voir le monde comme le fait un programmeur. Cela vous
aidera à vraiment connaître votre code, non seulement ce qui se passe ligne par ligne, mais aussi les concepts plus
importants qui le sous-tendent. Connaître la logique derrière les classes vous apprendra à penser logiquement afin que
vous puissiez écrire des programmes qui résolvent efficacement presque tous les problèmes que vous rencontrez.

Les cours facilitent également la vie de vous et des autres programmeurs avec lesquels vous devrez
travailler pour relever des défis de plus en plus complexes. Lorsque vous et d'autres programmeurs écrivez
du code basé sur le même type de logique, vous serez en mesure de comprendre le travail de chacun. Vos
programmes auront du sens pour de nombreux collaborateurs, permettant à chacun d'accomplir plus.

Créer et utiliser une classe


Vous pouvez modéliser presque tout en utilisant des classes. Commençons par écrire une classe simple, Chien, cela
représente un chien - pas un chien en particulier, mais n'importe quel chien. Que savons-nous de la plupart des
chiens de compagnie? Eh bien, ils ont tous un nom et un âge. Nous savons également que la plupart des chiens
s'assoient et se retournent. Ces deux informations (nom et âge) et ces deux comportements (s'asseoir et se
retourner) iront dans notre Chien classe parce qu'ils sont communs à la plupart des chiens. Cette classe dira à Python
comment créer un objet représentant un chien. Une fois notre classe écrite, nous l'utiliserons pour créer des instances
individuelles, chacune représentant un chien spécifique.

Création de la classe de chien

Chaque instance créée à partir du Chien la classe stockera un Nom Et un âge, et nous donnerons à chaque
chien la possibilité de s'asseoir() et rouler():

dog.py u Chien de classe ():


v "" "Une simple tentative de modeler un chien." ""

w def __init __ (soi, nom, âge):


"" "Initialise les attributs de nom et d'âge." "" Self.name = nom
X
self.age = âge

y def sit (soi):


"" "Simule un chien assis en réponse à une commande." "" Print (self.name.title ()
+ "est maintenant assis.")

def roll_over (soi-même):


"" "Simule le retournement en réponse à une commande." "" Print
(self.name.title () + "rolled over!")

162 Chapitre 9
Il y a beaucoup de choses à remarquer ici, mais ne vous inquiétez pas. Vous verrez cette structure tout au long
de ce chapitre et aurez beaucoup de temps pour vous y habituer. À u nous définissons une classe appelée Chien. Par
convention, les noms en majuscules font référence aux classes en Python. Les parenthèses dans la définition de
classe sont vides car nous créons cette classe à partir de zéro. À v nous écrivons une docstring décrivant ce que fait
cette classe.

la méthode __init __ ()

Une fonction qui fait partie d'une classe est une méthode. Tout ce que vous avez appris sur les fonctions s'applique
également aux méthodes; la seule différence pratique pour l'instant est la façon dont nous appellerons les méthodes. Le __ init
__ () méthode à w est une méthode spéciale Python s'exécute automatiquement chaque fois que nous créons une nouvelle
instance basée sur le
Chien classer. Cette méthode a deux traits de soulignement et deux traits de soulignement de fin, une convention
qui permet d'éviter que les noms de méthode par défaut de Python n'entrent en conflit avec vos noms de
méthode.
Nous définissons le __ init __ () méthode pour avoir trois paramètres: soi, nom,
et âge. Le soi Le paramètre est obligatoire dans la définition de la méthode et doit précéder les
autres paramètres. Il doit être inclus dans la définition car lorsque Python appelle cela __ init __ () plus
tard (pour créer une instance de Chien), l'appel de méthode passera automatiquement le soi argument.
Chaque appel de méthode associé à une classe passe automatiquement soi, lequel

est une référence à l'instance elle-même; il donne à chaque instance un accès aux attributs et
méthodes de la classe. Lorsque nous faisons une instance de Chien,
Python appellera le __ init __ () méthode de la Chien classer. Nous passerons Chien()
un nom et un âge comme arguments; soi est passé automatiquement, nous n'avons donc pas besoin de le passer.
Chaque fois que nous voulons créer une instance à partir du Chien class, nous fournirons des valeurs uniquement pour les
deux derniers paramètres, Nom et âge.
Les deux variables définies à X chacun a le préfixe soi. Toute variable préfixée par soi est disponible
pour toutes les méthodes de la classe, et nous pourrons également accéder à ces variables via n'importe
quelle instance créée à partir de la classe.
self.name = nom prend la valeur stockée dans le paramètre Nom et le stocke dans la variable Nom, qui est
ensuite attaché à l'instance en cours de création. Le même processus se produit avec self.age = âge. Les
variables accessibles via des instances comme celle-ci sont appelées les attributs.

Le Chien class a deux autres méthodes définies: s'asseoir() et rouler() y.


Parce que ces méthodes n'ont pas besoin d'informations supplémentaires comme un nom ou un âge, nous les
définissons simplement pour avoir un paramètre, soi. Les instances que nous créerons ultérieurement auront
accès à ces méthodes. En d'autres termes, ils pourront s'asseoir et se retourner. Pour le moment, s'asseoir() et rouler()
ne fais pas grand-chose. Ils impriment simplement un message indiquant que le chien est assis ou se retourne.
Mais le concept peut être étendu à des situations réalistes: si cette classe faisait partie d'un jeu vidéo réel, ces
méthodes contiendraient du code pour faire asseoir et se retourner un chien animé. Si cette classe était écrite
pour contrôler un robot, ces méthodes dirigeraient les mouvements qui amèneraient un robot chien à s'asseoir
et à se retourner.

Des classes 163


Création de classes dans Python 2.7

Lorsque vous créez une classe dans Python 2.7, vous devez apporter une modification mineure. Vous incluez le
terme objet entre parenthèses lorsque vous créez une classe:

classer Nom du cours( objet):


- - couper--

Cela permet aux classes Python 2.7 de se comporter davantage comme des classes Python 3, ce qui facilite
globalement votre travail.
Le Chien La classe serait définie comme ceci dans Python 2.7:

class Dog (objet):


- - couper--

Créer une instance à partir d'une classe

Considérez une classe comme un ensemble d'instructions sur la façon de créer une instance. La classe Chien est un

ensemble d'instructions qui indique à Python comment créer des instances individuelles représentant des chiens

spécifiques.

Faisons une instance représentant un chien spécifique:

Chien de classe ():

- - couper--

u my_dog = Chien ('willie', 6)

v print ("Le nom de mon chien est" + my_dog.name.title () + ".")


w print ("Mon chien a" + str (my_dog.age) + "ans.")

Le Chien La classe que nous utilisons ici est celle que nous venons d'écrire dans l'exemple
précédent. À u nous disons à Python de créer un chien dont le nom est ' Willie ' et dont l'âge est 6. Lorsque
Python lit cette ligne, il appelle le __ init __ () méthode dans Chien avec les arguments ' Willie ' et 6. Le __ init __ () crée
une instance représentant ce chien particulier et définit la Nom et âge attributs en utilisant les valeurs que
nous avons fournies. Le __ init __ () la méthode n'a pas d'explicite revenir

instruction, mais Python renvoie automatiquement une instance représentant ce chien. Nous stockons cette instance
dans la variable mon chien. La convention de dénomination est utile ici: nous pouvons généralement supposer qu'un nom
en majuscule comme Chien fait référence à une classe et à un nom en minuscule comme mon chien fait référence à une
seule instance créée à partir d'une classe.

accès aux attributs

Pour accéder aux attributs d'une instance, vous utilisez la notation par points. À v nous accédons à la valeur de mon
chien attribut de Nom en écrivant:

my_dog.name

La notation par points est souvent utilisée en Python. Cette syntaxe montre comment Python
trouve la valeur d'un attribut. Ici Python regarde l'instance mon chien

164 Chapitre 9
puis trouve l'attribut Nom associé à mon chien. C'est le même attribut appelé self.name dans la classe Chien.
À w nous utilisons la même approche pour travailler avec l'attribut âge. Dans notre premier impression déclaration,
my_dog.name.title ()

fait du ' willie ', la valeur de mon chien de Nom attribut, commencez par une majuscule. Dans la seconde impression déclaration,
str (mon_chien.age) convertit 6, la valeur de mon chien de âge
attribut, à une chaîne.
Le résultat est un résumé de ce que nous savons mon chien:

Le nom de mon chien est Willie.


Mon chien a 6 ans.

Méthodes d'appel

Après avoir créé une instance de la classe Chien, nous pouvons utiliser la notation par points pour appeler n'importe

quelle méthode définie dans Chien. Faisons asseoir notre chien et rouler:

Chien de classe ():

- - couper--

my_dog = Chien ('willie', 6)


mon_dog.sit ()
my_dog.roll_over ()

Pour appeler une méthode, donnez le nom de l'instance (dans ce cas, mon chien)
et la méthode que vous souhaitez appeler, séparés par un point. Quand Python lit
mon_dog.sit (), il cherche la méthode s'asseoir() dans la classe Chien et exécute ce code. Python
interprète la ligne my_dog.roll_over () de la même manière.
Maintenant, Willie fait ce que nous lui disons:

Willie est maintenant assis. Willie


s'est retourné!

Cette syntaxe est très utile. Lorsque les attributs et les méthodes ont reçu des noms
descriptifs appropriés comme nom, âge, assis (), et rouler(),
nous pouvons facilement déduire ce qu'un bloc de code, même celui que nous n'avons jamais vu auparavant, est censé

faire.

Création de plusieurs instances

Vous pouvez créer autant d'instances à partir d'une classe que vous le souhaitez. Créons un deuxième chien
appelé votre chien:

Chien de classe ():

- - couper--

my_dog = Chien ('willie', 6) votre_dog


= Chien ('lucy', 3)

print ("Le nom de mon chien est" + my_dog.name.title () + ".") print ("Mon chien
a" + str (my_dog.age) + "years old.") my_dog.sit ()

Des classes 165


print ("\ nLe nom de votre chien est" + your_dog.name.title () + ".") print ("Votre chien a" +
str (your_dog.age) + "years old.") your_dog.sit ()

Dans cet exemple, nous créons un chien nommé Willie et un chien nommé Lucy. Chaque chien est une
instance distincte avec son propre ensemble d'attributs, capable du même ensemble d'actions:

Le nom de mon chien est Willie.


Mon chien a 6 ans. Willie est
maintenant assis.

Le nom de votre chien est Lucy.


Votre chien a 3 ans. Lucy est
maintenant assise.

Même si nous utilisions le même nom et le même âge pour le deuxième chien, Python créerait toujours
une instance distincte du Chien classer. Vous pouvez créer autant d'instances d'une classe que vous le
souhaitez, tant que vous donnez à chaque instance un nom de variable unique ou qu'elle occupe une place
unique dans une liste ou un dictionnaire.

essayez-le vous-même

9-1. Le restaurant: Faire une classe appelée Le restaurant . Le __ init __ () méthode pour

Le restaurant devrait stocker deux attributs: a restaurant_name et un cuisine_type.


Créez une méthode appelée describe_restaurant () qui imprime ces deux informations, et une méthode
appelée open_restaurant () qui imprime un message indiquant que le restaurant est ouvert.

Créer une instance appelée le restaurant de votre classe. Imprimez les deux attributs individuellement,

puis appelez les deux méthodes.

9-2. Trois restaurants: Commencez par votre classe à partir de l'exercice 9-1. Créez trois instances

différentes de la classe et appelez describe_restaurant () pour chaque instance.

9-3. Utilisateurs: Faire une classe appelée Utilisateur . Créez deux attributs appelés Prénom

et nom de famille, puis créez plusieurs autres attributs généralement stockés dans un profil utilisateur. Créez une

méthode appelée describe_user () qui imprime un résumé des informations de l'utilisateur. Faites une autre méthode

appelée Greet_user () qui imprime un message d'accueil personnalisé à l'utilisateur.

Créez plusieurs instances représentant différents utilisateurs et appelez les deux méthodes pour chaque utilisateur.

166 Chapitre 9
travailler avec des classes et des instances

Vous pouvez utiliser des classes pour représenter de nombreuses situations du monde réel. Une fois que vous avez écrit

une classe, vous passerez la plupart de votre temps à travailler avec des instances créées à partir de cette classe. L'une

des premières tâches que vous voudrez faire est de modifier les attributs associés à une instance particulière. Vous pouvez

modifier les attributs d'une instance directement ou écrire des méthodes qui mettent à jour les attributs de manière

spécifique.

La classe de voiture

Écrivons une nouvelle classe représentant une voiture. Notre classe stockera des informations sur le type
de voiture avec lequel nous travaillons et disposera d'une méthode qui résume ces informations:

car.py Voiture de classe ():

"" "Une simple tentative de représenter une voiture." ""

u def __init __ (soi, marque, modèle, année):


"" "Initialisez les attributs pour décrire une voiture." "" Self.make =
make
self.model = modèle
self.year = année

v def get_descriptive_name (soi):


"" "Renvoie un nom descriptif parfaitement formaté." ""
long_name = str (self.year) + '' + self.make + '' + self.model return long_name.title ()

w my_new_car = Voiture ('audi', 'a4', 2016)


print (ma_nouvelle_car.get_nom_descriptif ())

À u dans le Auto classe, nous définissons le __ init __ () méthode avec la soi


paramètre d'abord, comme nous l'avons fait auparavant avec notre Chien classer. Nous lui donnons
également trois autres paramètres: faire, modèle, et an. Le __ init __ () La méthode prend ces paramètres et les
stocke dans les attributs qui seront associés aux instances créées à partir de cette classe. Quand on fait
un nouveau Auto
exemple, nous devrons spécifier une marque, un modèle et une année pour notre instance.
À v nous définissons une méthode appelée get_descriptive_name () qui met une voiture
année, faire, et maquette en une seule chaîne décrivant parfaitement la voiture. Cela nous évitera d'avoir à imprimer
la valeur de chaque attribut individuellement. Pour travailler avec les valeurs d'attribut dans cette méthode, nous
utilisons self.make, self.model, et auto.année.
À w nous créons une instance à partir du Auto class et stockez-le dans la variable
ma nouvelle voiture. Puis nous appelons get_descriptive_name () pour montrer quel type de voiture
on a:

Audi A4 2016

Pour rendre la classe plus intéressante, ajoutons un attribut qui change avec le temps. Nous
ajouterons un attribut qui stocke le kilométrage global de la voiture.

Des classes 167


Définition d'une valeur par défaut pour un attribut

Chaque attribut d'une classe a besoin d'une valeur initiale, même si cette valeur est 0 ou une chaîne vide.
Dans certains cas, comme lors de la définition d'une valeur par défaut, il est logique de spécifier cette valeur
initiale dans le corps du __ init __ () méthode; si vous faites cela pour un attribut, vous n'avez pas besoin
d'inclure un paramètre pour cet attribut.

Ajoutons un attribut appelé Relevé du compteur kilométrique qui commence toujours par une valeur de 0. Nous

ajouterons également une méthode read_odometer () qui nous aide à lire le compteur kilométrique de chaque voiture:

Voiture de classe ():

def __init __ (soi, marque, modèle, année):


"" "Initialisez les attributs pour décrire une voiture." "" Self.make =
make
self.model = modèle
self.year = année
u self.odometer_reading = 0

def get_descriptive_name (soi):


- - couper--

v def read_odometer (self):


"" "Imprimez un relevé indiquant le kilométrage de la voiture." ""
print ("Cette voiture a" + str (self.odometer_reading) + "miles dessus.")

my_new_car = Voiture ('audi', 'a4', 2016) print


(my_new_car.get_descriptive_name ())
my_new_car.read_odometer ()

Cette fois, lorsque Python appelle le __ init __ () méthode pour créer une nouvelle instance, il stocke les
valeurs de marque, de modèle et d'année en tant qu'attributs comme dans l'exemple précédent. Puis Python
crée un nouvel attribut appelé Relevé du compteur kilométrique et définit sa valeur initiale sur 0 u. Nous avons
également une nouvelle méthode appelée read_odometer () à v cela facilite la lecture du kilométrage d'une
voiture.

Notre voiture démarre avec un kilométrage de 0:

Audi A4 2016
Cette voiture a 0 miles dessus.

Peu de voitures sont vendues avec exactement 0 miles au compteur, nous avons donc besoin d'un
moyen de modifier la valeur de cet attribut.

Modification des valeurs d'attribut

Vous pouvez modifier la valeur d'un attribut de trois manières: vous pouvez modifier la valeur
directement via une instance, définir la valeur via une méthode ou incrémenter la valeur (y ajouter un
certain montant) via une méthode. Regardons chacune de ces approches.

168 Chapitre 9
Modification directe de la valeur d'un attribut

Le moyen le plus simple de modifier la valeur d'un attribut est d'accéder directement à l'attribut via une
instance. Ici, nous réglons directement la lecture du compteur kilométrique à 23:

Voiture de classe ():

- - couper--

my_new_car = Voiture ('audi', 'a4', 2016) print


(my_new_car.get_descriptive_name ())

u my_new_car.odometer_reading = 23
my_new_car.read_odometer ()

À u nous utilisons la notation par points pour accéder à la voiture Relevé du compteur kilométrique attribut et

définissez sa valeur directement. Cette ligne indique à Python de prendre l'instance

ma nouvelle voiture, trouver l'attribut Relevé du compteur kilométrique associé et définissez la valeur de cet
attribut sur 23:

Audi A4 2016
Cette voiture a 23 miles dessus.

Parfois, vous voudrez accéder directement à des attributs comme celui-ci, mais d'autres fois, vous
voudrez écrire une méthode qui met à jour la valeur pour vous.

Modification de la valeur d'un attribut via une méthode

Il peut être utile de disposer de méthodes qui mettent à jour certains attributs pour vous. Au lieu
d'accéder directement à l'attribut, vous transmettez la nouvelle valeur à une méthode qui gère la mise à
jour en interne.
Voici un exemple montrant une méthode appelée update_odometer ():

Voiture de classe ():

- - couper--

u def update_odometer (soi, kilométrage):


"" "Réglez la lecture de l'odomètre à la valeur donnée." ""
Self.odometer_reading = kilométrage

my_new_car = Voiture ('audi', 'a4', 2016) print


(my_new_car.get_descriptive_name ())

v mon_nouveau_car.update_odomètre (23)
my_new_car.read_odometer ()

La seule modification de Auto est l'ajout de update_odometer () à u.


Cette méthode prend une valeur de kilométrage et la stocke dans self.odometer_reading.
À v nous appelons update_odometer () et donnez-le 23 comme argument (correspondant

Des classes 169


à la kilométrage paramètre dans la définition de la méthode). Il règle la lecture de l'odomètre à 23,
et read_odometer () imprime la lecture:

Audi A4 2016
Cette voiture a 23 miles dessus.

Nous pouvons étendre la méthode update_odometer () pour effectuer un travail supplémentaire chaque fois que le

relevé du compteur kilométrique est modifié. Ajoutons un peu de logique pour nous assurer que personne n'essaie de

reculer le relevé du compteur kilométrique:

Voiture de classe ():

- - couper--

def update_odometer (soi, kilométrage):


"" "
Réglez la lecture de l'odomètre à la valeur donnée.
Rejetez le changement s'il tente de faire reculer le compteur kilométrique. "" "

u si kilométrage> = self.odometer_reading:
self.odometer_reading = kilométrage
autre:
v print ("Vous ne pouvez pas reculer un compteur kilométrique!")

À présent update_odometer () vérifie que la nouvelle lecture a du sens avant de modifier l'attribut. Si le nouveau
kilométrage, kilométrage, est supérieur ou égal au kilométrage existant, self.odometer_reading, vous pouvez mettre à jour la
lecture de l'odomètre au nouveau kilométrage u. Si le nouveau kilométrage est inférieur au kilométrage existant, vous
recevrez un avertissement indiquant que vous ne pouvez pas reculer un compteur kilométrique. v.

Incrémenter la valeur d'un attribut via une méthode

Parfois, vous souhaiterez incrémenter la valeur d'un attribut d'un certain montant plutôt que de définir une valeur
entièrement nouvelle. Disons que nous achetons une voiture d'occasion et que nous y passons 100 miles entre le

moment où nous l'achetons et le moment où nous l'enregistrons. Voici une méthode qui nous permet de passer ce

montant incrémentiel et d'ajouter cette valeur à la lecture du compteur kilométrique:

Voiture de classe ():

- - couper--

def update_odometer (soi, kilométrage):


- - couper--

u def increment_odometer (self, miles):


"" "Ajoutez le montant indiqué à la lecture de l'odomètre." ""
Self.odometer_reading + = miles

v my_used_car = Voiture ('subaru', 'outback', 2013)


print (my_used_car.get_descriptive_name ())

w my_used_car.update_odometer (23500)
my_used_car.read_odometer ()

170 Chapitre 9
X my_used_car.increment_odometer (100)
my_used_car.read_odometer ()

La nouvelle méthode incrément_odomètre () à u prend un certain nombre de miles et ajoute cette valeur à self.odometer_reading.
À v nous créons une voiture d'occasion,
ma_voiture_utilisée. Nous avons mis son odomètre à 23 500 en appelant update_odometer () et en le passant 23500 à w. À X nous
appelons incrément_odomètre () et passe-le 100 pour ajouter les 100 miles que nous avons parcourus entre l'achat de la
voiture et son enregistrement:

Subaru Outback 2013


Cette voiture a 23500 miles dessus. Cette
voiture a 23600 miles dessus.

Vous pouvez facilement modifier cette méthode pour rejeter les incréments négatifs afin que personne n'utilise
cette fonction pour reculer un odomètre.

Remarque Vous pouvez utiliser des méthodes comme celle-ci pour contrôler la manière dont les utilisateurs de votre programme mettent
à jour les valeurs telles qu'une lecture d'odomètre, mais toute personne ayant accès au programme peut définir la lecture
d'odomètre sur n'importe quelle valeur en accédant directement à l'attribut. Une sécurité efficace exige une attention extrême
aux détails en plus des vérifications de base comme celles présentées ici.

essayez-le vous-même

9-4. Nombre servi: Commencez par votre programme de l'exercice 9-1 (page 166). Ajoutez un attribut
appelé number_served avec une valeur par défaut de 0. Créez une instance appelée le restaurant de cette
classe. Imprimez le nombre de clients que le restaurant a servis, puis modifiez cette valeur et imprimez-la
à nouveau.
Ajoutez une méthode appelée set_number_served () qui vous permet de définir le nombre de clients qui ont

été servis. Appelez cette méthode avec un nouveau numéro et imprimez à nouveau la valeur.

Ajoutez une méthode appelée increment_number_served () qui vous permet d'augmenter le nombre de clients

qui ont été servis. Appelez cette méthode avec n'importe quel nombre de votre choix qui pourrait représenter le nombre

de clients qui ont été servis, par exemple, en une journée de travail.

9-5. Tentatives de connexion: Ajoutez un attribut appelé login_attempts à ton Utilisateur

classe de l'exercice 9-3 (page 166). Ecrire une méthode appelée increment_ login_attempts () qui
incrémente la valeur de login_attempts par 1. Écrivez une autre méthode appelée reset_login_attempts () qui
réinitialise la valeur de connexion_
tentatives à 0.
Créez une instance du Utilisateur classe et appel increment_login_attempts ()
plusieurs fois . Imprimer la valeur de login_attempts pour s'assurer qu'il a été incrémenté

correctement, puis appelez reset_login_attempts (). Impression login_attempts encore à

assurez-vous qu'il a été remis à 0.

Des classes 171


Héritage
Vous n'êtes pas toujours obligé de partir de zéro lorsque vous écrivez un cours. Si le cours que vous écrivez
est une version spécialisée d'un autre cours que vous avez écrit, vous pouvez utiliser héritage. Quand une
classe hérite d'un autre, il prend automatiquement tous les attributs et méthodes de la première classe. La
classe d'origine s'appelle le classe parent, et la nouvelle classe est la classe enfant. La classe enfant hérite de
chaque attribut et méthode de sa classe parent, mais est également libre de définir de nouveaux attributs et
méthodes qui lui sont propres.

La méthode __init __ () pour une classe enfant

La première tâche de Python lors de la création d'une instance à partir d'une classe enfant est d'attribuer des
valeurs à tous les attributs de la classe parent. Pour ce faire, le __ init __ ()
pour une classe enfant a besoin de l'aide de sa classe parent.
À titre d'exemple, modélisons une voiture électrique. Une voiture électrique est juste un type spécifique de voiture,

nous pouvons donc baser notre nouvelle Voiture électrique classe sur le Auto classe que nous avons écrite plus tôt. Ensuite,

nous n'aurons plus qu'à écrire du code pour les attributs et les comportements spécifiques aux voitures électriques.

Commençons par créer une version simple du Voiture électrique classe, qui fait tout le Auto
la classe fait:

electric_car.py u Voiture de classe ():


"" "Une simple tentative de représenter une voiture." ""

def __init __ (soi, marque, modèle, année):


self.make = faire
self.model = modèle
self.year = année
self.odometer_reading = 0

def get_descriptive_name (soi):


long_name = str (self.year) + '' + self.make + '' + self.model return long_name.title ()

def read_odometer (self):


print ("Cette voiture a" + str (self.odometer_reading) + "miles dessus.")

def update_odometer (soi, kilométrage):


si kilométrage> = self.odometer_reading:
self.odometer_reading = kilométrage
autre:
print ("Vous ne pouvez pas reculer un compteur kilométrique!")

def increment_odometer (self, miles):


self.odometer_reading + = miles

v classe ElectricCar (voiture):


"" "Représente des aspects d'une voiture, spécifiques aux véhicules électriques." ""

172 Chapitre 9
w def __init __ (soi, marque, modèle, année):
"" "Initialise les attributs de la classe parente." "" Super () .__ init __
X (marque, modèle, année)

y my_tesla = ElectricCar ('tesla', 'model s', 2016)


print (my_tesla.get_descriptive_name ())

À u nous commençons par Auto. Lorsque vous créez une classe enfant, la classe parent doit faire
partie du fichier actuel et doit apparaître avant la classe enfant dans le fichier. À v nous définissons la classe
enfant, Voiture électrique. Le nom de la classe parent doit être inclus entre parenthèses dans la définition de la
classe enfant. Le __ init __ () méthode à w recueille les informations nécessaires pour faire un Auto

exemple.
Le super() fonction à X est une fonction spéciale qui aide Python à établir des connexions entre la
classe parent et la classe enfant. Cette ligne indique à Python d'appeler le __ init __ () méthode de Voiture
électrique la classe parente de, qui donne un
Voiture électrique instance tous les attributs de sa classe parente. Le nom super
vient d'une convention d'appeler la classe parente a superclasse et la classe enfant a sous-classe.

Nous testons si l'héritage fonctionne correctement en essayant de créer une voiture électrique avec le
même type d'informations que nous fournirions lors de la fabrication d'une voiture ordinaire. À y nous faisons
une instance du Voiture électrique classe et stockez-le dans my_tesla. Cette ligne appelle le __ init __ () méthode
définie dans Voiture électrique,
qui à son tour dit à Python d'appeler le __ init __ () méthode définie dans la classe parente Auto. Nous
fournissons les arguments ' tesla ',' modèle s ', et 2016.
Mis à part __ init __ (), il n'y a pas encore d'attributs ou de méthodes propres à une voiture
électrique. À ce stade, nous nous assurons simplement que la voiture électrique a le Auto comportements:

Tesla Model S 2016

Le Voiture électrique instance fonctionne comme une instance de Auto, nous pouvons donc commencer à définir des
attributs et des méthodes spécifiques aux voitures électriques.

Héritage en Python 2.7


Dans Python 2.7, l'héritage est légèrement différent. Le Voiture électrique la classe ressemblerait à ceci:

classe Car (objet):


def __init __ (soi, marque, modèle, année):
- - couper--

classe ElectricCar (voiture):


def __init __ (soi, marque, modèle, année):
super (ElectricCar, self) .__ init __ (marque, modèle, année)
- - couper--

Des classes 173


Le super() la fonction a besoin de deux arguments: une référence à la classe enfant et le soi objet.
Ces arguments sont nécessaires pour aider Python à établir des connexions appropriées entre les
classes parent et enfant. Lorsque vous utilisez l'héritage dans Python 2.7, assurez-vous de définir la
classe parente à l'aide du objet syntaxe également.

Définition d'attributs et de méthodes pour la classe enfant

Une fois que vous avez une classe enfant qui hérite d'une classe parent, vous pouvez ajouter tous les
nouveaux attributs et méthodes nécessaires pour différencier la classe enfant de la classe parent.

Ajoutons un attribut spécifique aux voitures électriques (une batterie, par exemple) et une méthode
pour rendre compte de cet attribut. Nous allons stocker la taille de la batterie et écrire une méthode qui
imprime une description de la batterie:

Voiture de classe ():

- - couper--

classe ElectricCar (voiture):


"" "Représente des aspects d'une voiture, spécifiques aux véhicules électriques." ""

def __init __ (soi, marque, modèle, année):


"" "
Initialisez les attributs de la classe parente.
Ensuite, initialisez les attributs spécifiques à une voiture électrique. "" "

super () .__ init __ (marque, modèle, année)


u self.battery_size = 70

v def describe_battery (self):


"" "Imprimez une déclaration décrivant la taille de la batterie." ""
print ("Cette voiture a une" + str (self.battery_size) + "-kWh battery.")

my_tesla = ElectricCar ('tesla', 'model s', 2016) print


(my_tesla.get_descriptive_name ())
my_tesla.describe_battery ()

À u on ajoute un nouvel attribut self.battery_size et définissez sa valeur initiale sur, disons, 70. Cet
attribut sera associé à toutes les instances créées à partir du
Voiture électrique class mais ne sera associé à aucune instance de Auto. Nous ajoutons également une méthode
appelée describe_battery () qui imprime des informations sur la batterie à v. Lorsque nous appelons cette méthode,
nous obtenons une description clairement spécifique à une voiture électrique:

Tesla Model S 2016


Cette voiture a une batterie de 70 kWh.

Il n'y a pas de limite à ce que vous pouvez spécialiser Voiture électrique classer. Vous pouvez ajouter autant
d'attributs et de méthodes que nécessaire pour modéliser une voiture électrique avec le degré de précision dont vous
avez besoin. Un attribut ou une méthode qui pourrait appartenir à n'importe quelle voiture, plutôt que celui qui est
spécifique à une voiture électrique

174 Chapitre 9
voiture, devrait être ajouté à la Auto classe au lieu du Voiture électrique classer. Ensuite, quiconque utilise le Auto classe
aura également cette fonctionnalité disponible, et le Voiture électrique classe ne contiendra que du code pour
les informations et le comportement spécifiques aux véhicules électriques.

Remplacer les méthodes de la classe parent

Vous pouvez remplacer toute méthode de la classe parent qui ne correspond pas à ce que vous essayez de
modéliser avec la classe enfant. Pour ce faire, vous définissez une méthode dans la classe enfant avec le même
nom que la méthode que vous souhaitez remplacer dans la classe parent. Python ignorera la méthode de classe
parente et ne prêtera attention qu'à la méthode que vous définissez dans la classe enfant.

Dites la classe Auto avait une méthode appelée fill_gas_tank (). Cette méthode n'a pas de sens pour un
véhicule tout électrique, vous voudrez peut-être remplacer cette méthode. Voici une façon de le faire:

def ElectricCar (voiture):


- - couper--

def fill_gas_tank ():


"" "Les voitures électriques n'ont pas de réservoir d'essence." "" Imprimer ("Cette

voiture n'a pas besoin d'un réservoir d'essence!")

Maintenant si quelqu'un essaie d'appeler fill_gas_tank () avec une voiture électrique, Python ignorera la méthode fill_gas_tank
() dans Auto et exécutez ce code à la place. Lorsque vous utilisez l'héritage, vous pouvez faire en sorte que vos classes
enfants conservent ce dont vous avez besoin et remplacer tout ce dont vous n'avez pas besoin de la classe parent.

Instances en tant qu'attributs

Lorsque vous modélisez quelque chose du monde réel dans le code, vous pouvez constater que vous ajoutez de
plus en plus de détails à une classe. Vous constaterez que vous disposez d'une liste croissante d'attributs et de
méthodes et que vos fichiers sont de plus en plus longs. Dans ces situations, vous pouvez reconnaître qu'une partie
d'une classe peut être écrite en tant que classe distincte. Vous pouvez diviser votre grande classe en classes plus
petites qui travaillent ensemble.

Par exemple, si nous continuons à ajouter des détails à la Voiture électrique class, nous pourrions remarquer que nous
ajoutons de nombreux attributs et méthodes spécifiques à la batterie de la voiture. Lorsque nous voyons cela se produire,
nous pouvons arrêter et déplacer ces attributs et méthodes vers une classe distincte appelée Batterie. Ensuite, nous
pouvons utiliser un
Batterie instance comme attribut dans le Voiture électrique classer:

Voiture de classe ():

- - couper--

u classe Batterie ():


"" "Une simple tentative de modéliser une batterie pour une voiture électrique." ""

v def __init __ (self, battery_size = 70):


"" "Initialisez les attributs de la batterie." "" Self.battery_size =
battery_size

Des classes 175


w def describe_battery (self):
"" "Imprimez une déclaration décrivant la taille de la batterie." ""
print ("Cette voiture a une" + str (self.battery_size) + "-kWh battery.")

classe ElectricCar (voiture):


"" "Représente des aspects d'une voiture, spécifiques aux véhicules électriques." ""

def __init __ (soi, marque, modèle, année):


"" "
Initialisez les attributs de la classe parente.
Ensuite, initialisez les attributs spécifiques à une voiture électrique. "" "

super () .__ init __ (marque, modèle, année)


X self.battery = Batterie ()

my_tesla = ElectricCar ('tesla', 'model s', 2016)

print (my_tesla.get_descriptive_name ())


my_tesla.battery.describe_battery ()

À u nous définissons une nouvelle classe appelée Batterie qui n'hérite d'aucune autre classe. Le
__ init __ () méthode à v a un paramètre, batterie_size, en plus de soi. Il s'agit d'un paramètre facultatif qui
définit la taille de la batterie à 70 si aucune valeur n'est fournie. La méthode describe_battery () a
également été déplacé dans cette classe w.

Dans le Voiture électrique class, nous ajoutons maintenant un attribut appelé auto.batterie X.
Cette ligne indique à Python de créer une nouvelle instance de Batterie ( avec une taille par défaut de 70, car
nous ne spécifions pas de valeur) et stockons cette instance dans l'attribut auto.batterie. Cela se produira à
chaque fois que __ init __ () la méthode est appelée; tout Voiture électrique l'instance aura maintenant un Batterie instance
créée automatiquement.

Nous créons une voiture électrique et la stockons dans la variable my_tesla. Lorsque nous voulons
décrire la batterie, nous devons travailler à travers la voiture batterie
attribut:

my_tesla.battery.describe_battery ()

Cette ligne indique à Python de regarder l'instance my_tesla, trouver son batterie
attribut, et appelez la méthode describe_battery () qui est associé à la
Batterie instance stockée dans l'attribut.
La sortie est identique à ce que nous avons vu précédemment:

Tesla Model S 2016


Cette voiture a une batterie de 70 kWh.

176 Chapitre 9
Cela ressemble à beaucoup de travail supplémentaire, mais maintenant nous pouvons décrire la batterie avec
autant de détails que nous le voulons sans encombrer le Voiture électrique classer. Ajoutons une autre méthode à Batterie qui
indique l'autonomie de la voiture en fonction de la taille de la batterie:

Voiture de classe ():

- - couper--

classe Batterie ():


- - couper--

u def get_range (soi):


"" "Imprimez une déclaration sur l'autonomie fournie par cette batterie." "" If self.battery_size
== 70:
plage = 240
elif self.battery_size == 85:
plage = 270

message = "Cette voiture peut parcourir environ" + str (autonomie) message + = "miles
avec une charge complète."
imprimer (message)

classe ElectricCar (voiture):


- - couper--

my_tesla = ElectricCar ('tesla', 'model s', 2016) print


(my_tesla.get_descriptive_name ())
my_tesla.battery.describe_battery ()
v my_tesla.battery.get_range ()

La nouvelle méthode get_range () à u effectue une analyse simple. Si la capacité de la batterie est de
70 kWh, get_range () définit la portée à 240 miles, et si la capacité est de 85 kWh, elle définit la portée à 270
miles. Il signale ensuite cette valeur. Lorsque nous voulons utiliser cette méthode, nous devons à
nouveau l'appeler via la voiture batterie attribut à v.

La sortie nous indique l'autonomie de la voiture en fonction de la taille de sa batterie:

Tesla Model S 2016


Cette voiture a une batterie de 70 kWh.
Cette voiture peut parcourir environ 240 miles avec une charge complète.

Modélisation d'objets du monde réel

Au fur et à mesure que vous commencez à modéliser des objets plus complexes comme des voitures électriques, vous

vous débattez avec des questions intéressantes. L'autonomie d'une voiture électrique est-elle une propriété de la batterie

ou de la voiture? Si nous ne décrivons qu'une seule voiture, c'est probablement bien de maintenir l'association de la

méthode get_range () avec le Batterie

classer. Mais si nous décrivons toute la gamme de voitures d'un constructeur, nous
vraiment envie de bouger get_range () à la Voiture électrique classer. Le get_range () méthode

Des classes 177


vérifierait toujours la taille de la batterie avant de déterminer l'autonomie, mais indiquerait une autonomie
spécifique au type de voiture auquel elle est associée. Alternativement, nous pourrions maintenir l'association
des get_range () méthode avec la batterie mais passez-lui un paramètre tel que modèle de voiture. Le get_range () La
méthode rapporterait alors une plage basée sur la taille de la batterie et le modèle de voiture.

Cela vous amène à un point intéressant de votre croissance en tant que programmeur. Lorsque vous vous
débattez avec de telles questions, vous pensez à un niveau logique plus élevé plutôt qu'à un niveau axé sur la
syntaxe. Vous ne pensez pas à Python, mais à la façon de représenter le monde réel dans le code. Lorsque vous
atteignez ce point, vous vous rendrez compte qu'il n'y a souvent pas de bonnes ou de mauvaises approches pour
modéliser des situations du monde réel. Certaines approches sont plus efficaces que d'autres, mais il faut de la
pratique pour trouver les représentations les plus efficaces. Si votre code fonctionne comme vous le souhaitez,
vous vous en sortez bien! Ne vous découragez pas si vous trouvez que vous déchirez vos cours et que vous les
réécrivez plusieurs fois en utilisant des approches différentes. Dans la quête d'écrire un code précis et efficace,
tout le monde passe par ce processus.

essayez-le vous-même

9-6. Stand de crème glacée: Un stand de crème glacée est un type de restaurant spécifique. Écrivez une classe appelée IceCreamStand

qui hérite de la Le restaurant classe que vous avez écrite dans l'exercice 9-1 (page 166) ou dans l'exercice 9-4 (page 171).

L'une ou l'autre version de

la classe fonctionnera; choisissez simplement celui que vous préférez. Ajoutez un attribut appelé

les saveurs qui stocke une liste de saveurs de crème glacée. Écrivez une méthode qui affiche ces saveurs.

Créer une instance de IceCreamStand, et appelez cette méthode.

9-7. Administrateur: Un administrateur est un type particulier d'utilisateur. Écrivez une classe appelée

Administrateur qui hérite de la Utilisateur classe que vous avez écrite dans l'exercice 9-3 (page 166) ou dans

l'exercice 9-5 (page 171). Ajouter un attribut, privilèges, qui stocke une liste

de chaînes comme " peut ajouter un message "," peut supprimer un message "," peut interdire l'utilisateur ", etc .

Ecrire une méthode appelée show_privileges () qui répertorie l'ensemble de privilèges de l'administrateur. Créer une

instance de Administrateur, et appelez votre méthode.

9-8. Privilèges: Ecrire un autre Privilèges classer . La classe doit avoir un attribut, privilèges, qui stocke une liste de

chaînes comme décrit dans l'exercice 9-7. Bouge le show_privileges () méthode à cette classe. Faire un Privilèges instance

comme attribut dans le Administrateur classer . Créer une nouvelle instance de Administrateur et utilisez votre

méthode pour afficher ses privilèges.

9-9. Mise à niveau de la batterie: Utilisez la version finale de electric_car.py de cette section. Ajouter une méthode au Batterie

classe appelée upgrade_battery (). Cette méthode doit vérifier la taille de la batterie et définir la capacité sur 85 si ce n'est

pas déjà le cas. Faire une voiture électrique avec une taille de batterie par défaut, appelez get_range () une fois, puis

appelez get_range () une deuxième fois après la mise à niveau de la batterie. Vous devriez voir une augmentation de

l'autonomie de la voiture.

178 Chapitre 9
Importer des classes

Au fur et à mesure que vous ajoutez plus de fonctionnalités à vos classes, vos fichiers peuvent devenir longs, même si vous

utilisez correctement l'héritage. Conformément à la philosophie globale de Python, vous voudrez garder vos fichiers aussi

épurés que possible. Pour vous aider, Python vous permet de stocker des classes dans des modules, puis d'importer les

classes dont vous avez besoin dans votre programme principal.

Importer une seule classe

Créons un module contenant uniquement le Auto classer. Cela soulève un problème de dénomination subtile: nous
avons déjà un fichier nommé car.py dans ce chapitre, mais ce module doit être nommé car.py car il contient du
code représentant une voiture. Nous résoudrons ce problème de dénomination en stockant le Auto classe dans un
module nommé
car.py, remplacer le car.py fichier que nous utilisions précédemment. Désormais, tout programme utilisant ce
module aura besoin d'un nom de fichier plus spécifique, tel que
my_car.py. Voici car.py avec juste le code de la classe Auto:

car.py u "" " Une classe qui peut être utilisée pour représenter une voiture. "" "

Voiture de classe ():

"" "Une simple tentative de représenter une voiture." ""

def __init __ (soi, marque, modèle, année):


"" "Initialisez les attributs pour décrire une voiture." "" Self.make =
make
self.model = modèle
self.year = année
self.odometer_reading = 0

def get_descriptive_name (soi):


"" "Renvoie un nom descriptif parfaitement formaté." ""
long_name = str (self.year) + '' + self.make + '' + self.model return long_name.title ()

def read_odometer (self):


"" "Imprimez un relevé indiquant le kilométrage de la voiture." ""
print ("Cette voiture a" + str (self.odometer_reading) + "miles dessus.")

def update_odometer (soi, kilométrage):


"" "
Réglez la lecture de l'odomètre à la valeur donnée.
Rejetez le changement s'il tente de faire reculer le compteur kilométrique. "" "

si kilométrage> = self.odometer_reading:
self.odometer_reading = kilométrage
autre:
print ("Vous ne pouvez pas reculer un compteur kilométrique!")

def increment_odometer (self, miles):


"" "Ajoutez le montant indiqué à la lecture de l'odomètre." ""
Self.odometer_reading + = miles

Des classes 179


À u nous incluons une docstring au niveau du module qui décrit brièvement le contenu de ce module.
Vous devez écrire une docstring pour chaque module que vous créez.

Maintenant, nous créons un fichier séparé appelé my_car.py. Ce fichier importera le


Auto classe, puis créez une instance à partir de cette classe:

my_car.py u de voiture d'importation de voiture

my_new_car = Voiture ('audi', 'a4', 2016) print


(my_new_car.get_descriptive_name ())

my_new_car.odometer_reading = 23
my_new_car.read_odometer ()

Le importer déclaration à u dit à Python d'ouvrir le auto module et importez la classe Auto. Maintenant, nous pouvons

utiliser le Auto classe comme si elle était définie dans ce fichier. Le résultat est le même que celui que nous avons vu

précédemment:

Audi A4 2016
Cette voiture a 23 miles dessus.

L'importation de classes est un moyen efficace de programmer. Imaginez combien de temps ce fichier de programme

serait si l'ensemble Auto classe ont été inclus. Lorsque vous déplacez à la place la classe vers un module et importez le

module, vous obtenez toujours les mêmes fonctionnalités, mais vous gardez votre fichier programme principal propre et

facile à lire. Vous stockez également la plupart de la logique dans des fichiers séparés; une fois que vos cours fonctionnent

comme vous le souhaitez, vous pouvez laisser ces fichiers seuls et vous concentrer sur la logique de niveau supérieur de

votre programme principal.

Stockage de plusieurs classes dans un module

Vous pouvez stocker autant de classes que nécessaire dans un seul module, bien que chaque classe d'un module
doive être liée d'une manière ou d'une autre. Les classes Batterie et
Voiture électrique les deux aident à représenter les voitures, alors ajoutons-les au module car.py:

car.py "" "Un ensemble de classes utilisées pour représenter les voitures à essence et électriques." ""

Voiture de classe ():

- - couper--

classe Batterie ():


"" "Une simple tentative de modéliser une batterie pour une voiture électrique." ""

def __init __ (self, battery_size = 60):


"" "Initialisez les attributs de la batterie." "" Self.battery_size =
battery_size

def describe_battery (self):


"" "Imprimez une déclaration décrivant la taille de la batterie." ""
print ("Cette voiture a une" + str (self.battery_size) + "-kWh battery.")

def get_range (soi):

180 Chapitre 9
"" "Imprimez une déclaration sur l'autonomie fournie par cette batterie." "" If self.battery_size
== 70:
plage = 240
elif self.battery_size == 85:
plage = 270

message = "Cette voiture peut parcourir environ" + str (autonomie) message + = "miles
avec une charge complète."
imprimer (message)

classe ElectricCar (voiture):


"" "Modélise des aspects d'une voiture, spécifiques aux véhicules électriques." ""

def __init __ (soi, marque, modèle, année):


"" "
Initialisez les attributs de la classe parente.
Ensuite, initialisez les attributs spécifiques à une voiture électrique. "" "

super () .__ init __ (marque, modèle, année)


self.battery = Batterie ()

Maintenant, nous pouvons créer un nouveau fichier appelé my_electric_car.py, importer le

Voiture électrique classe, et faites une voiture électrique:

mon_électrique de l'importation de voitures ElectricCar


car.py
my_tesla = ElectricCar ('tesla', 'model s', 2016)

print (my_tesla.get_descriptive_name ())


my_tesla.battery.describe_battery ()
my_tesla.battery.get_range ()

Cela a le même résultat que nous avons vu précédemment, même si la plupart de la logique est cachée
dans un module:

Tesla Model S 2016


Cette voiture a une batterie de 70 kWh.
Cette voiture peut parcourir environ 240 miles avec une charge complète.

Importer plusieurs classes à partir d'un module

Vous pouvez importer autant de classes que nécessaire dans un fichier programme. Si nous voulons faire une
voiture ordinaire et une voiture électrique dans le même fichier, nous devons importer les deux classes, Auto et Voiture
électrique:

my_cars.py u importation de voiture Voiture, Voiture électrique

v my_beetle = Voiture ('volkswagen', 'beetle', 2016)


print (my_beetle.get_descriptive_name ())

w my_tesla = Voiture électrique ('tesla', 'roadster', 2016)


print (my_tesla.get_descriptive_name ())

Des classes 181


Vous importez plusieurs classes d'un module en séparant chaque classe par une virgule u. Une fois
que vous avez importé les classes nécessaires, vous êtes libre de créer autant d'instances de chaque
classe que nécessaire.
Dans cet exemple, nous fabriquons une Volkswagen Beetle ordinaire à v et une Tesla Roadster
électrique à w:

Volkswagen Beetle 2016


Tesla Roadster 2016

Importer un module entier

Vous pouvez également importer un module entier, puis accéder aux classes dont vous avez besoin en utilisant
la notation par points. Cette approche est simple et aboutit à un code facile à lire. Étant donné que chaque
appel qui crée une instance d'une classe inclut le nom du module, vous n'aurez pas de conflits de noms avec
les noms utilisés dans le fichier actuel.

Voici à quoi ressemble l'importation de l'intégralité auto module puis créez une voiture ordinaire et une
voiture électrique:

my_cars.py u voiture d'importation

v my_beetle = voiture.Car ('volkswagen', 'coccinelle', 2016)


print (my_beetle.get_descriptive_name ())

w my_tesla = voiture.ElectricCar ('tesla', 'roadster', 2016)


print (my_tesla.get_descriptive_name ())

À u nous importons le tout auto module. Nous accédons ensuite aux classes dont nous avons besoin
via le nom_module.nom_classe syntaxe. À v nous créons à nouveau une Volkswagen Beetle, et à w nous créons
un Tesla Roadster.

Importation de toutes les classes à partir d'un module

Vous pouvez importer chaque classe d'un module en utilisant la syntaxe suivante:

de nom_module importer *

Cette méthode n'est pas recommandée pour deux raisons. Premièrement, il est utile de pouvoir lire le importer
en haut d'un fichier et obtenez une idée claire des classes utilisées par un programme. Avec cette approche, il
n'est pas clair quelles classes vous utilisez à partir du module. Cette approche peut également conduire à une
confusion avec les noms dans le fichier. Si vous importez accidentellement une classe portant le même nom que
quelque chose d'autre dans votre fichier programme, vous pouvez créer des erreurs difficiles à diagnostiquer. Je
le montre ici car même si ce n'est pas une approche recommandée, vous le verrez probablement dans le code
d'autres personnes.

Si vous avez besoin d'importer de nombreuses classes à partir d'un module, vous feriez mieux d'importer
l'intégralité du module et d'utiliser le nom_module.nom_classe syntaxe.

182 Chapitre 9
Vous ne verrez pas toutes les classes utilisées en haut du fichier, mais vous verrez clairement où le module est utilisé
dans le programme. Vous éviterez également les conflits de dénomination potentiels qui peuvent survenir lorsque vous
importez chaque classe dans un module.

Importer un module dans un module

Parfois, vous voudrez répartir vos classes sur plusieurs modules pour empêcher qu'un seul fichier ne devienne
trop volumineux et éviter de stocker des classes non liées dans le même module. Lorsque vous stockez vos
classes dans plusieurs modules, vous pouvez constater qu'une classe dans un module dépend d'une classe
dans un autre module. Lorsque cela se produit, vous pouvez importer la classe requise dans le premier
module.

Par exemple, stockons le Auto classe dans un module et le Voiture électrique


et Batterie classes dans un module séparé. Nous allons créer un nouveau module appelé
electric_car.py : Remplacement de electric_car.py fichier que nous avons créé précédemment et copiez uniquement le
fichier Batterie et Voiture électrique classes dans ce fichier:

electric_car.py "" "Un ensemble de classes pouvant être utilisées pour représenter des voitures électriques." ""

u de voiture d'importation de voiture

classe Batterie ():


- - couper--

classe ElectricCar (voiture):


- - couper--

La classe Voiture électrique a besoin d'accéder à sa classe parente Auto, donc nous importons

Auto directement dans le module à u. Si nous oublions cette ligne, Python lèvera une erreur lorsque nous essayons de
faire un Voiture électrique exemple. Nous devons également mettre à jour le Auto module de sorte qu'il ne contienne que le Auto
classer:

car.py "" "Une classe qui peut être utilisée pour représenter une voiture." ""

Voiture de classe ():

- - couper--

Maintenant, nous pouvons importer de chaque module séparément et créer le type de voiture dont nous avons
besoin:

my_cars.py u de voiture d'importation de voiture

de l'importation de voiture_électrique ElectricCar

my_beetle = Voiture ('volkswagen', 'beetle', 2016) print


(my_beetle.get_descriptive_name ())

my_tesla = ElectricCar ('tesla', 'roadster', 2016) print


(my_tesla.get_descriptive_name ())

Des classes 183


À u nous importons Auto depuis son module, et Voiture électrique depuis son module. Nous créons ensuite une
voiture ordinaire et une voiture électrique. Les deux types de voitures sont créés correctement:

Volkswagen Beetle 2016


Tesla Roadster 2016

Trouver votre propre flux de travail

Comme vous pouvez le voir, Python vous offre de nombreuses options pour structurer le code dans un
grand projet. Il est important de connaître toutes ces possibilités afin de pouvoir déterminer les meilleures
façons d'organiser vos projets et de comprendre les projets des autres.

Lorsque vous débutez, gardez la structure de votre code simple. Essayez de tout faire dans un seul fichier et
de déplacer vos classes vers des modules séparés une fois que tout fonctionne. Si vous aimez l'interaction des
modules et des fichiers, essayez de stocker vos classes dans des modules lorsque vous démarrez un projet.
Trouvez une approche qui vous permet d'écrire du code qui fonctionne, et partez de là.

essayez-le vous-même

9-10. Restaurant importé: Utilisation de votre dernière Le restaurant class, stockez-le dans un module. Créez un fichier

séparé qui importe Le restaurant . Faire un Le restaurant instance, et appelez l'un des Le restaurant méthodes de pour

montrer que le importer l'instruction fonctionne correctement.

9-11. Administrateur importé: Commencez par votre travail à partir de l'exercice 9-8 (page 178). Stocker les classes Utilisateur,

privilèges, et Administrateur dans un module. Créez un fichier séparé, créez un Administrateur instance, et appelez show_privileges

() pour montrer que tout fonctionne correctement.

9-12. Modules multiples: Stocker le Utilisateur classe dans un module et stockez le

Privilèges et Administrateur classes dans un module séparé. Dans un fichier séparé, créez un Administrateur instance

et appel show_privileges () pour montrer que tout fonctionne toujours correctement.

la bibliothèque standard Python


Le Bibliothèque standard Python est un ensemble de modules inclus avec chaque installation de Python. Maintenant
que vous avez une compréhension de base du fonctionnement des classes, vous pouvez commencer à utiliser des
modules comme ceux-ci que d'autres programmeurs ont écrits. Vous pouvez utiliser n'importe quelle fonction ou classe
de la bibliothèque standard en incluant un simple importer déclaration en haut de votre dossier. Regardons une classe,

OrdonnéDict, du module collections.

184 Chapitre 9
Les dictionnaires vous permettent de connecter des informations, mais ils ne suivent pas l'ordre dans
lequel vous ajoutez des paires clé-valeur. Si vous créez un dictionnaire et que vous souhaitez suivre l'ordre
dans lequel les paires clé-valeur sont ajoutées, vous pouvez utiliser le OrdonnéDict classe de la collections module.
Instances du OrdonnéDict class se comportent presque exactement comme les dictionnaires, sauf qu'ils
gardent une trace de l'ordre dans lequel les paires clé-valeur sont ajoutées.

Revisitons le favorite_languages.py exemple du chapitre 6. Cette fois, nous garderons une trace de
l'ordre dans lequel les gens répondent au sondage:

favori_ u à partir de l'importation de collections OrderedDict


languages.py
v favorite_languages = OrderedDict ()

w favorite_languages ['jen'] = 'python'


favorite_languages ['sarah'] = 'c'
favorite_languages ['edward'] = 'ruby'
favorite_languages ['phil'] = 'python'

X pour le nom, la langue dans favorite_languages.items ():


print (name.title () + la langue préférée de "est" +
language.title () + ".")

Nous commençons par importer le OrdonnéDict classe du module


collections à u. À v nous créons une instance du OrdonnéDict class et stockez cette instance dans favorite_languages.
Notez qu'il n'y a pas de parenthèses; l'appel à OrdonnéDict () crée un dictionnaire ordonné vide
pour nous et le stocke dans favorite_languages. Nous ajoutons ensuite chaque nom et langue à favorite_languages
un à la fois w. Maintenant quand nous bouclons

favorite_languages à X, nous savons que nous recevrons toujours les réponses dans l'ordre dans lequel elles ont été
ajoutées:

Le langage préféré de Jen est Python. La langue


préférée de Sarah est la langue préférée de C.
Edward est Ruby. Le langage préféré de Phil est
Python.

C'est une classe formidable à connaître car elle combine le principal avantage des listes (conserver votre ordre
d'origine) avec la caractéristique principale des dictionnaires (relier des informations). Lorsque vous commencez à
modéliser des situations du monde réel qui vous intéressent, vous rencontrerez probablement une situation où un
dictionnaire ordonné est exactement ce dont vous avez besoin. Au fur et à mesure que vous en apprendrez plus sur la
bibliothèque standard, vous vous familiariserez avec un certain nombre de modules comme celui-ci qui vous aideront à
gérer les situations courantes.

Remarque Vous pouvez également télécharger des modules à partir de sources externes. Vous verrez un certain nombre de ces
exemples dans la partie II, où nous aurons besoin de modules externes pour terminer chaque projet.

Des classes 185


essayez-le vous-même

9-13. OrderedDict Rewrite: Commencez par l'exercice 6-4 (page 108), dans lequel vous avez utilisé un dictionnaire

standard pour représenter un glossaire. Réécrivez le programme en utilisant le OrdonnéDict class et assurez-vous

que l'ordre de la sortie correspond à l'ordre dans lequel les paires clé-valeur ont été ajoutées au dictionnaire.

9-14. Dé: Le module Aléatoire contient des fonctions qui génèrent des nombres aléatoires de différentes
manières. La fonction randint () renvoie un entier dans la plage que vous fournissez. Le code suivant
renvoie un nombre compris entre 1 et 6:

à partir d'une importation aléatoire randint x


= randint (1, 6)

Faire un cours Mourir avec un attribut appelé côtés, qui a une valeur par défaut de 6. Ecrire une
méthode appelée roll_die () qui imprime un nombre aléatoire compris entre 1 et le nombre de côtés du
dé. Faites un dé à 6 faces et lancez-le 10 fois.

Fabriquez un dé à 10 faces et un dé à 20 faces. Lancez chaque dé 10 fois.

9-15. Module Python de la semaine: Une excellente ressource pour explorer la bibliothèque standard

Python est un site appelé Module Python de la semaine. Aller à

http://pymotw.com/ et regardez la table des matières. Trouvez un module qui vous semble
intéressant et lisez-le à ce sujet, ou explorez la documentation de
le collections et Aléatoire modules .

Classes de style
Quelques problèmes de style liés aux classes méritent d'être clarifiés, d'autant plus que vos programmes
deviennent plus compliqués.
Les noms de classe doivent être écrits en CamelCaps. Pour ce faire, mettez en majuscule la première lettre de
chaque mot du nom et n'utilisez pas de traits de soulignement. Les noms d'instance et de module doivent être écrits en
minuscules avec des traits de soulignement entre les mots.

Chaque classe doit avoir une docstring immédiatement après la définition de la classe. La docstring doit
être une brève description de ce que fait la classe, et vous devez suivre les mêmes conventions de formatage
que vous avez utilisées pour écrire des docstrings dans les fonctions. Chaque module doit également avoir
une docstring décrivant à quoi les classes d'un module peuvent être utilisées.

Vous pouvez utiliser des lignes vides pour organiser le code, mais ne les utilisez pas de manière excessive.
Dans une classe, vous pouvez utiliser une ligne vide entre les méthodes, et dans un module, vous pouvez utiliser
deux lignes vides pour séparer les classes.
Si vous devez importer un module de la bibliothèque standard et un module que vous avez écrit, placez
l'instruction d'importation pour le module de bibliothèque standard

186 Chapitre 9
première. Ajoutez ensuite une ligne vide et l'instruction d'importation pour le module que vous avez écrit. Dans les
programmes avec plusieurs instructions d'importation, cette convention permet de voir plus facilement d'où viennent
les différents modules utilisés dans le programme.

résumé
Dans ce chapitre, vous avez appris à rédiger vos propres cours. Vous avez appris à stocker des informations
dans une classe à l'aide d'attributs et à écrire des méthodes qui donnent à vos classes le comportement dont
elles ont besoin. Vous avez appris à écrire __ init __ () méthodes qui créent des instances à partir de vos classes
avec exactement les attributs que vous souhaitez. Vous avez vu comment modifier les attributs d'une instance
directement et via des méthodes. Vous avez appris que l'héritage peut simplifier la création de classes liées les
unes aux autres, et vous avez appris à utiliser des instances d'une classe comme attributs dans une autre
classe pour garder chaque classe simple.

Vous avez vu comment le stockage des classes dans des modules et l'importation des classes dont vous avez
besoin dans les fichiers où elles seront utilisées peuvent garder vos projets organisés. Vous avez commencé à vous
familiariser avec la bibliothèque standard Python et vous avez vu un exemple basé sur le OrdonnéDict classe de la collections module.
Enfin, vous avez appris à styliser vos classes en utilisant les conventions Python.

Dans le chapitre 10, vous apprendrez à travailler avec des fichiers afin de pouvoir enregistrer le travail que vous

avez effectué dans un programme et le travail que vous avez autorisé les utilisateurs à faire. Vous en apprendrez

également sur des exceptions, une classe Python spéciale conçue pour vous aider à répondre aux erreurs lorsqu'elles

surviennent.

Des classes 187


dix
f I les et les xCeP t Ions

Maintenant que vous maîtrisez les compétences de base dont vous

avez besoin pour écrire des programmes organisés et faciles à utiliser, il est

temps de penser à rendre vos programmes encore plus pertinents et

utilisables. Dans ce chapitre, vous apprendrez à travailler avec des fichiers afin

que vos programmes puissent analyser rapidement de nombreuses données.

Vous apprendrez à gérer les erreurs afin que vos programmes ne se bloquent pas lorsqu'ils rencontrent des situations

inattendues. Vous en apprendrez davantage sur des exceptions, qui sont des objets spéciaux créés par Python pour gérer

les erreurs qui surviennent lors de l'exécution d'un programme. Vous en apprendrez également sur le json module, qui vous

permet d'enregistrer les données utilisateur afin qu'elles ne soient pas perdues lorsque votre programme s'arrête de

s'exécuter.

Apprendre à travailler avec des fichiers et à enregistrer des données rendra vos programmes plus faciles à
utiliser. Les utilisateurs pourront choisir quelles données saisir et quand les saisir. Les gens peuvent exécuter
votre programme, faire du travail, puis fermer le programme et reprendre là où ils l'ont laissé plus tard. Apprendre
à gérer les exceptions vous aidera à gérer les situations dans lesquelles les fichiers n'existent pas et à gérer
d'autres problèmes pouvant entraîner le blocage de vos programmes. Cela rendra vos programmes plus
robustes lorsqu'ils rencontrent de mauvaises données, que ce soit
cela vient d'erreurs innocentes ou de tentatives malveillantes pour casser vos programmes. Avec les
compétences que vous apprendrez dans ce chapitre, vous rendrez vos programmes plus applicables,
utilisables et stables.

lecture d'un fichier


Une quantité incroyable de données est disponible dans des fichiers texte. Les fichiers texte peuvent contenir des données
météorologiques, des données sur le trafic, des données socio-économiques, des œuvres littéraires, etc. La lecture à
partir d'un fichier est particulièrement utile dans les applications d'analyse de données, mais elle s'applique également à
toute situation dans laquelle vous souhaitez analyser ou modifier les informations stockées dans un fichier. Par exemple,
vous pouvez écrire un programme qui lit le contenu d'un fichier texte et réécrit le fichier avec une mise en forme qui permet
à un navigateur de l'afficher.

Lorsque vous souhaitez travailler avec les informations d'un fichier texte, la première étape consiste à lire
le fichier en mémoire. Vous pouvez lire l'intégralité du contenu d'un fichier ou vous pouvez parcourir le fichier
ligne par ligne.

Lire un fichier entier


Pour commencer, nous avons besoin d'un fichier contenant quelques lignes de texte. Commençons par un
fichier qui contient pi à 30 décimales avec 10 décimales par ligne:

pi_digits.txt 3,1415926535
8979323846
2643383279

Pour essayer vous-même les exemples suivants, vous pouvez saisir ces lignes dans un éditeur et enregistrer
le fichier sous pi_digits.txt, ou vous pouvez télécharger le fichier à partir des ressources du livre via https://www.nostarch.com/pythoncr
Enregistrez le fichier dans le même répertoire où vous stockerez les programmes de ce chapitre.

Voici un programme qui ouvre ce fichier, le lit et imprime le contenu du fichier à


l'écran:

file_reader.py avec open ('pi_digits.txt') comme file_object:


contents = file_object.read ()
imprimer (contenu)

La première ligne de ce programme a beaucoup à faire. Commençons par regarder le ouvert() fonction.
Pour travailler sur un fichier, même en imprimant simplement son contenu, vous devez d'abord ouvert le
fichier pour y accéder. Le ouvert() La fonction a besoin d'un argument: le nom du fichier que vous souhaitez
ouvrir. Python recherche ce fichier dans le répertoire où le programme en cours d'exécution est stocké.
Dans cet exemple, file_reader.py est en cours d'exécution, donc Python recherche pi_digits.txt dans le
répertoire où file_reader.py est stocké. Le ouvert()

function renvoie un objet représentant le fichier. Ici, open ('pi_digits.txt')


renvoie un objet représentant pi_digits.txt. Python stocke cet objet dans
objet_fichier, avec lequel nous travaillerons plus tard dans le programme.
Le mot clé avec ferme le fichier une fois que l'accès à celui-ci n'est plus nécessaire. Remarquez comment nous
appelons ouvert() dans ce programme mais pas Fermer(). Tu pourrais ouvrir

190 Chapitre 10
et fermez le fichier en appelant ouvert() et Fermer(), mais si un bogue dans votre programme empêche le Fermer() de
s'exécuter, le fichier peut ne jamais se fermer. Cela peut sembler anodin, mais des fichiers mal fermés peuvent
entraîner la perte ou la corruption de données. Et si tu appelles Fermer() trop tôt dans votre programme, vous vous
surprendrez à essayer de travailler avec un fermé fichier (un fichier auquel vous ne pouvez pas accéder), ce qui
entraîne davantage d'erreurs. Il n'est pas toujours facile de savoir exactement quand fermer un fichier, mais avec
la structure présentée ici, Python le découvrira pour vous. Tout ce que vous avez à faire est d'ouvrir le fichier et de
travailler avec lui comme vous le souhaitez, en sachant que Python le fermera automatiquement le moment venu.

Une fois que nous avons un objet fichier représentant pi_digits.txt, nous utilisons le lire()
méthode dans la deuxième ligne de notre programme pour lire tout le contenu du fichier et le stocker comme une
longue chaîne dans Contenu. Lorsque nous imprimons la valeur de Contenu, nous récupérons l'intégralité du fichier
texte:

3,1415926535
8979323846
2643383279

La seule différence entre cette sortie et le fichier d'origine est la ligne vierge
supplémentaire à la fin de la sortie. La ligne vide apparaît car
lire() renvoie une chaîne vide lorsqu'elle atteint la fin du fichier; cette chaîne vide apparaît comme une ligne vide.
Si vous souhaitez supprimer la ligne vierge supplémentaire, vous pouvez utiliser rstrip () dans le impression déclaration:

avec open ('pi_digits.txt') comme file_object:


contents = file_object.read ()
print (contents.rstrip ())

Rappelez-vous que Python rstrip () supprime ou supprime tous les caractères d'espacement du
côté droit d'une chaîne. Maintenant, la sortie correspond exactement au contenu du fichier d'origine:

3,1415926535
8979323846
2643383279

Chemins de fichiers

Lorsque vous passez un nom de fichier simple comme pi_digits.txt à la ouvert() fonction, Python regarde
dans le répertoire où le fichier en cours d'exécution (c'est-à-dire votre. py programme) est stocké.

Parfois, selon la façon dont vous organisez votre travail, le fichier que vous souhaitez ouvrir ne se trouve pas
dans le même répertoire que votre fichier programme. Par exemple, vous pouvez stocker vos fichiers de programme
dans un dossier appelé python_work; à l'intérieur
travail_python, vous pourriez avoir un autre dossier appelé text_files pour distinguer vos fichiers
programme des fichiers texte qu'ils manipulent. Bien que text_files
est dans travail_python, juste en passant ouvert() le nom d'un fichier dans text_files ne fonctionnera pas, car Python ne
recherchera que python_work et arrêtez-vous là; ça ne va pas continuer

Fichiers et exceptions 191


et regarde dedans text_files. Pour que Python ouvre des fichiers à partir d'un répertoire autre que celui où votre
fichier programme est stocké, vous devez fournir un chemin du fichier, qui indique à Python de rechercher dans un
emplacement spécifique de votre système.
Parce que text_files Est à l'intérieur travail_python, vous pouvez utiliser un chemin de fichier relatif pour ouvrir un
fichier à partir de text_files. UNE chemin de fichier relatif indique à Python de rechercher un emplacement donné par rapport
au répertoire où le fichier programme en cours d'exécution est stocké. Sous Linux et OS X, vous écririez:

avec open ('text_files / nom de fichier. txt ') en tant que file_object:

Cette ligne indique à Python de rechercher le fichier souhaité. SMS fichier dans le dossier

text_files et suppose que text_files est situé à l'intérieur travail_python ( ce que c'est). Sur les systèmes Windows, vous
utilisez une barre oblique inverse (\) au lieu d'une barre oblique (/) dans le chemin du fichier:

avec open ('text_files \ nom de fichier. txt ') en tant que file_object:

Vous pouvez également indiquer à Python exactement où se trouve le fichier sur votre ordinateur, quel que soit
l'endroit où le programme en cours d'exécution est stocké. C'est ce qu'on appelle un chemin d'accès absolu au fichier. Vous
utilisez un chemin absolu si un chemin relatif ne fonctionne pas. Par exemple, si vous avez mis text_files dans un dossier
autre que
python_work —Dire, un dossier appelé autres fichiers - puis juste en passant ouvert() le chemin ' text_files / nom de
fichier. SMS' ne fonctionnera pas car Python ne recherchera que cet emplacement à l'intérieur python_work. Vous
devrez écrire un chemin complet pour clarifier où vous voulez que Python regarde.

Les chemins absolus sont généralement plus longs que les chemins relatifs, il est donc utile de les stocker dans
une variable, puis de passer cette variable à ouvert(). Sous Linux et OS X, les chemins absolus ressemblent à ceci:

file_path = '/ home / ehmatthes / other_files / text_files / nom de fichier. txt 'avec open (file_path)
comme file_object:

et sous Windows, ils ressemblent à ceci:

file_path = 'C: \ Users \ ehmatthes \ other_files \ text_files \ nom de fichier. txt 'avec open (file_path)
comme file_object:

En utilisant des chemins absolus, vous pouvez lire des fichiers à partir de n'importe quel emplacement de votre

système. Pour l'instant, il est plus simple de stocker des fichiers dans le même répertoire que vos fichiers programme ou

dans un dossier tel que text_files dans le répertoire qui stocke vos fichiers programme.

Remarque Les systèmes Windows interprètent parfois correctement les barres obliques dans les chemins de fichiers. Si vous utilisez
Windows et que vous n'obtenez pas les résultats escomptés, assurez-vous d'essayer d'utiliser des barres obliques inverses.

192 Chapitre 10
Lecture ligne par ligne

Lorsque vous lisez un fichier, vous voudrez souvent examiner chaque ligne du fichier. Il se peut que vous recherchiez
certaines informations dans le fichier ou que vous souhaitiez modifier le texte du fichier d'une manière ou d'une autre.
Par exemple, vous voudrez peut-être lire un fichier de données météorologiques et travailler avec n'importe quelle
ligne contenant le mot
ensoleillé dans la description de la météo de ce jour-là. Dans un reportage, vous pouvez rechercher n'importe
quelle ligne avec la balise < titre> et réécrivez cette ligne avec un type de formatage spécifique.

Vous pouvez utiliser un pour boucle sur l'objet fichier pour examiner chaque ligne d'un fichier une par une:

file_reader.py u filename = 'pi_digits.txt'

v avec open (filename) comme file_object:


w pour la ligne dans file_object:
imprimer (ligne)

À u nous stockons le nom du fichier que nous lisons dans la variable


nom de fichier. Il s'agit d'une convention courante lorsque vous travaillez avec des fichiers. Parce que la variable nom
de fichier ne représente pas le fichier réel - c'est juste une chaîne indiquant à Python où trouver le fichier - vous
pouvez facilement échanger ' pi_digits.txt '
pour le nom d'un autre fichier avec lequel vous souhaitez travailler. Après avoir appelé ouvert(),
un objet représentant le fichier et son contenu est stocké dans la variable
objet_fichier v. Nous utilisons à nouveau le avec syntaxe pour permettre à Python d'ouvrir et de fermer le fichier correctement.
Pour examiner le contenu du fichier, nous travaillons sur chaque ligne du fichier en effectuant une boucle sur l'objet fichier w.

Lorsque nous imprimons chaque ligne, nous trouvons encore plus de lignes vierges:

3,1415926535

8979323846

2643383279

Ces lignes vides apparaissent car un caractère de nouvelle ligne invisible se trouve à la fin de chaque
ligne dans le fichier texte. Le impression ajoute sa propre nouvelle ligne à chaque fois que nous l'appelons, nous
nous retrouvons donc avec deux caractères de nouvelle ligne à la fin de chaque ligne: un du fichier et un de la impression
déclaration. Utilisant rstrip () sur chaque ligne du impression L'instruction élimine ces lignes vides supplémentaires:

filename = 'pi_digits.txt'

avec open (filename) comme file_object:


pour la ligne dans file_object:
impression (line.rstrip ())

Fichiers et exceptions 193


Maintenant, la sortie correspond à nouveau au contenu du fichier:

3,1415926535
8979323846
2643383279

Créer une liste de lignes à partir d'un fichier

Lorsque vous utilisez avec, l'objet fichier renvoyé par ouvert() est uniquement disponible à l'intérieur du avec bloc qui le
contient. Si vous souhaitez conserver l'accès au contenu d'un fichier en dehors de avec block, vous pouvez stocker les
lignes du fichier dans une liste à l'intérieur du bloc, puis travailler avec cette liste. Vous pouvez traiter des parties du
fichier immédiatement et reporter certains traitements pour plus tard dans le programme.

L'exemple suivant stocke les lignes de pi_digits.txt dans une liste à l'intérieur du
avec bloc, puis imprime les lignes en dehors du avec bloquer:

filename = 'pi_digits.txt'

avec open (filename) comme file_object:


u lines = objet_fichier.readlines ()

v pour ligne en lignes:


impression (line.rstrip ())

À u le readlines () La méthode prend chaque ligne du fichier et la stocke dans une liste. Cette liste est ensuite
stockée dans lignes, avec lequel nous pouvons continuer à travailler après le avec le bloc se termine. À v nous utilisons un
simple pour boucle pour imprimer chaque ligne à partir de lignes. Parce que chaque élément dans lignes correspond à
chaque ligne du fichier, la sortie correspond exactement au contenu du fichier.

Utilisation du contenu d'un fichier

Après avoir lu un fichier en mémoire, vous pouvez faire ce que vous voulez avec ces données, alors
explorons brièvement les chiffres de pi. Tout d'abord, nous allons essayer de créer une seule chaîne
contenant tous les chiffres du fichier sans espace:

pi_string.py filename = 'pi_digits.txt'

avec open (filename) comme file_object:


lines = objet_fichier.readlines ()

u pi_string = ''
v pour ligne en lignes:
pi_string + = ligne.rstrip ()

w imprimer (pi_string)
print (len (pi_string))

Nous commençons par ouvrir le fichier et stocker chaque ligne de chiffres dans une liste, comme nous l'avons
fait dans l'exemple précédent. À u nous créons une variable, pi_string, à

194 Chapitre 10
tenez les chiffres de pi. Nous créons ensuite une boucle qui ajoute chaque ligne de chiffres à
pi_string et supprime le caractère de nouvelle ligne de chaque ligne v. À w nous imprimons cette chaîne et
montrons également la longueur de la chaîne:

3,1415926535 8979323846 2643383279


36

La variable pi_string contient l'espace blanc qui se trouvait sur le côté gauche des chiffres de chaque ligne,
mais nous pouvons nous en débarrasser en utilisant déshabiller() au lieu
de rstrip ():

filename = 'pi_30_digits.txt'

avec open (filename) comme file_object:


lines = objet_fichier.readlines ()

pi_string = ''
pour ligne en lignes:
pi_string + = line.strip ()

imprimer (pi_string)
print (len (pi_string))

Maintenant, nous avons une chaîne contenant pi à 30 décimales. La chaîne comporte 32 caractères
car elle comprend également les 3 premiers et une virgule décimale:

3,141592653589793238462643383279
32

Remarque Lorsque Python lit un fichier texte, il interprète tout le texte du fichier comme une chaîne. Si vous lisez un nombre et
que vous souhaitez travailler avec cette valeur dans un contexte numérique, vous devrez le convertir en entier à l'aide
du int () ou convertissez-le en flottant à l'aide de la flotter() fonction.

Fichiers volumineux: un million de chiffres

Jusqu'à présent, nous nous sommes concentrés sur l'analyse d'un fichier texte ne contenant que trois lignes, mais le code
de ces exemples fonctionnerait tout aussi bien sur des fichiers beaucoup plus volumineux. Si nous commençons avec un
fichier texte qui contient pi à 1 000 000 décimales au lieu de seulement 30, nous pouvons créer une seule chaîne contenant
tous ces chiffres. Nous n'avons pas du tout besoin de changer notre programme, sauf de lui passer un fichier différent. Nous
n'imprimerons également que les 50 premières décimales, nous n'avons donc pas à regarder un million de chiffres défiler
dans le terminal:

pi_string.py filename = 'pi_million_digits.txt'

avec open (filename) comme file_object:


lines = objet_fichier.readlines ()

Fichiers et exceptions 195


pi_string = ''
pour ligne en lignes:
pi_string + = line.strip ()

print (pi_string [: 52] + "...")


print (len (pi_string))

La sortie montre que nous avons effectivement une chaîne contenant pi à


1000000 décimales:

3,14159265358979323846264338327950288419716939937510 ... 1000002

Python n'a pas de limite inhérente à la quantité de données avec laquelle vous pouvez travailler; vous pouvez

travailler avec autant de données que la mémoire de votre système peut gérer.

Remarque Pour exécuter ce programme (et de nombreux exemples qui suivent), vous devrez télécharger les ressources
disponibles sur https://www.nostarch.com/pythoncrashcourse/.

Votre anniversaire est-il contenu dans Pi?

J'ai toujours été curieux de savoir si mon anniversaire apparaît n'importe où dans les chiffres de pi. Utilisons le
programme que nous venons d'écrire pour savoir si l'anniversaire de quelqu'un apparaît n'importe où dans le premier
million de chiffres de pi. Nous pouvons le faire en exprimant chaque anniversaire sous la forme d'une chaîne de chiffres
et en vérifiant si cette chaîne apparaît n'importe où dans pi_string:

filename = 'pi_million_digits.txt'

avec open (filename) comme file_object:


lines = objet_fichier.readlines ()

pi_string = ''
pour ligne en lignes:
pi_string + = ligne.rstrip ()

u anniversaire = entrée ("Entrez votre date de naissance, sous la forme mmjjj:")


v si anniversaire dans pi_string:
print ("Votre anniversaire apparaît dans le premier million de chiffres de pi!") else:

print ("Votre anniversaire n'apparaît pas dans le premier million de chiffres de pi.")

À u nous demandons l'anniversaire de l'utilisateur, puis à v nous vérifions si cette chaîne est dans pi_string.
Essayons:

Entrez votre date de naissance, sous la forme mmddyy: 120372


Votre anniversaire apparaît dans le premier million de chiffres de pi!

Mon anniversaire apparaît dans les chiffres de pi! Une fois que vous avez lu un fichier, vous pouvez analyser
son contenu de n'importe quelle manière que vous pouvez imaginer.

196 Chapitre 10
essayez-le vous-même

10-1. Apprendre Python: Ouvrez un fichier vide dans votre éditeur de texte et écrivez quelques lignes résumant ce

que vous avez appris sur Python jusqu'à présent. Commencez chaque ligne par la phrase En Python, vous

pouvez .... Enregistrez le fichier sous learning_python.txt dans le même répertoire que vos exercices de ce
chapitre. Écrivez un programme qui lit le fichier et imprime ce que vous avez écrit trois fois. Imprimez le contenu

une fois en lisant le fichier entier, une fois en boucle sur l'objet fichier, et une fois en stockant les lignes dans une

liste, puis en les utilisant en dehors du avec bloquer .

10-2. Apprentissage C: Vous pouvez utiliser le remplacer() méthode pour remplacer n'importe quel mot d'une chaîne par

un mot différent. Voici un exemple rapide montrant comment remplacer

'chien' avec ' chat' dans une phrase:

>>> message = "J'aime vraiment les chiens."


>>> message.replace ('chien', 'chat')
«J'aime vraiment les chats.

Lisez chaque ligne du fichier que vous venez de créer, learning_python.txt, et remplacez le mot Python
avec le nom d'une autre langue, telle que C. Imprimez chaque ligne modifiée à l'écran.

écriture dans un fichier

L'un des moyens les plus simples d'enregistrer des données consiste à les écrire dans un fichier. Lorsque vous écrivez
du texte dans un fichier, la sortie sera toujours disponible après la fermeture du terminal contenant la sortie de votre
programme. Vous pouvez examiner la sortie après l'exécution d'un programme et vous pouvez également partager les
fichiers de sortie avec d'autres. Vous pouvez également écrire des programmes qui lisent le texte dans la mémoire et le
réutiliser plus tard.

Ecrire dans un fichier vide

Pour écrire du texte dans un fichier, vous devez appeler ouvert() avec un deuxième argument indiquant à Python que
vous souhaitez écrire dans le fichier. Pour voir comment cela fonctionne, écrivons un message simple et stockons-le
dans un fichier au lieu de l'imprimer à l'écran:

écrivez_ filename = 'programmation.txt'


message.py
u avec open (filename, 'w') comme file_object:
v file_object.write ("J'adore la programmation.")

L'appel à ouvert() dans cet exemple a deux arguments u. Le premier argument est toujours le nom
du fichier que nous voulons ouvrir. Le deuxième argument, ' w ',
indique à Python que nous voulons ouvrir le fichier dans mode d'écriture. Vous pouvez ouvrir un fichier

Fichiers et exceptions 197


dans mode lecture (' r '), mode d'écriture (' w '), mode d'ajout (' une'), ou un mode qui vous permet de lire et
d'écrire dans le fichier (' r + '). Si vous omettez l'argument mode, Python ouvre le fichier en mode lecture
seule par défaut.
Le ouvert() La fonction crée automatiquement le fichier dans lequel vous écrivez s'il n'existe pas
déjà. Attention cependant à ouvrir un fichier en écriture (' w ')
car si le fichier existe, Python effacera le fichier avant de renvoyer l'objet fichier.

À v nous utilisons le écrivez() sur l'objet fichier pour écrire une chaîne dans le fichier. Ce
programme n'a pas de sortie de terminal, mais si vous ouvrez le fichier
programmation.txt, vous verrez une ligne:

programmation.txt J'adore la programmation.

Ce fichier se comporte comme tout autre fichier sur votre ordinateur. Vous pouvez l'ouvrir, y
écrire un nouveau texte, le copier, le coller, etc.

Remarque Python ne peut écrire des chaînes que dans un fichier texte. Si vous souhaitez stocker des données numériques dans un
fichier texte, vous devrez d'abord convertir les données au format chaîne en utilisant le str () fonction.

Ecrire plusieurs lignes

Le écrivez() La fonction n'ajoute aucune nouvelle ligne au texte que vous écrivez. Donc, si vous écrivez plus
d'une ligne sans inclure de caractères de nouvelle ligne, votre fichier peut ne pas ressembler à ce que vous
souhaitez:

filename = 'programmation.txt'

avec open (filename, 'w') comme file_object:


file_object.write ("J'adore la programmation.")
file_object.write ("J'adore créer de nouveaux jeux.")

Si vous ouvrez programmation.txt, vous verrez les deux lignes écrasées ensemble:

J'adore la programmation, j'aime créer de nouveaux jeux.

Inclure les nouvelles lignes dans votre écrivez() fait apparaître chaque chaîne sur sa propre ligne:

filename = 'programmation.txt'

avec open (filename, 'w') comme file_object:


file_object.write ("J'adore la programmation. \ n")
file_object.write ("J'adore créer de nouveaux jeux. \ n")

La sortie apparaît maintenant sur des lignes séparées:

J'adore la programmation.
J'adore créer de nouveaux jeux.

198 Chapitre 10
Vous pouvez également utiliser des espaces, des tabulations et des lignes vides pour formater votre sortie,
comme vous l'avez fait avec la sortie basée sur un terminal.

Ajout à un fichier
Si vous souhaitez ajouter du contenu à un fichier au lieu d'écrire sur le contenu existant, vous pouvez ouvrir le
fichier dans mode d'ajout. Lorsque vous ouvrez un fichier en mode ajout, Python n'efface pas le fichier avant
de renvoyer l'objet fichier. Toutes les lignes que vous écrivez dans le fichier seront ajoutées à la fin du fichier.
Si le fichier n'existe pas encore, Python créera un fichier vide pour vous.

Modifions write_message.py en ajoutant de nouvelles raisons pour lesquelles nous aimons la programmation au
fichier existant programmation.txt:

écrivez_ filename = 'programmation.txt'


message.py
u avec open (filename, 'a') comme file_object:
v file_object.write ("J'aime aussi trouver un sens dans les grands ensembles de données. \ n") file_object.write ("J'adore
créer des applications qui peuvent s'exécuter dans un navigateur. \ n")

À u nous utilisons le ' une' argument pour ouvrir le fichier pour l'ajouter plutôt que pour l'écrire sur le
fichier existant. À v nous écrivons deux nouvelles lignes, qui s'ajoutent à programmation.txt:

programmation.txt J'adore la programmation.


J'adore créer de nouveaux jeux.
J'aime aussi trouver du sens dans les grands ensembles de données. J'adore créer des

applications qui peuvent s'exécuter dans un navigateur.

Nous nous retrouvons avec le contenu original du fichier, suivi du nouveau contenu que nous venons
d'ajouter.

essayez-le vous-même

10-3. Invité: Écrivez un programme qui demande à l'utilisateur son nom. Lorsqu'ils répondent, écrivez leur nom

dans un fichier appelé guest.txt.

10-4. Livre d'or: Écrire un tandis que boucle qui demande aux utilisateurs leur nom. Lorsqu'ils entrent leur nom, imprimez un

message d'accueil à l'écran et ajoutez une ligne enregistrant leur visite dans un fichier appelé guest_book.txt. Assurez-vous

que chaque entrée apparaît sur une nouvelle ligne dans le fichier.

10-5. Sondage de programmation: Écrire un tandis que boucle qui demande aux gens pourquoi ils aiment la programmation.

Chaque fois que quelqu'un entre une raison, ajoutez sa raison à un fichier qui stocke toutes les réponses.

Fichiers et exceptions 199


des exceptions

Python utilise des objets spéciaux appelés des exceptions pour gérer les erreurs qui surviennent lors de
l'exécution d'un programme. Chaque fois qu'une erreur se produit et que Python ne sait pas quoi faire
ensuite, il crée un objet d'exception. Si vous écrivez du code qui gère l'exception, le programme continuera
à s'exécuter. Si vous ne gérez pas l'exception, le programme s'arrêtera et affichera un retraçage, qui
comprend un rapport sur l'exception qui a été soulevée.

Les exceptions sont gérées avec essayer-sauf blocs. UNE essayer-sauf block demande à Python de faire quelque chose,
mais il indique également à Python ce qu'il doit faire si une exception est déclenchée. Lorsque vous utilisez essayer-sauf blocs,
vos programmes continueront de fonctionner même si les choses commencent à mal tourner. Au lieu des traces, qui
peuvent être déroutantes pour les utilisateurs à lire, les utilisateurs verront des messages d'erreur conviviaux que vous
écrivez.

Gestion de l'exception ZeroDivisionError

Examinons une erreur simple qui oblige Python à déclencher une exception. Vous savez probablement qu'il est
impossible de diviser un nombre par zéro, mais demandons quand même à Python de le faire:

division.py imprimer (5/0)

Bien sûr, Python ne peut pas faire cela, nous obtenons donc un traçage:

Traceback (dernier appel le plus récent):


Fichier "division.py", ligne 1, dans <module>
imprimer (5/0)
u ZeroDivisionError: division par zéro

L'erreur signalée à u dans le retraçage, ZeroDivisionError, est un objet d'exception. Python crée ce type
d'objet en réponse à une situation où il ne peut pas faire ce que nous lui demandons. Lorsque cela se
produit, Python arrête le programme et nous indique le type d'exception qui a été levé. Nous pouvons
utiliser ces informations pour modifier notre programme. Nous dirons à Python quoi faire lorsque ce type
d'exception se produit; de cette façon, si cela se reproduit, nous sommes prêts.

Utilisation de blocs try-except

Lorsque vous pensez qu'une erreur peut se produire, vous pouvez écrire un essayer-sauf block pour gérer
l'exception qui pourrait être déclenchée. Vous dites à Python d'essayer d'exécuter du code et vous lui dites
quoi faire si le code entraîne un type particulier d'exception.

Voici ce qu'un essayer-sauf bloc pour gérer le ZeroDivisionError l'exception ressemble à:

essayer:

imprimer (5/0)
sauf ZeroDivisionError:
print ("Vous ne pouvez pas diviser par zéro!")

200 Chapitre 10
nous mettons impression (5/0), la ligne qui a causé l'erreur, à l'intérieur d'un essayer bloquer. Si le code dans
un essayer fonctionne, Python saute le sauf bloquer. Si le code dans le essayer bloque provoque une erreur,
Python recherche un sauf bloc dont l'erreur correspond à celle qui a été déclenchée et exécute le code dans
ce bloc.
Dans cet exemple, le code dans le essayer block produit un ZeroDivisionError,
donc Python cherche un sauf bloquer en lui disant comment répondre. Python exécute ensuite le code
dans ce bloc et l'utilisateur voit un message d'erreur convivial au lieu d'un retraçage:

Vous ne pouvez pas diviser par zéro!

Si plus de code suivait le essayer-sauf block, le programme continuerait de fonctionner car nous avons
dit à Python comment gérer l'erreur. Regardons un exemple où la détection d'une erreur peut permettre à
un programme de continuer à s'exécuter.

Utilisation d'exceptions pour éviter les plantages

La gestion correcte des erreurs est particulièrement importante lorsque le programme a plus de travail à faire après
que l'erreur se soit produite. Cela se produit souvent dans les programmes qui invitent les utilisateurs à entrer. Si le
programme répond correctement à une entrée non valide, il peut demander une entrée plus valide au lieu de se
bloquer.
Créons une calculatrice simple qui ne fait que diviser:

division.py print ("Donnez-moi deux nombres et je les diviserai.") print ("Entrez 'q' pour
quitter.")

tandis que Vrai:


u first_number = input ("\ nFirst number:") si first_number ==
'q':
Pause
v second_number = input ("Second number:") si
second_number == 'q':
Pause
w answer = int (first_number) / int (second_number) print (answer)

Ce programme invite l'utilisateur à saisir un premier_nombre u et, si l'utilisateur n'entre pas q pour
quitter, un second_number v. Nous divisons ensuite ces deux nombres pour obtenir un répondre w. Ce
programme ne fait rien pour gérer les erreurs, donc lui demander de diviser par zéro le fait planter:

Donnez-moi deux chiffres et je les diviserai. Entrez «q» pour


quitter.

Premier numéro: 5
Deuxième numéro: 0
Traceback (dernier appel le plus récent):
Fichier "division.py", ligne 9, dans <module>
answer = int (first_number) / int (second_number) ZeroDivisionError:
division par zéro

Fichiers et exceptions 201


C'est dommage que le programme plante, mais ce n'est pas non plus une bonne idée de laisser les
utilisateurs voir les traces. Les utilisateurs non techniques seront déroutés par eux, et dans un contexte malveillant,
les attaquants en apprendront plus que vous ne voulez qu'ils en sachent à partir d'un retraçage. Par exemple, ils
connaîtront le nom de votre fichier programme et verront une partie de votre code qui ne fonctionne pas
correctement. Un attaquant expérimenté peut parfois utiliser ces informations pour déterminer le type d'attaques à
utiliser contre votre code.

Le bloc else
Nous pouvons rendre ce programme plus résistant aux erreurs en enveloppant la ligne qui pourrait produire
des erreurs dans un essayer-sauf bloquer. L'erreur se produit sur la ligne qui effectue la division, c'est donc là
que nous mettrons le essayer-sauf bloquer. Cet exemple comprend également un autre bloquer. Tout code qui
dépend du essayer
le bloc s'exécutant avec succès entre dans le autre bloquer:

print ("Donnez-moi deux nombres et je les diviserai.") print ("Entrez 'q' pour
quitter.")

tandis que Vrai:


first_number = input ("\ nFirst number:") si first_number ==
'q':
Pause
second_number = input ("Second number:")
u essayer:

answer = int (first_number) / int (second_number)


v sauf ZeroDivisionError:
print ("Vous ne pouvez pas diviser par 0!") else:
w
imprimer (réponse)

Nous demandons à Python d'essayer de terminer l'opération de division dans un essayer


bloquer u, qui inclut uniquement le code susceptible de provoquer une erreur. Tout code qui dépend du essayer
le bloc qui réussit est ajouté au autre bloquer. Dans ce cas, si l'opération de division est réussie, nous
utilisons le autre bloquer pour imprimer le résultat w.

Le sauf block indique à Python comment répondre quand un ZeroDivisionError


surgit v. Si la essayer L'instruction ne réussit pas en raison d'une erreur de division par zéro, nous imprimons
un message convivial indiquant à l'utilisateur comment éviter ce type d'erreur. Le programme continue de
s'exécuter et l'utilisateur ne voit jamais de traceback:

Donnez-moi deux chiffres et je les diviserai. Entrez «q» pour


quitter.

Premier numéro: 5
Deuxième numéro: 0
Vous ne pouvez pas diviser par 0!

202 Chapitre 10
Premier numéro: 5
Deuxième numéro: 2
2,5

Premier numéro: q

Le essayer-sauf-autre block fonctionne comme ceci: Python tente d'exécuter le code dans le essayer déclaration.
Le seul code qui devrait entrer dans un essayer instruction est un code susceptible de déclencher une exception.
Parfois, vous aurez du code supplémentaire qui ne devrait s'exécuter que si le essayer le blocage a réussi; ce
code va dans le autre bloquer. Le sauf block indique à Python quoi faire au cas où une certaine exception se
produirait lorsqu'il essaie d'exécuter le code dans le essayer déclaration.

En anticipant les sources probables d'erreurs, vous pouvez écrire des programmes robustes qui continuent à
s'exécuter même lorsqu'ils rencontrent des données non valides et des ressources manquantes. Votre code sera
résistant aux erreurs d'utilisateurs innocents et aux attaques malveillantes.

Gestion de l'exception FileNotFoundError

Un problème courant lors de l'utilisation de fichiers est la gestion des fichiers manquants. Le fichier que vous
recherchez peut se trouver à un emplacement différent, le nom du fichier peut être mal orthographié ou le fichier
peut ne pas exister du tout. Vous pouvez gérer toutes ces situations de manière simple avec un essayer-sauf bloquer.

Essayons de lire un fichier qui n'existe pas. Le programme suivant essaie de lire le contenu de Alice
au pays des merveilles, mais je n'ai pas sauvegardé le fichier
alice.txt dans le même répertoire que alice.py:

alice.py filename = 'alice.txt'

avec open (filename) comme f_obj:


contenu = f_obj.read ()

Python ne peut pas lire à partir d'un fichier manquant, il lève donc une exception:

Traceback (dernier appel le plus récent):


Fichier "alice.py", ligne 3, dans <module>
avec open (filename) comme f_obj:
FileNotFoundError: [Errno 2] Aucun fichier ou répertoire de ce type: 'alice.txt'

La dernière ligne du retraçage signale un FileNotFoundError: c'est l'exception que Python crée
lorsqu'il ne trouve pas le fichier qu'il essaie d'ouvrir. Dans cet exemple, le ouvert() la fonction produit
l'erreur, donc pour la gérer, le essayer
block commencera juste avant la ligne qui contient ouvert():

filename = 'alice.txt'

essayer:

avec open (filename) comme f_obj:


contenu = f_obj.read ()

Fichiers et exceptions 203


sauf FileNotFoundError:
msg = "Désolé, le fichier" + filename + "n'existe pas." imprimer (msg)

Dans cet exemple, le code dans le essayer block produit un FileNotFoundError,


donc Python cherche un sauf bloc qui correspond à cette erreur. Python exécute ensuite le code
dans ce bloc, et le résultat est un message d'erreur convivial au lieu d'un retraçage:

Désolé, le fichier alice.txt n'existe pas.

Le programme n'a plus rien à faire si le fichier n'existe pas, donc le code de gestion des erreurs
n'ajoute pas grand-chose à ce programme. Développons cet exemple et voyons comment la gestion des
exceptions peut vous aider lorsque vous travaillez avec plusieurs fichiers.

Analyse du texte

Vous pouvez analyser des fichiers texte contenant des livres entiers. De nombreux ouvrages classiques de la
littérature sont disponibles sous forme de simples fichiers texte car ils sont dans le domaine public. Les textes
utilisés dans cette section proviennent du projet Gutenberg ( http://gutenberg.org/). Project Gutenberg maintient
une collection d'œuvres littéraires disponibles dans le domaine public, et c'est une excellente ressource si vous
êtes intéressé à travailler avec des textes littéraires dans vos projets de programmation.

Tirons le texte de Alice au pays des merveilles et essayez de compter le nombre de mots dans le texte.
Nous utiliserons la méthode string diviser(), qui peut construire une liste de mots à partir d'une chaîne. Voici
quoi diviser() fait avec une chaîne contenant
juste le titre " Alice au pays des merveilles":

>>> title = "Alice au pays des merveilles"


>>> title.split ()
['Alice au pays des merveilles']

Le diviser() La méthode sépare une chaîne en parties partout où elle trouve un espace et stocke toutes les
parties de la chaîne dans une liste. Le résultat est une liste de mots de la chaîne, bien que des signes de
ponctuation puissent également apparaître avec certains des mots. Pour compter le nombre de mots dans Alice
au pays des merveilles,
nous utiliserons diviser() sur tout le texte. Ensuite, nous compterons les éléments de la liste pour avoir une idée
approximative du nombre de mots dans le texte:

filename = 'alice.txt'

essayer:

avec open (filename) comme f_obj:


contenu = f_obj.read ()
sauf FileNotFoundError:
msg = "Désolé, le fichier" + filename + "n'existe pas." imprimer (msg)

204 Chapitre 10
autre:
# Comptez le nombre approximatif de mots dans le fichier. mots =
contents.split ()
u
v num_words = len (mots)
w print ("Le fichier" + nom de fichier + "a environ" + str (num_words) + "mots.")

J'ai déplacé le fichier alice.txt dans le bon répertoire, de sorte que le essayer block fonctionnera cette fois. À u nous
prenons la ficelle Contenu, qui contient désormais l'intégralité du texte de Alice au pays des merveilles comme une
longue chaîne, et utilisez le diviser()
méthode pour produire une liste de tous les mots du livre. Quand nous utilisons len () sur cette liste pour
examiner sa longueur, on obtient une bonne approximation du nombre de mots dans la chaîne d'origine v. À
w nous imprimons une déclaration indiquant le nombre de mots trouvés dans le fichier. Ce code est placé
dans le autre bloquer car cela ne fonctionnera que si le code dans le essayer block a été exécuté avec succès.
La sortie nous indique le nombre de mots dans alice.txt:

Le fichier alice.txt contient environ 29461 mots.

Le nombre est un peu élevé car des informations supplémentaires sont fournies par l'éditeur dans le fichier
texte utilisé ici, mais c'est une bonne approximation de la longueur de Alice au pays des merveilles.

Travailler avec plusieurs fichiers

Ajoutons plus de livres à analyser. Mais avant de le faire, déplaçons l'essentiel de ce programme vers
une fonction appelée count_words (). Ce faisant, il sera plus facile d'exécuter l'analyse pour plusieurs livres:

word_count.py def count_words (nom de fichier):


u "" "Comptez le nombre approximatif de mots dans un fichier." ""
essayer:

avec open (filename) comme f_obj:


contenu = f_obj.read ()
sauf FileNotFoundError:
msg = "Désolé, le fichier" + filename + "n'existe pas." imprimer (msg)

autre:
# Comptez le nombre approximatif de mots dans le fichier. mots =
contents.split ()

num_words = len (mots)


print ("Le fichier" + nom de fichier + "a environ" + str (num_words) +
" mots.")

filename = 'alice.txt'
count_words (nom de fichier)

La plupart de ce code est inchangé. Nous l'avons simplement indenté et déplacé dans le corps de count_words
(). C'est une bonne habitude de garder les commentaires à jour lorsque vous modifiez un programme, nous avons
donc changé le commentaire en docstring et l'avons légèrement reformulé u.

Fichiers et exceptions 205


Maintenant, nous pouvons écrire une boucle simple pour compter les mots dans n'importe quel texte que nous

voulons analyser. Nous faisons cela en stockant les noms des fichiers que nous voulons analyser dans une liste, puis nous

appelons count_words () pour chaque fichier de la liste. Nous essaierons de compter les mots pour Alice au pays des

merveilles, Siddhartha, Moby Dick, et Petite femme, qui sont tous disponibles dans le domaine public. J'ai laissé
intentionnellement

siddhartha.txt hors du répertoire contenant word_count.py, afin que nous puissions voir dans quelle mesure notre
programme gère un fichier manquant:

def count_words (nom de fichier):


- - couper--

filenames = ['alice.txt', 'siddhartha.txt', 'moby_dick.txt', 'little_women.txt'] pour le nom de fichier dans les noms de
fichiers:
count_words (nom de fichier)

Disparus siddhartha.txt file n'a aucun effet sur le reste de l'exécution du programme:

Le fichier alice.txt contient environ 29461 mots. Désolé, le fichier


siddhartha.txt n'existe pas. Le fichier moby_dick.txt contient environ
215136 mots. Le fichier little_women.txt contient environ 189079 mots.

En utilisant le essayer-sauf bloc dans cet exemple offre deux avantages significatifs. Nous
empêchons nos utilisateurs de voir une trace, et nous laissons le programme continuer à analyser les
textes qu'il est capable de trouver. Si nous n'attrapons pas le FileNotFoundError cette siddhartha.txt soulevé,
l'utilisateur verrait un suivi complet et le programme cesserait de s'exécuter après avoir essayé
d'analyser
Siddhartha. Il n'analyserait jamais Moby Dick ou Petite femme.

Échouer silencieusement

Dans l'exemple précédent, nous avons informé nos utilisateurs que l'un des fichiers
n'était pas disponible. Mais vous n'avez pas besoin de signaler chaque exception que vous détectez. Parfois, vous voudrez
que le programme échoue silencieusement lorsqu'une exception se produit et continue comme si de rien n'était. Pour faire
échouer un programme en silence, vous écrivez un essayer comme d'habitude, mais vous dites explicitement à Python de ne
rien faire dans le
sauf bloquer. Python a un passe instruction qui lui dit de ne rien faire dans un bloc:

def count_words (nom de fichier):


"" "Comptez le nombre approximatif de mots dans un fichier." "" Essayez:

- - couper--
sauf FileNotFoundError:
u passe

autre:
- - couper--

filenames = ['alice.txt', 'siddhartha.txt', 'moby_dick.txt', 'little_women.txt'] pour le nom de fichier dans les noms de
fichiers:
count_words (nom de fichier)

206 Chapitre 10
La seule différence entre cette liste et la précédente est la
passe déclaration à u. Maintenant quand un FileNotFoundError est déclenché, le code dans le sauf le bloc
s'exécute, mais rien ne se passe. Aucune trace n'est produite et il n'y a pas de sortie en réponse à l'erreur qui
a été déclenchée. Les utilisateurs voient le nombre de mots pour chaque fichier existant, mais ils ne voient
aucune indication qu'un fichier n'a pas été trouvé:

Le fichier alice.txt contient environ 29461 mots.


Le fichier moby_dick.txt contient environ 215136 mots. Le fichier
little_women.txt contient environ 189079 mots.

Le passe L'instruction agit également comme un espace réservé. C'est un rappel que vous choisissez de ne
rien faire à un moment précis de l'exécution de votre programme et que vous voudrez peut-être y faire quelque
chose plus tard. Par exemple, dans ce programme, nous pourrions décider d'écrire les noms de fichiers manquants
dans un fichier appelé
missing_files.txt. Nos utilisateurs ne verraient pas ce fichier, mais nous pourrions le lire et traiter
les textes manquants.

Décider des erreurs à signaler

Comment savoir quand signaler une erreur à vos utilisateurs et quand échouer en silence? Si les utilisateurs savent
quels textes sont censés être analysés, ils pourraient apprécier un message les informant des raisons pour lesquelles
certains textes n'ont pas été analysés. Si les utilisateurs s'attendent à voir des résultats mais ne savent pas quels
livres sont censés être analysés, ils n'ont peut-être pas besoin de savoir que certains textes n'étaient pas disponibles.
Donner aux utilisateurs des informations qu'ils ne recherchent pas peut diminuer la convivialité de votre programme.
Les structures de gestion des erreurs de Python vous donnent un contrôle précis sur la quantité à partager avec les
utilisateurs lorsque les choses tournent mal; c'est à vous de décider de la quantité d'informations à partager.

Un code bien écrit et correctement testé n'est pas très sujet aux erreurs internes, telles que la syntaxe
ou les erreurs logiques. Mais chaque fois que votre programme dépend de quelque chose d'externe, comme
l'entrée de l'utilisateur, l'existence d'un fichier ou la disponibilité d'une connexion réseau, il est possible
qu'une exception soit levée. Un peu d'expérience vous aidera à savoir où inclure les blocs de gestion des
exceptions dans votre programme et dans quelle mesure signaler aux utilisateurs les erreurs qui
surviennent.

essayez-le vous-même

10-6. Une addition: Un problème courant lors de la demande de saisie numérique se produit lorsque les utilisateurs

fournissent du texte au lieu de chiffres. Lorsque vous essayez de convertir l'entrée en un int, vous obtiendrez un Erreur-type

. Écrivez un programme qui demande deux nombres. Ajoutez-les ensemble et imprimez le résultat. Attrapez le Erreur-type

si l'une des valeurs d'entrée n'est pas un nombre, et affichez un message d'erreur convivial. Testez votre programme

en saisissant deux chiffres, puis en saisissant du texte au lieu d'un

numéro .
(a continué)

Fichiers et exceptions 207


10-7. Calculateur d'addition: Enveloppez votre code de l'exercice 10-6 dans un tandis que boucle pour que l'utilisateur

puisse continuer à entrer des nombres même s'il fait une erreur et entre du texte au lieu d'un nombre.

10-8. Les chats et les chiens: Faites deux fichiers, cats.txt et dogs.txt. Stockez au moins trois noms de chats dans le

premier fichier et trois noms de chiens dans le second fichier. Écrivez un programme qui essaie de lire ces fichiers et

d'imprimer le contenu du fichier à l'écran. Enveloppez votre code dans un essayer-sauf bloquer pour attraper le Fichier

introuvable erreur et imprimez un message convivial si un fichier est manquant. Déplacez l'un des fichiers vers un

emplacement différent sur votre système et assurez-vous que le code dans le sauf block s'exécute correctement.

10-9. Chats et chiens silencieux: Modifiez votre sauf dans l'exercice 10-8 pour échouer silencieusement si l'un des fichiers est

manquant.

10-10. Mots communs: Visitez Project Gutenberg ( http://gutenberg.org/)


et trouvez quelques textes que vous aimeriez analyser. Téléchargez les fichiers texte de ces travaux ou copiez le

texte brut de votre navigateur dans un fichier texte sur votre ordinateur.

Vous pouvez utiliser le compter() pour savoir combien de fois un mot ou une phrase apparaît dans une
chaîne. Par exemple, le code suivant compte le nombre de fois ' rangée' apparaît dans une chaîne:

>>> line = "Row, row, row your boat"


>>> line.count ('ligne')
2
>>> line.lower (). count ('ligne')
3

Notez que la conversion de la chaîne en minuscules à l'aide de plus bas() capture toutes les
apparences du mot que vous recherchez, quel que soit son format.

Écrivez un programme qui lit les fichiers que vous avez trouvés sur Project Gutenberg et détermine

combien de fois le mot ' le' apparaît dans chaque texte.

stocker des données

Beaucoup de vos programmes demanderont aux utilisateurs de saisir certains types d'informations. Vous pouvez autoriser

les utilisateurs à stocker des préférences dans un jeu ou à fournir des données pour une visualisation. Quel que soit l'objectif

de votre programme, vous stockerez les informations fournies par les utilisateurs dans des structures de données telles que

des listes et des dictionnaires. Lorsque les utilisateurs ferment un programme, vous voudrez presque toujours enregistrer les

informations qu'ils ont saisies. Un moyen simple de le faire consiste à stocker vos données à l'aide du

json module.

208 Chapitre 10
Le json module vous permet de vider des structures de données Python simples dans un fichier et de charger les

données de ce fichier la prochaine fois que le programme s'exécute. Vous pouvez aussi utiliser json pour partager des données

entre différents programmes Python. Mieux encore, le format de données JSON n'est pas spécifique à Python, vous pouvez

donc partager les données que vous stockez au format JSON avec des personnes qui travaillent dans de nombreux autres

langages de programmation. C'est un format utile et portable, et il est facile à apprendre.

Remarque Le format JSON (JavaScript Object Notation) a été initialement développé pour JavaScript. Cependant, il est depuis
devenu un format commun utilisé par de nombreux langages, y compris Python.

Utilisation de json.dump () et json.load ()

Écrivons un programme court qui stocke un ensemble de nombres et un autre programme qui lit ces
nombres en mémoire. Le premier programme utilisera json.dump () pour stocker l'ensemble de nombres,
et le deuxième programme utilisera
json.load ().
Le json.dump () La fonction prend deux arguments: une donnée à stocker et un objet fichier qu'elle peut
utiliser pour stocker les données. Voici comment vous pouvez utiliser
json.dump () pour stocker une liste de nombres:

numéro_ importer json


écrivain.py

nombres = [2, 3, 5, 7, 11, 13]

u filename = 'nombres.json'
v avec open (filename, 'w') comme f_obj:
w json.dump (nombres, f_obj)

Nous importons d'abord le json module, puis créez une liste de nombres avec lesquels travailler. À u nous
choisissons un nom de fichier dans lequel stocker la liste des nombres. Il est courant d'utiliser l'extension de
fichier. json pour indiquer que les données du fichier sont stockées au format JSON. Ensuite, nous ouvrons le
fichier en écriture, ce qui permet json pour écrire les données dans le fichier v. À w nous utilisons le json.dump ()

fonction pour stocker la liste Nombres dans le fichier nombres.json.


Ce programme n'a pas de sortie, mais ouvrons le fichier nombres.json et regardez-le. Les
données sont stockées dans un format qui ressemble à Python:

[2, 3, 5, 7, 11, 13]

Maintenant, nous allons écrire un programme qui utilise json.load () pour relire la liste en mémoire:

numéro_ importer json


reader.py
u filename = 'nombres.json'
v avec open (filename) comme f_obj:
w nombres = json.load (f_obj)

imprimer (nombres)

Fichiers et exceptions 209


À u nous nous assurons de lire à partir du même fichier dans lequel nous avons écrit. Cette fois-ci, lorsque
nous ouvrons le fichier, nous l'ouvrons en mode lecture car Python n'a besoin que de lire à partir du fichier v. À w nous
utilisons le json.load () fonction pour charger les informations stockées dans nombres.json, et nous le stockons dans la
variable Nombres.
Enfin, nous imprimons la liste des numéros récupérés et voyons que c'est la même liste créée dans number_writer.py:

[2, 3, 5, 7, 11, 13]

Il s'agit d'un moyen simple de partager des données entre deux programmes.

Enregistrement et lecture des données générées par l'utilisateur

Sauvegarde des données avec json est utile lorsque vous travaillez avec des données générées par l'utilisateur, car si vous

ne stockez pas les informations de votre utilisateur d'une manière ou d'une autre, vous les perdrez lorsque le programme

s'arrêtera de s'exécuter. Regardons un exemple dans lequel nous demandons à l'utilisateur son nom la première fois qu'il

exécute un programme, puis nous nous souvenons de son nom lorsqu'il réexécutera le programme.

Commençons par stocker le nom de l'utilisateur:

rappelles toi_ importer json


me.py
u username = input ("Quel est votre nom?")

filename = 'username.json'
avec open (filename, 'w') comme f_obj:
v json.dump (nom d'utilisateur, f_obj)
w print ("Nous nous souviendrons de vous à votre retour," + nom d'utilisateur + "!")

À u nous demandons un nom d'utilisateur à stocker. Ensuite, nous utilisons json.dump (),

en lui passant un nom d'utilisateur et un objet fichier, pour stocker le nom d'utilisateur dans un fichier v.

Ensuite, nous imprimons un message informant l'utilisateur que nous avons stocké ses informations w:

Quel est ton nom? Eric


Nous nous souviendrons de vous à votre retour, Eric!

Maintenant, écrivons un nouveau programme qui salue un utilisateur dont le nom a déjà été
stocké:

greet_user.py importer json

filename = 'username.json'

avec open (filename) comme f_obj:


u nom d'utilisateur = json.load (f_obj)
v print ("Bienvenue à nouveau," + nom d'utilisateur + "!")

210 Chapitre 10
À u nous utilisons json.load () pour lire les informations stockées dans username.json
dans la variable Nom d'utilisateur. Maintenant que nous avons récupéré le nom d'utilisateur, nous pouvons les accueillir à

nouveau v:

Bienvenue à nouveau, Eric!

Nous devons combiner ces deux programmes en un seul fichier. Quand quelqu'un court Remember_me.py, nous
voulons récupérer leur nom d'utilisateur de la mémoire si possible; par conséquent, nous allons commencer par un essayer
bloc qui tente de récupérer le nom d'utilisateur. Si le fichier username.json n'existe pas, nous aurons le sauf bloquer
l'invite pour un nom d'utilisateur et le stocker dans username.json pour la prochaine fois:

rappelles toi_ importer json


me.py
# Chargez le nom d'utilisateur, s'il a été stocké précédemment.
# Sinon, demandez le nom d'utilisateur et enregistrez-le. filename =
'username.json'

essayer:

u avec open (filename) comme f_obj:


v nom d'utilisateur = json.load (f_obj)
w sauf FileNotFoundError:
X username = input ("Quel est votre nom?")
y avec open (filename, 'w') comme f_obj:
json.dump (nom d'utilisateur, f_obj)
print ("Nous nous souviendrons de vous à votre retour," + nom d'utilisateur + "!")
autre:
print ("Bienvenue à nouveau," + nom d'utilisateur + "!")

Il n'y a pas de nouveau code ici; les blocs de code des deux derniers exemples sont simplement combinés
en un seul fichier. À u nous essayons d'ouvrir le fichier username.json.
Si ce fichier existe, nous lisons le nom d'utilisateur en mémoire v et imprimez un message de bienvenue à
l'utilisateur dans le autre bloquer. Si c'est la première fois que l'utilisateur exécute le programme, username.json
n'existera pas et un FileNotFoundError
se produira w. Python passera à la sauf bloquer où nous invitons l'utilisateur à entrer son nom d'utilisateur X. Nous
utilisons ensuite json.dump () pour stocker le nom d'utilisateur et imprimer un message d'accueil y.

Quel que soit le bloc exécuté, le résultat est un nom d'utilisateur et un message d'accueil approprié. Si
c'est la première fois que le programme s'exécute, voici la sortie:

Quel est ton nom? Eric


Nous nous souviendrons de vous à votre retour, Eric!

Sinon:

Bienvenue à nouveau, Eric!

C'est la sortie que vous voyez si le programme a déjà été exécuté au moins une fois.

Fichiers et exceptions 211


Refactoring

Souvent, vous arriverez à un point où votre code fonctionnera, mais vous reconnaîtrez que vous pouvez
améliorer le code en le décomposant en une série de fonctions qui ont des tâches spécifiques. Ce
processus s'appelle refactoring. La refactorisation rend votre code plus propre, plus facile à comprendre et
plus facile à étendre.
Nous pouvons refactoriser Remember_me.py en déplaçant l'essentiel de sa logique dans une ou plusieurs
fonctions. L'objectif de Remember_me.py est en train de saluer l'utilisateur, alors déplaçons tout notre code existant
dans une fonction appelée greet_user ():

rappelles toi_ importer json


me.py
def greet_user ():
u "" "Saluez l'utilisateur par son nom." ""
filename = 'username.json'
essayer:

avec open (filename) comme f_obj:


nom d'utilisateur = json.load (f_obj)
sauf FileNotFoundError:
username = input ("Quel est votre nom?") avec open
(filename, 'w') comme f_obj:
json.dump (nom d'utilisateur, f_obj)
print ("Nous nous souviendrons de vous à votre retour," + nom d'utilisateur + "!")
autre:
print ("Bienvenue à nouveau," + nom d'utilisateur + "!")

Greet_user ()

Parce que nous utilisons une fonction maintenant, nous mettons à jour les commentaires avec une
docstring qui reflète le fonctionnement actuel du programme u. Ce fichier est un peu plus propre, mais la fonction Greet_user
() fait plus que simplement saluer l'utilisateur - il récupère également un nom d'utilisateur stocké s'il en existe un et
demande un nouveau nom d'utilisateur s'il n'en existe pas.

Refactorisons Greet_user () il ne fait donc pas autant de tâches différentes. Nous commencerons par déplacer
le code de récupération d'un nom d'utilisateur stocké vers une fonction distincte:

importer json

def get_stored_username ():


u "" "Obtenez le nom d'utilisateur enregistré si disponible." ""

filename = 'username.json'
essayer:

avec open (filename) comme f_obj:


nom d'utilisateur = json.load (f_obj)
sauf FileNotFoundError:
v retour Aucun
autre:
retourner le nom d'utilisateur

212 Chapitre 10
def greet_user ():
"" "Saluez l'utilisateur par son nom." ""
nom d'utilisateur = get_stored_username ()
w si nom d'utilisateur:

print ("Welcome back," + username + "!") else:

username = input ("Quel est votre nom?") filename =


'username.json'
avec open (filename, 'w') comme f_obj:
json.dump (nom d'utilisateur, f_obj)
print ("Nous nous souviendrons de vous à votre retour," + nom d'utilisateur + "!")

Greet_user ()

La nouvelle fonction get_stored_username () a un objectif clair, comme indiqué dans la docstring à u. Cette
fonction récupère un nom d'utilisateur stocké et renvoie le nom d'utilisateur si elle en trouve un. Si le fichier username.json
n'existe pas, la fonction retourne Aucun v. C'est une bonne pratique: une fonction doit soit renvoyer la valeur
que vous attendez, soit elle doit renvoyer Aucun. Cela nous permet d'effectuer un test simple avec la valeur
de retour de la fonction. À w nous imprimons un message de bienvenue à l'utilisateur si la tentative de
récupération d'un nom d'utilisateur a réussi, et si ce n'est pas le cas, nous demandons un nouveau nom
d'utilisateur.

Nous devrions factoriser un autre bloc de code sur greet_user (). Si le nom d'utilisateur
n'existe pas, nous devrions déplacer le code qui demande un nouveau nom d'utilisateur vers une
fonction dédiée à cet effet:

importer json

def get_stored_username ():


"" "Obtenez le nom d'utilisateur enregistré si disponible." ""

- - couper--

def get_new_username ():


"" "Demander un nouveau nom d'utilisateur." ""
username = input ("Quel est votre nom?") filename =
'username.json'
avec open (filename, 'w') comme f_obj:
json.dump (nom d'utilisateur, f_obj)
retourner le nom d'utilisateur

def greet_user ():


"" "Saluez l'utilisateur par son nom." "" Username
= get_stored_username ()
si nom d'utilisateur:

print ("Welcome back," + username + "!") else:

nom d'utilisateur = get_new_username ()


print ("Nous nous souviendrons de vous à votre retour," + nom d'utilisateur + "!")

Greet_user ()

Fichiers et exceptions 213


Chaque fonction de cette version finale de Remember_me.py a un objectif unique et clair. Nous appelons greet_user
(), et cette fonction imprime un message approprié: soit elle souhaite la bienvenue à un utilisateur existant, soit elle
accueille un nouvel utilisateur. Il fait cela en appelant get_stored_username (), qui est uniquement responsable de la
récupération d'un nom d'utilisateur stocké s'il en existe un. Pour terminer, Greet_user () appels get_new_username ()

si nécessaire, qui est uniquement responsable de l'obtention d'un nouveau nom d'utilisateur et de son stockage.
Cette compartimentation du travail est une partie essentielle de l'écriture d'un code clair qui sera facile à maintenir
et à étendre.

essayez-le vous-même

10-11. Numéro préféré: Écrivez un programme qui demande le numéro préféré de l'utilisateur. Utilisation json.dump

() pour stocker ce numéro dans un fichier. Écrivez un programme séparé qui lit cette valeur et imprime le

message «Je connais votre numéro préféré! Son _____ ."

10-12. Numéro préféré mémorisé: Combinez les deux programmes de l'exercice 10-11 en un seul fichier. Si le

numéro est déjà enregistré, signalez le numéro favori à l'utilisateur. Sinon, demandez le numéro favori de

l'utilisateur et enregistrez-le dans un fichier. Exécutez le programme deux fois pour voir qu'il fonctionne.

10-13. Vérifier l'utilisateur: La liste finale pour Remember_me.py suppose que l'utilisateur a déjà entré son nom

d'utilisateur ou que le programme est en cours d'exécution pour la première fois. Nous devons le modifier au cas où

l'utilisateur actuel ne serait pas la dernière personne qui a utilisé le programme.

Avant d'imprimer un message de bienvenue dans greet_user (), demandez à l'utilisateur s'il s'agit du nom d'utilisateur correct.

Si ce n'est pas le cas, appelez get_new_username () pour obtenir le nom d'utilisateur correct.

résumé
Dans ce chapitre, vous avez appris à utiliser des fichiers. Vous avez appris à lire un fichier entier à la fois et à lire le
contenu d'un fichier une ligne à la fois. Vous avez appris à écrire dans un fichier et à ajouter du texte à la fin d'un
fichier. Vous lisez des informations sur les exceptions et comment gérer les exceptions que vous êtes susceptible
de voir dans vos programmes. Enfin, vous avez appris à stocker des structures de données Python afin de pouvoir
enregistrer les informations fournies par vos utilisateurs, en les évitant d'avoir à recommencer à chaque fois qu'ils
exécutent un programme.

Au chapitre 11, vous apprendrez des moyens efficaces de tester votre code. Cela vous aidera à être sûr que le
code que vous développez est correct, et cela vous aidera à identifier les bogues qui sont introduits lorsque vous
continuez à construire sur les programmes que vous avez écrits.

214 Chapitre 10
11
testez votre CoDe

Lorsque vous écrivez une fonction ou une classe, vous pouvez

également écrire des tests pour ce code. Les tests prouvent que votre code

fonctionne comme il est censé le faire en réponse à tous les types d'entrée pour

lesquels il est conçu. Lorsque vous écrivez des tests, vous pouvez être sûr que

votre code fonctionnera correctement à mesure que de plus en plus de personnes

commenceront à utiliser vos programmes. Vous pourrez également tester

nouveau code au fur et à mesure que vous l'ajoutez pour vous assurer que vos modifications ne perturbent pas le

comportement existant de votre programme. Chaque programmeur fait des erreurs, donc chaque programmeur doit

tester son code souvent, en détectant les problèmes avant que les utilisateurs ne les rencontrent.

Dans ce chapitre, vous apprendrez à tester votre code à l'aide d'outils de Python
Test de l'unité module. Vous apprendrez à créer un cas de test et à vérifier qu'un ensemble d'entrées donne la
sortie souhaitée. Vous verrez à quoi ressemble un test réussi et à quoi ressemble un test échoué, et vous
apprendrez comment un test échoué peut vous aider à améliorer votre code. Vous apprendrez à tester des
fonctions et des classes, et vous commencerez à comprendre le nombre de tests à écrire pour un projet.
tester une fonction
Pour en savoir plus sur les tests, nous avons besoin de code à tester. Voici une fonction simple qui prend un
prénom et un nom et renvoie un nom complet parfaitement formaté:

Nom_ def get_formatted_name (premier, dernier):


function.py "" "Génère un nom complet soigneusement formaté." "" Full_name
= first + '' + last
retourne full_name.title ()

La fonction get_formatted_name () combine le prénom et le nom avec un espace entre les deux pour
compléter un nom complet, puis met en majuscule et renvoie le nom complet. Pour vérifier ça get_formatted_name
() fonctionne, faisons un programme qui utilise cette fonction. Le programme names.py permet aux
utilisateurs de saisir un prénom et un nom et de voir un nom complet parfaitement formaté:

names.py from name_function import get_formatted_name

print ("Entrez 'q' à tout moment pour quitter.") avec True:

first = input ("\ nVeuillez me donner un prénom:") si first == 'q':

Pause
last = input ("Veuillez me donner un nom de famille:") if last == 'q':

Pause

nom_formaté = get_nom_formaté (premier, dernier) print ("\ tNom correctement


formaté:" + nom_formaté + '.')

Ce programme importe get_formatted_name () de name_function.py. L'utilisateur peut entrer


une série de prénoms et de noms et voir les noms complets formatés générés:

Entrez «q» à tout moment pour quitter.

Veuillez me donner un prénom: Janis


Veuillez me donner un nom de famille: joplin
Nom parfaitement formaté: Janis Joplin.

Veuillez me donner un prénom: bob


Veuillez me donner un nom de famille: Dylan
Nom parfaitement formaté: Bob Dylan.

Veuillez me donner un prénom: q

Nous pouvons voir que les noms générés ici sont corrects. Mais disons que nous voulons modifier get_formatted_name
() il peut donc également gérer les prénoms. Ce faisant, nous voulons nous assurer de ne pas casser la
façon dont la fonction gère les noms qui n'ont qu'un prénom et un nom. Nous pourrions tester notre code

216 Chapitre 11
en exécutant names.py et entrer un nom comme Janis Joplin à chaque fois que nous modifions get_formatted_name
(), mais cela deviendrait fastidieux. Heureusement, Python fournit un moyen efficace d'automatiser le test
de la sortie d'une fonction. Si nous automatisons les tests de get_formatted_name (), nous pouvons toujours
être sûrs que la fonction fonctionnera avec les types de noms pour lesquels nous avons écrit des tests.

Tests unitaires et cas de test

Le module Test de l'unité de la bibliothèque standard Python fournit des outils pour tester votre code. UNE Test de l'unité vérifie
qu'un aspect spécifique du comportement d'une fonction est correct. UNE cas de test est une collection de tests
unitaires qui, ensemble, prouvent qu'une fonction se comporte comme elle est censée le faire, dans la gamme
complète des situations que vous vous attendez à ce qu'elle gère. Un bon cas de test considère tous les types
d'entrées possibles qu'une fonction pourrait recevoir et inclut des tests pour représenter chacune de ces situations. Un
cas de test avec couverture totale inclut une gamme complète de tests unitaires couvrant toutes les manières possibles
d'utiliser une fonction. Obtenir une couverture complète sur un grand projet peut être intimidant. Il est souvent suffisant
d'écrire des tests pour les comportements critiques de votre code, puis de ne viser une couverture complète que si le
projet commence à être largement utilisé.

Un test de réussite

La syntaxe pour configurer un cas de test demande un certain temps pour s'y habituer, mais une fois que vous avez
configuré le cas de test, il est simple d'ajouter plus de tests unitaires pour vos fonctions. Pour écrire un cas de test
pour une fonction, importez le Test de l'unité module et la fonction que vous souhaitez tester. Ensuite, créez une classe
qui hérite de
unittest.TestCase, et écrivez une série de méthodes pour tester différents aspects du comportement de votre
fonction.
Voici un cas de test avec une méthode qui vérifie que la fonction
get_formatted_name () fonctionne correctement lorsqu'on lui donne un prénom et un nom:

nom du test_ importer unittest


function.py from name_function import get_formatted_name

u classe NamesTestCase (unittest.TestCase):


"" "Tests pour 'name_function.py'." ""

def test_first_last_name (soi-même):


"" "Est-ce que des noms comme" Janis Joplin "fonctionnent?" ""

v nom_formaté = get_nom_formaté ('janis', 'joplin') self.assertEqual (nom_formaté,


w 'Janis Joplin')

unittest.main ()

Tout d'abord, nous importons Test de l'unité et la fonction que nous voulons tester, get_formatted_ name (). À u nous
créons une classe appelée NamesTestCase, qui contiendra une série de tests unitaires pour get_formatted_name (). Vous pouvez
nommer la classe comme vous le souhaitez

Tester votre code 217