The Python Language Reference

Version 3.13.7

Guido van Rossum and the Python development team

octobre 01, 2025

Python Software Foundation

Email : docs@[Link]
 Table des matières

1 Introduction 3
1.1 Autres implé mentations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Notations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Analyse lexicale 5
2.1 Structure des lignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Lignes logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Lignes physiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.3 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.4 Dé claration d’encodage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.5 Continuation de ligne explicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.6 Continuation de ligne implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.7 Lignes vierges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.8 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.9 Espaces entre lexè mes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Autres lexè mes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Identifiants et mots-clé s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3.1 Mots-clé s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.2 Mots-clé s ad hoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.3 Classes ré servé es pour les identifiants . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4 Litté raux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4.1 Litté raux de chaînes de caractè res et de suites d’octets . . . . . . . . . . . . . . . . . . . 10
2.4.2 Concaté nation de chaînes de caractè res . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.3 f-strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.4 Litté raux numé riques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.5 Entiers litté raux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.6 Floating-point literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.7 Imaginaires litté raux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5 Opé rateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.6 Dé limiteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3 Modèle de données 17
3.1 Objets, valeurs et types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Hié rarchie des types standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.1 None . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.2 NotImplemented . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.3 Ellipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.4 [Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.5 Sé quences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.6 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.7 Tableaux de correspondances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

i
 3.2.8 Types appelables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.9 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2.10 Classes dé claré es par le dé veloppeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.11 Instances de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2.12 Objets entré es-sorties (ou objets fichiers) . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2.13 Types internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3 Mé thodes spé ciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.1 Personnalisation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3.2 Personnalisation de l’accè s aux attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3.3 Personnalisation de la cré ation de classes . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.3.4 Personnalisation des instances et vé rification des sous-classes . . . . . . . . . . . . . . . . 46
3.3.5 Émulation de types gé né riques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.3.6 Émulation d’objets appelables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.3.7 Émulation de types conteneurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.3.8 Émulation de types numé riques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.3.9 Gestionnaire de contexte With . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.3.10 Arguments positionnels dans le filtrage par motif sur les classes . . . . . . . . . . . . . . 53
3.3.11 Emulating buffer types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.3.12 Recherche des mé thodes spé ciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.4 Coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.4.1 Objets attendables (awaitable) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.4.2 Objets coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.4.3 Ité rateurs asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.4.4 Gestionnaires de contexte asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4 Modèle d’exécution 59
4.1 Structure d’un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2 Noms et liaisons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2.1 Liaisons des noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2.2 Ré solution des noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.2.3 Annotation scopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.4 Lazy evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.5 Noms natifs et restrictions d’exé cution . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.2.6 Interaction avec les fonctionnalité s dynamiques . . . . . . . . . . . . . . . . . . . . . . . 62
4.3 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

5 Le système d’importation 65
5.1 importlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.2 Les paquets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.2.1 Paquets classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.2.2 Paquets espaces de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.3 Recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.3.1 Cache des modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.3.2 Chercheurs et chargeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.3.3 Points d’entré es automatiques pour l’importation . . . . . . . . . . . . . . . . . . . . . . 68
5.3.4 Mé ta-chemins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.4 Chargement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.4.1 Chargeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.4.2 Sous-modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.4.3 Spé cificateurs de modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.4.4 l’attribut __path__ des modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.4.5 Repré sentation textuelle d’un module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.4.6 Invalidation de bytecode mis en cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.5 Le chercheur dans path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.5.1 Chercheurs d’entré e dans path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.5.2 Protocole des chercheurs d’entré e dans path . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.6 Remplacement du systè me d’importation standard . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.7 Importations relatives au paquet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

ii
 5.8 Cas particulier de __main__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.8.1 __main__.__spec__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.9 Ré fé rences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

6 Expressions 77
6.1 Conversions arithmé tiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.2 Atomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.2.1 Identifiants (noms) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.2.2 Litté raux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
6.2.3 Formes parenthé sé es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
6.2.4 Agencements des listes, ensembles et dictionnaires . . . . . . . . . . . . . . . . . . . . . 79
6.2.5 Agencements de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.2.6 Agencements d’ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.2.7 Agencements de dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.2.8 Expressions gé né ratrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.2.9 Expressions yield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.3 Primaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.3.1 Ré fé rences à des attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.3.2 sé lection (ou indiçage) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.3.3 Tranches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.3.4 Appels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.4 Expression await . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.5 L’opé rateur puissance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.6 Arithmé tique unaire et opé rations sur les bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.7 Opé rations arithmé tiques binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.8 Opé rations de dé calage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
6.9 Opé rations binaires bit à bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.10 Comparaisons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.10.1 Comparaisons de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.10.2 Opé rations de tests d’appartenance à un ensemble . . . . . . . . . . . . . . . . . . . . . 93
6.10.3 Comparaisons d’identifiants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.11 Opé rations boolé ennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.12 Expressions d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.13 Expressions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.14 Expressions lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.15 Listes d’expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.16 Ordre d’é valuation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
6.17 Priorité s des opé rateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

7 Les instructions simples 99

7.1 Les expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
7.2 Les assignations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.2.1 Les assignations augmenté es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
7.2.2 Les assignations annoté es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.3 L’instruction assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.4 L’instruction pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.5 L’instruction del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.6 L’instruction return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.7 L’instruction yield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.8 L’instruction raise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.9 L’instruction break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.10 L’instruction continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.11 L’instruction import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.11.1 L’instruction future . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
7.12 L’instruction global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7.13 L’instruction nonlocal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
7.14 The type statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

iii
8 Instructions composées 111
8.1 L’instruction if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
8.2 L’instruction while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
8.3 L’instruction for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
8.4 L’instruction try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.4.1 clause except . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.4.2 clause except* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
8.4.3 clause else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
8.4.4 clause finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
8.5 L’instruction with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.6 L’instruction match . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8.6.1 Aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8.6.2 Gardes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.6.3 Bloc case attrape-tout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.6.4 Filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.7 Dé finition de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
8.8 Dé finition de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
8.9 Coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
8.9.1 Dé finition de fonctions coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
8.9.2 L’instruction async for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
8.9.3 L’instruction async with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
8.10 Type parameter lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
8.10.1 Generic functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
8.10.2 Generic classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
8.10.3 Generic type aliases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

9 Composants de plus haut niveau 135

9.1 Programmes Python complets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
9.2 Fichier d’entré e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
9.3 Entré e interactive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
9.4 Entré e d’expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

10 Spécification complète de la grammaire 137

A Glossaire 155

B About this documentation 173

B.1 Contributors to the Python documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

C Histoire et licence 175

C.1 Histoire du logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
C.2 Conditions gé né rales pour accé der à , ou utiliser, Python . . . . . . . . . . . . . . . . . . . . . . . 176
C.2.1 PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 . . . . . . . . . . . . . 176
C.2.2 LICENCE D’UTILISATION [Link] POUR PYTHON 2.0 . . . . . . . . . . . 177
C.2.3 LICENCE D’UTILISATION CNRI POUR PYTHON 1.6.1 . . . . . . . . . . . . . . . . 177
C.2.4 LICENCE D’UTILISATION CWI POUR PYTHON 0.9.0 à 1.2 . . . . . . . . . . . . . 179
C.2.5 ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION . 179
C.3 Licences et remerciements pour les logiciels tiers . . . . . . . . . . . . . . . . . . . . . . . . . . 179
C.3.1 Mersenne twister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
C.3.2 Interfaces de connexion (sockets) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
C.3.3 Interfaces de connexion asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
C.3.4 Gestion de té moin (cookie) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
C.3.5 Traçage d’exé cution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
C.3.6 Les fonctions UUencode et UUdecode . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
C.3.7 Appel de procé dures distantes en XML (RPC, pour Remote Procedure Call) . . . . . . . . 183
C.3.8 test_epoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
C.3.9 Select kqueue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
C.3.10 SipHash24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
C.3.11 strtod et dtoa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

iv
 C.3.12 OpenSSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
C.3.13 expat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
C.3.14 libffi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
C.3.15 zlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
C.3.16 cfuhash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
C.3.17 libmpdec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
C.3.18 Ensemble de tests C14N du W3C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
C.3.19 mimalloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
C.3.20 asyncio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
C.3.21 Global Unbounded Sequences (GUS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

D Copyright 195

Index 197

v
vi
 The Python Language Reference, Version 3.13.7

Cette documentation dé crit la syntaxe et la « sé mantique interne » du langage. Elle peut ê tre laconique, mais essaye
d’ê tre exhaustive et exacte. La sé mantique des objets natifs secondaires, des fonctions, et des modules est documenté e
dans library-index. Pour une pré sentation informelle du langage, voyez plutô t tutorial-index. Pour les dé veloppeurs C
ou C++, deux manuels supplé mentaires existent : extending-index survole l’é criture d’extensions, et c-api-index dé crit
l’interface C/C++ en dé tail.

Table des matières 1

The Python Language Reference, Version 3.13.7

2 Table des matières

 CHAPITRE 1

Introduction

Ce manuel de ré fé rence dé crit le langage de programmation Python. Il n’a pas vocation à ê tre un tutoriel.
Nous essayons d’ê tre le plus pré cis possible et nous utilisons le français (NdT : ou l’anglais pour les parties qui ne sont
pas encore traduites) plutô t que des spé cifications formelles, sauf pour la syntaxe et l’analyse lexicale. Nous espé rons
ainsi rendre ce document plus compré hensible pour un grand nombre de lecteurs, mê me si cela laisse un peu de place
à l’ambiguïté . En consé quence, si vous arrivez de Mars et que vous essayez de ré -implé menter Python à partir de cet
unique document, vous devrez faire des hypothè ses et, finalement, vous aurez certainement implé menté un langage
sensiblement diffé rent. D’un autre cô té , si vous utilisez Python et que vous vous demandez quelles rè gles s’appliquent
pour telle partie du langage, vous devriez trouver une ré ponse satisfaisante ici. Si vous souhaitez voir une dé finition
plus formelle du langage, nous acceptons toutes les bonnes volonté s (ou bien inventez une machine pour nous cloner
☺).
S’agissant du manuel de ré fé rence d’un langage, il est dangereux de rentrer profondé ment dans les dé tails d’implé -
mentation ; l’implé mentation peut changer et d’autres implé mentations du mê me langage peuvent fonctionner dif-
fé remment. En mê me temps, CPython est l’implé mentation de Python la plus ré pandue (bien que d’autres implé -
mentations gagnent en popularité ) et certaines de ses bizarreries mé ritent parfois d’ê tre mentionné es, en particulier
lorsque l’implé mentation impose des limitations supplé mentaires. Par consé quent, vous trouvez de courtes ”notes
d’implé mentation” saupoudré es dans le texte.
Chaque implé mentation de Python est livré e avec un certain nombre de modules natifs. Ceux-ci sont documenté s dans
library-index. Quelques modules natifs sont mentionné s quand ils interagissent significativement avec la dé finition du
langage.

1.1 Autres implémentations

Bien qu’il existe une implé mentation Python qui soit de loin la plus populaire, il existe d’autres implé mentations qui
pré sentent un inté rê t particulier pour diffé rents publics.
Parmi les implé mentations les plus connues, nous pouvons citer :
CPython
C’est l’implé mentation originelle et la plus entretenue de Python, é crite en C. Elle implé mente gé né ralement
en premier les nouvelles fonctionnalité s du langage.
Jython
Python implemented in Java. This implementation can be used as a scripting language for Java applications,
or can be used to create applications using the Java class libraries. It is also often used to create tests for Java
libraries. More information can be found at the Jython website.

3
The Python Language Reference, Version 3.13.7

Python pour .NET

Cette implé mentation utilise en fait l’implé mentation CPython, mais c’est une application .NET et permet un
accè s aux bibliothè ques .NET. Elle a é té cré ée par Brian Lloyd. Pour plus d’informations, consultez la page
d’accueil Python pour .NET (site en anglais).
IronPython
An alternate Python for .NET. Unlike [Link], this is a complete Python implementation that generates
IL, and compiles Python code directly to .NET assemblies. It was created by Jim Hugunin, the original creator
of Jython. For more information, see the IronPython website.
PyPy
An implementation of Python written completely in Python. It supports several advanced features not found
in other implementations like stackless support and a Just in Time compiler. One of the goals of the project
is to encourage experimentation with the language itself by making it easier to modify the interpreter (since
it is written in Python). Additional information is available on the PyPy project’s home page.
Chacune de ces implé mentations diffè re d’une maniè re ou d’une autre par rapport au langage dé crit dans ce manuel, ou
comporte des spé cificité s que la documentation standard de Python ne couvre pas. Reportez-vous à la documentation
spé cifique à l’implé mentation pour dé terminer ce que vous devez savoir sur l’implé mentation que vous utilisez.

1.2 Notations
The descriptions of lexical analysis and syntax use a modified Backus–Naur form (BNF) grammar notation. This
uses the following style of definition :

name ::= lc_letter (lc_letter | "_")*

lc_letter ::= "a"..."z"

La premiè re ligne indique qu’un name est un lc_letter suivi d’une suite de zé ro ou plus lc_letters ou tiret bas.
Un lc_letter est, à son tour, l’un des caractè res 'a' à 'z' (cette rè gle est effectivement respecté e pour les noms
dé finis dans les rè gles lexicales et grammaticales de ce document).
Chaque rè gle commence par un nom (qui est le nom que la rè gle dé finit) et ::=. Une barre verticale (|) est utilisé e
pour sé parer les alternatives ; c’est l’opé rateur le moins prioritaire de cette notation. Une é toile (*) signifie zé ro ou
plusieurs ré pé titions de l’é lé ment pré cé dent ; de mê me, un plus (+) signifie une ou plusieurs ré pé titions, et une expres-
sion entre crochets ([ ]) signifie zé ro ou une occurrence (en d’autres termes, l’expression encadré e est facultative).
Les opé rateurs * et + agissent aussi é troitement que possible ; les parenthè ses sont utilisé es pour le regroupement.
Les chaînes litté rales sont entouré es de guillemets anglais ". L’espace n’est utilisé e que pour sé parer les lexè mes.
Les rè gles sont normalement contenues sur une seule ligne ; les rè gles avec de nombreuses alternatives peuvent ê tre
formaté es avec chaque ligne repré sentant une alternative (et donc dé butant par une barre verticale, sauf la premiè re).
Dans les dé finitions lexicales (comme dans l’exemple ci-dessus), deux autres conventions sont utilisé es : deux ca-
ractè res litté raux sé paré s par des points de suspension signifient le choix d’un seul caractè re dans la plage donné e
(en incluant les bornes) de caractè res ASCII. Une phrase entre les signes infé rieur et supé rieur (<...>) donne une
description informelle du symbole dé fini ; par exemple, pour dé crire la notion de ”caractè re de contrô le” si né cessaire.
Mê me si la notation utilisé e est presque la mê me, il existe une grande diffé rence entre la signification des dé finitions
lexicales et syntaxiques : une dé finition lexicale opè re sur les caractè res individuels de l’entré e, tandis qu’une dé finition
syntaxique opè re sur le flux de lexè mes gé né ré s par l’analyse lexicale. Toutes les notations sous la forme BNF dans
le chapitre suivant (« Analyse lexicale ») sont des dé finitions lexicales ; les notations dans les chapitres suivants sont
des dé finitions syntaxiques.

4 Chapitre 1. Introduction
 CHAPITRE 2

Analyse lexicale

A Python program is read by a parser. Input to the parser is a stream of tokens, generated by the lexical analyzer (also
known as the tokenizer). This chapter describes how the lexical analyzer breaks a file into tokens.
Python lit le texte du programme comme des suites de caractè res Unicode ; l’encodage du fichier source peut ê tre
spé cifié par une dé claration d’encodage et vaut par dé faut UTF-8, voir la PEP 3120 pour les dé tails. Si le fichier
source ne peut pas ê tre dé codé , une exception SyntaxError (erreur de syntaxe) est levé e.

2.1 Structure des lignes

Un programme en Python est divisé en lignes logiques.

2.1.1 Lignes logiques

La fin d’une ligne logique est repré senté e par le lexè me NEWLINE. Les instructions ne peuvent pas traverser les
limites des lignes logiques, sauf quand NEWLINE est autorisé par la syntaxe (par exemple, entre les instructions des
instructions composé es). Une ligne logique est constitué e d’une ou plusieurs lignes physiques en fonction des rè gles,
explicites ou implicites, de continuation de ligne.

2.1.2 Lignes physiques

Une ligne physique est une suite de caractè res terminé e par une sé quence de fin de ligne. Dans les fichiers sources et
les chaînes de caractè res, n’importe quelle sé quence de fin de ligne des plateformes standards peut ê tre utilisé e ; Unix
utilise le caractè re ASCII LF (pour linefeed, saut de ligne en français), Windows utilise la sé quence CR LF (carriage
return suivi de linefeed) et Macintosh utilisait le caractè re ASCII CR. Toutes ces sé quences peuvent ê tre utilisé es,
quelle que soit la plateforme. La fin de l’entré e est aussi une fin de ligne physique implicite.
Lorsque vous encapsulez Python, les chaînes de code source doivent ê tre passé es à l’API Python en utilisant les
conventions du C standard pour les caractè res de fin de ligne : le caractè re \n, dont le code ASCII est LF.

2.1.3 Commentaires
Un commentaire commence par le caractè re croisillon (#, hash en anglais et qui ressemble au symbole musical diè se,
c’est pourquoi il est souvent improprement appelé caractè re diè se) situé en dehors d’une chaine de caractè res litté rale
et se termine à la fin de la ligne physique. Un commentaire signifie la fin de la ligne logique à moins qu’une rè gle de
continuation de ligne implicite ne s’applique. Les commentaires sont ignoré s au niveau syntaxique, ce ne sont pas des
lexè mes.

5
The Python Language Reference, Version 3.13.7

2.1.4 Déclaration d’encodage

Si un commentaire placé sur la premiè re ou deuxiè me ligne du script Python correspond à l’expression rationnelle
coding[=:]\s*([-\w.]+), ce commentaire est analysé comme une dé claration d’encodage ; le premier groupe
de cette expression dé signe l’encodage du fichier source. Cette dé claration d’encodage doit ê tre seule sur sa ligne et,
si elle est sur la deuxiè me ligne, la premiè re ligne doit aussi ê tre une ligne composé e uniquement d’un commentaire.
Les formes recommandé es pour l’expression de l’encodage sont

# -*- coding: <encoding-name> -*-

qui est reconnue aussi par GNU Emacs et

# vim:fileencoding=<encoding-name>

qui est reconnue par VIM de Bram Moolenaar.

If no encoding declaration is found, the default encoding is UTF-8. If the implicit or explicit encoding of a file is
UTF-8, an initial UTF-8 byte-order mark (b'\xef\xbb\xbf') is ignored rather than being a syntax error.
Si un encodage est dé claré , le nom de l’encodage doit ê tre reconnu par Python (voir standard-encodings). L’encodage
est utilisé pour toute l’analyse lexicale, y compris les chaînes de caractè res, les commentaires et les identifiants.

2.1.5 Continuation de ligne explicite

Deux lignes physiques, ou plus, peuvent ê tre jointes pour former une seule ligne logique en utilisant la barre oblique
inversé e (\) selon la rè gle suivante : quand la ligne physique se termine par une barre oblique inversé e qui ne fait pas
partie d’une chaine de caractè res ou d’un commentaire, la ligne immé diatement suivante lui est adjointe pour former
une seule ligne logique, en supprimant la barre oblique inversé e et le caractè re de fin de ligne. Par exemple :

if 1900 < year < 2100 and 1 <= month <= 12 \

and 1 <= day <= 31 and 0 <= hour < 24 \
and 0 <= minute < 60 and 0 <= second < 60: # Looks like a valid date
return 1

Une ligne que se termine par une barre oblique inversé e ne peut pas avoir de commentaire. La barre oblique inversé e
ne permet pas de continuer un commentaire. La barre oblique inversé e ne permet pas de continuer un lexè me, sauf
s’il s’agit d’une chaîne de caractè res (par exemple, les lexè mes autres que les chaînes de caractè res ne peuvent pas
ê tre ré partis sur plusieurs lignes en utilisant une barre oblique inversé e). La barre oblique inversé e n’est pas autorisé e
ailleurs sur la ligne, en dehors d’une chaîne de caractè res.

2.1.6 Continuation de ligne implicite

Les expressions entre parenthè ses, crochets ou accolades peuvent ê tre ré parties sur plusieurs lignes sans utiliser de
barre oblique inversé e. Par exemple :

month_names = ['Januari', 'Februari', 'Maart', # These are the

'April', 'Mei', 'Juni', # Dutch names
'Juli', 'Augustus', 'September', # for the months
'Oktober', 'November', 'December'] # of the year

Les lignes continué es implicitement peuvent avoir des commentaires. L’indentation des lignes de continuation n’est pas
importante. Une ligne blanche est autorisé e comme ligne de continuation. Il ne doit pas y avoir de lexè me NEWLINE
entre des lignes implicitement continué es. Les lignes continué es implicitement peuvent ê tre utilisé es dans des chaînes
entre triples guillemets (voir ci-dessous) ; dans ce cas, elles ne peuvent pas avoir de commentaires.

2.1.7 Lignes vierges

Une ligne logique qui ne contient que des espaces, tabulations, caractè res de saut de page (formfeed en anglais)
ou commentaires est ignoré e (c’est-à -dire que le lexè me NEWLINE n’est pas produit). Pendant l’é dition interactive
d’instructions, la gestion des lignes vierges peut diffé rer en fonction de l’implé mentation de la boucle REPL. Dans

6 Chapitre 2. Analyse lexicale

 The Python Language Reference, Version 3.13.7

l’interpré teur standard, une ligne complè tement vierge (c’est-à -dire ne contenant strictement rien, mê me pas une
espace ou un commentaire) termine une instruction multi-lignes.

2.1.8 Indentation
Des espaces ou tabulations au dé but d’une ligne logique sont utilisé es pour connaître le niveau d’indentation de la
ligne, qui est ensuite utilisé pour dé terminer comment les instructions sont groupé es.
Les tabulations sont remplacé es (de la gauche vers la droite) par une à huit espaces de maniè re à ce que le nombre
de caractè res remplacé s soit un multiple de huit (nous avons ainsi la mê me rè gle que celle d’Unix). Le nombre total
d’espaces pré cé dant le premier caractè re non blanc dé termine alors le niveau d’indentation de la ligne. L’indentation
ne peut pas ê tre ré partie sur plusieurs lignes physiques à l’aide de barres obliques inversé es ; les espaces jusqu’à la
premiè re barre oblique inversé e dé terminent l’indentation.
L’indentation est dé claré e inconsistante et rejeté e si, dans un mê me fichier source, le mé lange des tabulations et
des espaces est tel que la signification dé pend du nombre d’espaces que repré sente une tabulation. Une exception
TabError est levé e dans ce cas.
Note de compatibilité entre les plateformes : en raison de la nature des é diteurs de texte sur les plateformes non
Unix, il n’est pas judicieux d’utiliser un mé lange d’espaces et de tabulations pour l’indentation dans un seul fichier
source. Il convient é galement de noter que des plateformes peuvent explicitement limiter le niveau d’indentation
maximal.
Un caractè re de saut de page peut ê tre pré sent au dé but de la ligne ; il est ignoré pour les calculs d’indentation ci-
dessus. Les caractè res de saut de page se trouvant ailleurs avec les espaces en tê te de ligne ont un effet indé fini (par
exemple, ils peuvent remettre à zé ro le nombre d’espaces).
Les niveaux d’indentation de lignes consé cutives sont utilisé s pour gé né rer les lexè mes INDENT et DEDENT, en
utilisant une pile, de cette façon :
Avant que la premiè re ligne du fichier ne soit lue, un « zé ro » est posé sur la pile ; il ne sera plus jamais enlevé . Les
nombres empilé s sont toujours strictement croissants de bas en haut. Au dé but de chaque ligne logique, le niveau
d’indentation de la ligne est comparé au sommet de la pile. S’ils sont é gaux, il ne se passe rien. S’il est plus grand, il
est empilé et un lexè me INDENT est produit. S’il est plus petit, il doit ê tre l’un des nombres pré sents dans la pile ;
tous les nombres de la pile qui sont plus grands sont retiré s et, pour chaque nombre retiré , un lexè me DEDENT est
produit. À la fin du fichier, un lexè me DEDENT est produit pour chaque nombre supé rieur à zé ro restant sur la pile.
Voici un exemple de code Python correctement indenté (bien que trè s confus) :

def perm(l):
# Compute the list of all permutations of l
if len(l) <= 1:
return [l]
r = []
for i in range(len(l)):
s = l[:i] + l[i+1:]
p = perm(s)
for x in p:
[Link](l[i:i+1] + x)
return r

L’exemple suivant montre plusieurs erreurs d’indentation :

def perm(l): # error: first line indented

for i in range(len(l)): # error: not indented
s = l[:i] + l[i+1:]
p = perm(l[:i] + l[i+1:]) # error: unexpected indent
for x in p:
[Link](l[i:i+1] + x)
return r # error: inconsistent dedent

2.1. Structure des lignes 7

The Python Language Reference, Version 3.13.7

En fait, les trois premiè res erreurs sont dé tecté es par l’analyseur syntaxique ; seule la derniè re erreur est trouvé e par
l’analyseur lexical (l’indentation de return r ne correspond à aucun niveau dans la pile).

2.1.9 Espaces entre lexèmes

Sauf au dé but d’une ligne logique ou dans les chaînes de caractè res, les caractè res « blancs » espace, tabulation et saut
de page peuvent ê tre utilisé s de maniè re interchangeable pour sé parer les lexè mes. Un blanc n’est né cessaire entre
deux lexè mes que si leur concaté nation pourrait ê tre interpré té e comme un lexè me diffé rent (par exemple, ab est un
lexè me, mais a b comporte deux lexè mes).

2.2 Autres lexèmes

Outre NEWLINE, INDENT et DEDENT, il existe les caté gories de lexè mes suivantes : identifiants, mots clés, litté-
raux, opérateurs et délimiteurs. Les blancs (autres que les fins de lignes, vus auparavant) ne sont pas des lexè mes mais
servent à dé limiter les lexè mes. Quand une ambiguïté existe, le lexè me correspond à la plus grande chaîne possible
qui forme un lexè me licite, en lisant de la gauche vers la droite.

2.3 Identifiants et mots-clés

Les identifiants (aussi appelé s noms) sont dé crits par les dé finitions lexicales suivantes.
La syntaxe des identifiants en Python est basé e sur l’annexe UAX-31 du standard Unicode avec les modifications
dé finies ci-dessous ; consultez la PEP 3131 pour plus de dé tails.
Within the ASCII range (U+0001..U+007F), the valid characters for identifiers include the uppercase and lowercase
letters A through Z, the underscore _ and, except for the first character, the digits 0 through 9. Python 3.0 introduced
additional characters from outside the ASCII range (see PEP 3131). For these characters, the classification uses the
version of the Unicode Character Database as included in the unicodedata module.
Les identifiants n’ont pas de limite de longueur. La casse est prise en compte.

identifier ::= xid_start xid_continue*

id_start ::= <all characters in general categories Lu, Ll, Lt, Lm, Lo, Nl, the underscore, a
id_continue ::= <all characters in id_start, plus characters in the categories Mn, Mc, Nd, Pc a
xid_start ::= <all characters in id_start whose NFKC normalization is in "id_start xid_contin
xid_continue ::= <all characters in id_continue whose NFKC normalization is in "id_continue*">
Les codes de caté gories Unicode cité s ci-dessus signifient :
— Lu — lettres majuscules
— Ll — lettres minuscules
— Lt — lettres majuscules particuliè res (caté gorie titlecase de l’Unicode)
— Lm — lettres modificatives avec chasse
— Lo — autres lettres
— Nl — nombres lettres (par exemple, les nombres romains)
— Mn — symboles que l’on combine avec d’autres (accents ou autres) sans gé né rer d’espace (nonspacing marks
en anglais)
— Mc — symboles que l’on combine avec d’autres en gé né rant une espace (spacing combining marks en anglais)
— Nd — chiffres (arabes et autres)
— Pc — connecteurs (tirets et autres lignes)
— Other_ID_Start - explicit list of characters in [Link] to support backwards compatibility
— Other_ID_Continue — pareillement
Tous les identifiants sont convertis dans la forme normale NFKC pendant l’analyse syntaxique : la comparaison des
identifiants se base sur leur forme NFKC.
A non-normative HTML file listing all valid identifier characters for Unicode 15.1.0 can be found at [Link]
[Link]/Public/15.1.0/ucd/[Link]

8 Chapitre 2. Analyse lexicale

 The Python Language Reference, Version 3.13.7

2.3.1 Mots-clés
Les identifiants suivants sont des mots ré servé s par le langage et ne peuvent pas ê tre utilisé s en tant qu’identifiants
normaux. Ils doivent ê tre é crits exactement comme ci-dessous :

False await else import pass

None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield

2.3.2 Mots-clés ad hoc

Ajouté dans la version 3.10.
Some identifiers are only reserved under specific contexts. These are known as soft keywords. The identifiers match,
case, type and _ can syntactically act as keywords in certain contexts, but this distinction is done at the parser level,
not when tokenizing.
As soft keywords, their use in the grammar is possible while still preserving compatibility with existing code that
uses these names as identifier names.
match, case, and _ are used in the match statement. type is used in the type statement.
Modifié dans la version 3.12 : type is now a soft keyword.

2.3.3 Classes réservées pour les identifiants

Certaines classes d’identifiants (outre les mots-clé s) ont une signification particuliè re. Ces classes se reconnaissent
par des caractè res de soulignement en tê te et en queue d’identifiant :
_*
N’est pas importé par from module import *.
_
Dans un motif case d’une instruction match, _ est un mot-clé ad hoc qui dé crit un motif attrape-tout.
De son cô té , l’interpré teur interactif place le ré sultat de la derniè re é valuation dans la variable - (son empla-
cement se situe dans le module builtins, avec les fonctions natives telles que print).
Ailleurs, _ est un identifiant comme un autre. Il est souvent utilisé pour dé signer des é lé ments « spé ciaux »,
mais il n’est pas spé cial pour Python en tant que tel.

® Note

Le nom _ est souvent utilisé pour internationaliser l’affichage ; reportez-vous à la documentation du module
gettext pour plus d’informations sur cette convention.

Il est aussi communé ment utilisé pour signifier que la variable n’est pas utilisé e.

__*__
Noms dé finis par le systè me, appelé s noms « dunder » (pour Double Underscores) de maniè re informelle. Ces
noms sont dé finis par l’interpré teur et son implé mentation (y compris la bibliothè que standard). Les noms
actuels dé finis par le systè me sont abordé s dans la section Méthodes spéciales, mais aussi ailleurs. D’autres
noms seront probablement dé finis dans les futures versions de Python. Toute utilisation de noms de la forme
__*__, dans n’importe quel contexte, qui n’est pas conforme à ce qu’indique explicitement la documentation,
est sujette à des mauvaises surprises sans avertissement.
__*
Noms privé s pour une classe. Les noms de cette forme, lorsqu’ils sont utilisé s dans le contexte d’une dé finition
de classe, sont ré écrits sous une forme modifié e pour é viter les conflits de noms entre les attributs « privé s »
des classes de base et les classes dé rivé es. Voir la section Identifiants (noms).

2.3. Identifiants et mots-clés 9

The Python Language Reference, Version 3.13.7

2.4 Littéraux
Les litté raux sont des notations pour indiquer des valeurs constantes de certains types natifs.

2.4.1 Littéraux de chaînes de caractères et de suites d’octets

Les chaînes de caractè res litté rales sont dé finies par les dé finitions lexicales suivantes :

stringliteral ::= [stringprefix](shortstring | longstring)

stringprefix ::= "r" | "u" | "R" | "U" | "f" | "F"
| "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF"
shortstring ::= "'" shortstringitem* "'" | '"' shortstringitem* '"'
longstring ::= "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
shortstringitem ::= shortstringchar | stringescapeseq
longstringitem ::= longstringchar | stringescapeseq
shortstringchar ::= <any source character except "\" or newline or the quote>
longstringchar ::= <any source character except "\">
stringescapeseq ::= "\" <any source character>

bytesliteral ::= bytesprefix(shortbytes | longbytes)

bytesprefix ::= "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"
shortbytes ::= "'" shortbytesitem* "'" | '"' shortbytesitem* '"'
longbytes ::= "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""'
shortbytesitem ::= shortbyteschar | bytesescapeseq
longbytesitem ::= longbyteschar | bytesescapeseq
shortbyteschar ::= <any ASCII character except "\" or newline or the quote>
longbyteschar ::= <any ASCII character except "\">
bytesescapeseq ::= "\" <any ASCII character>

Une restriction syntaxique non indiqué e par ces rè gles est qu’aucun blanc n’est autorisé entre le stringprefix ou
bytesprefix et le reste du litté ral. Le jeu de caractè res source est dé fini par la dé claration d’encodage ; il vaut
UTF-8 si aucune dé claration d’encodage n’est donné e dans le fichier source ; voir la section Déclaration d’encodage.
In plain English : Both types of literals can be enclosed in matching single quotes (') or double quotes ("). They can
also be enclosed in matching groups of three single or double quotes (these are generally referred to as triple-quoted
strings). The backslash (\) character is used to give special meaning to otherwise ordinary characters like n, which
means ’newline’ when escaped (\n). It can also be used to escape characters that otherwise have a special meaning,
such as newline, backslash itself, or the quote character. See escape sequences below for examples.
Les litté raux de suites d’octets sont toujours pré fixé s par 'b' ou 'B' ; cela cré e une instance de type bytes au lieu
du type str. Ils ne peuvent contenir que des caractè res ASCII ; les octets dont la valeur est supé rieure ou é gale à 128
doivent ê tre exprimé s à l’aide d’é chappements.
Both string and bytes literals may optionally be prefixed with a letter 'r' or 'R' ; such constructs are called raw
string literals and raw bytes literals respectively and treat backslashes as literal characters. As a result, in raw string
literals, '\U' and '\u' escapes are not treated specially.
Ajouté dans la version 3.3 : le pré fixe 'rb' a é té ajouté comme synonyme de 'br' pour les litté raux de suites d’octets.
la gestion du pré fixe historique pour les chaînes Unicode (u'chaine') a é té ré introduite afin de simplifier la main-
tenance de code compatible Python 2.x et 3.x. Voir la PEP 414 pour davantage d’informations.
Une chaîne litté rale qui contient 'f' ou 'F' dans le pré fixe est une chaîne de caractères littérale formatée ; lisez
f-strings. Le 'f' peut ê tre combiné avec 'r' mais pas avec 'b' ou 'u', donc les chaînes de caractè res formaté es
sont possibles mais les litté raux de suites d’octets ne peuvent pas l’ê tre.
Dans les chaînes entre triples guillemets, les sauts de ligne et guillemets peuvent ne pas ê tre é chappé s (et sont donc
pris en compte), mais trois guillemets non é chappé s à la suite terminent le litté ral (on entend par guillemet le caractè re
utilisé pour commencer le litté ral, c’est-à -dire ' ou ").

10 Chapitre 2. Analyse lexicale

 The Python Language Reference, Version 3.13.7

Escape sequences

À moins que le pré fixe 'r' ou 'R' ne soit pré sent, les sé quences d’é chappement dans les litté raux de chaînes et suites
d’octets sont interpré té es comme elles le seraient par le C Standard. Les sé quences d’é chappement reconnues sont :

Séquence d’échappement Signification Notes

\<newline> barre oblique inversé e et retour à la ligne ignoré s (1)
\\ barre oblique inversé e (\)
\' guillemet simple (')
\" guillemet double (")
\a cloche ASCII (BEL)
\b retour arriè re ASCII (BS)
\f saut de page ASCII (FF)
\n saut de ligne ASCII (LF)
\r retour à la ligne ASCII (CR)
\t tabulation horizontale ASCII (TAB)
\v tabulation verticale ASCII (VT)
\ooo caractè re dont le code est ooo en octal (2,4)
\xhh caractè re dont le code est ooo en hexadé cimal (3,4)

Les sé quences d’é chappement reconnues seulement dans les chaînes litté rales sont :

Séquence d’échappement Signification Notes

\N{name} caractè re dont le nom est name dans la base de donné es Unicode (5)
\uxxxx caractè re dont le code est xxxx en hexadé cimal (6)
\Uxxxxxxxx caractè re dont le code est xxxxxxxx en hexadé cimal sur 32 bits (7)

Notes :
(1) A backslash can be added at the end of a line to ignore the newline :

>>> 'This string will not include \

... backslashes or newline characters.'
'This string will not include backslashes or newline characters.'

The same result can be achieved using triple-quoted strings, or parentheses and string literal concatenation.
(2) Comme dans le C Standard, jusqu’à trois chiffres en base huit sont accepté s.
Modifié dans la version 3.11 : Octal escapes with value larger than 0o377 produce a DeprecationWarning.
Modifié dans la version 3.12 : Octal escapes with value larger than 0o377 produce a SyntaxWarning. In a
future Python version they will be eventually a SyntaxError.
(3) Contrairement au C Standard, il est obligatoire de fournir deux chiffres hexadé cimaux.
(4) Dans un litté ral de suite d’octets, un é chappement hexadé cimal ou octal est un octet dont la valeur est donné e.
Dans une chaîne litté rale, un é chappement est un caractè re Unicode dont le code est donné .
(5) Modifié dans la version 3.3 : Ajout du support pour les alias de noms 1 .
(6) Exactement quatre chiffres hexadé cimaux sont requis.
(7) N’importe quel caractè re Unicode peut ê tre encodé de cette façon. Exactement huit chiffres hexadé cimaux
sont requis.
Contrairement au C standard, toutes les sé quences d’é chappement non reconnues sont laissé es inchangé es dans la
chaîne, c’est-à -dire que la barre oblique inversée est laissée dans le résultat (ce comportement est utile en cas de
dé bogage : si une sé quence d’é chappement est mal tapé e, la sortie ré sultante est plus facilement reconnue comme
source de l’erreur). Notez bien é galement que les sé quences d’é chappement reconnues uniquement dans les litté raux
de chaînes de caractè res ne sont pas reconnues pour les litté raux de suites d’octets.
Modifié dans la version 3.6 : Unrecognized escape sequences produce a DeprecationWarning.
1. [Link]

2.4. Littéraux 11
The Python Language Reference, Version 3.13.7

Modifié dans la version 3.12 : Unrecognized escape sequences produce a SyntaxWarning. In a future Python version
they will be eventually a SyntaxError.
Mê me dans une chaîne litté rale brute, les guillemets peuvent ê tre é chappé s avec une barre oblique inversé e mais la
barre oblique inversé e reste dans le ré sultat ; par exemple, r"\"" est une chaîne de caractè res valide composé e de
deux caractè res : une barre oblique inversé e et un guillemet double ; r"\" n’est pas une chaîne de caractè res valide
(mê me une chaîne de caractè res brute ne peut pas se terminer par un nombre impair de barres obliques inversé es).
Plus pré cisé ment, une chaîne littérale brute ne peut pas se terminer par une seule barre oblique inversée (puisque la
barre oblique inversé e é chappe le guillemet suivant). Notez é galement qu’une simple barre oblique inversé e suivie
d’un saut de ligne est interpré té e comme deux caractè res faisant partie du litté ral et non comme une continuation de
ligne.

2.4.2 Concaténation de chaînes de caractères

Plusieurs chaînes de caractè res ou suites d’octets adjacentes (sé paré es par des blancs), utilisant é ventuellement des
conventions de guillemets diffé rentes, sont autorisé es. La signification est la mê me que leur concaté nation. Ainsi,
"hello" 'world' est l’é quivalent de "helloworld". Cette fonctionnalité peut ê tre utilisé e pour ré duire le nombre
de barres obliques inverses, pour diviser de longues chaînes de caractè res sur plusieurs lignes ou mê me pour ajouter
des commentaires à des portions de chaînes de caractè res. Par exemple :

[Link]("[A-Za-z_]" # letter or underscore

"[A-Za-z0-9_]*" # letter, digit or underscore
)

Notez que cette fonctionnalité agit au niveau syntaxique mais est implé menté e au moment de la compilation. Pour
concaté ner les expressions des chaînes de caractè res au moment de l’exé cution, vous devez utiliser l’opé rateur +.
Notez é galement que la concaté nation litté rale peut utiliser un style diffé rent de guillemets pour chaque composant
(et mê me mé langer des chaînes de caractè res brutes et des chaînes de caractè res entre triples guillemets). Enfin, les
chaînes de caractè res formaté es peuvent ê tre concaté né es avec des chaînes de caractè res ordinaires.

2.4.3 f-strings
Ajouté dans la version 3.6.
Une chaine de caractères littérale formatée ou f-string est une chaine de caractè res litté rale pré fixé e par 'f' ou 'F'.
Ces chaines peuvent contenir des champs à remplacer, c’est-à -dire des expressions dé limité es par des accolades {}.
Alors que les autres litté raux de chaines ont des valeurs constantes, les chaines formaté es sont de vraies expressions
é valué es à l’exé cution.
Les sé quences d’é chappement sont dé codé es comme à l’inté rieur des chaînes de caractè res ordinaires (sauf lorsqu’une
chaîne de caractè res est é galement marqué e comme une chaîne brute). Aprè s dé codage, la grammaire s’appliquant
au contenu de la chaîne de caractè res est :

f_string ::= (literal_char | "{{" | "}}" | replacement_field)*

replacement_field ::= "{" f_expression ["="] ["!" conversion] [":" format_spec] "}"
f_expression ::= (conditional_expression | "*" or_expr)
("," conditional_expression | "," "*" or_expr)* [","]
| yield_expression
conversion ::= "s" | "r" | "a"
format_spec ::= (literal_char | replacement_field)*
literal_char ::= <any code point except "{", "}" or NULL>

Les portions qui sont en dehors des accolades sont traité es comme les litté raux, sauf les doubles accolades '{{'
ou '}}' qui sont remplacé es par la simple accolade correspondante. Une simple accolade ouvrante '{' marque le
dé but du champ à remplacer, qui commence par une expression Python. Pour afficher à la fois le texte de l’expression
et sa valeur une fois é valué e (utile lors du dé bogage), un signe é gal '=' peut ê tre ajouté aprè s l’expression. Ensuite,
il peut y avoir un champ de conversion, introduit par un point d’exclamation '!'. Une spé cification de format peut
aussi ê tre rajouté e, introduite par le caractè re deux-points ':'. Le champ à remplacer se termine par une accolade
fermante '}'.

12 Chapitre 2. Analyse lexicale

 The Python Language Reference, Version 3.13.7

Expressions in formatted string literals are treated like regular Python expressions surrounded by parentheses, with
a few exceptions. An empty expression is not allowed, and both lambda and assignment expressions := must be
surrounded by explicit parentheses. Each expression is evaluated in the context where the formatted string literal
appears, in order from left to right. Replacement expressions can contain newlines in both single-quoted and triple-
quoted f-strings and they can contain comments. Everything that comes after a # inside a replacement field is a
comment (even closing braces and quotes). In that case, replacement fields must be closed in a different line.

>>> f"abc{a # This is a comment }"

... + 3}"
'abc5'

Modifié dans la version 3.7 : Avant Python 3.7, il é tait illé gal d’utiliser await ainsi que les compré hensions utilisant
async for dans les expressions au sein des chaînes de caractè res formaté es litté rales à cause d’un problè me dans
l’implé mentation.
Modifié dans la version 3.12 : Prior to Python 3.12, comments were not allowed inside f-string replacement fields.
Lorsqu’un signe é gal '=' est pré sent, la sortie comprend le texte de l’expression, le signe '=' et la valeur calculé e.
Les espaces aprè s l’accolade ouvrante '{', dans l’expression et aprè s le signe '=' sont conservé es à l’affichage. Par
dé faut, le signe '=' utilise la repr() de l’expression, sauf si un format est indiqué . Quand le format est indiqué , c’est
str() de l’expression qui est utilisé e à moins qu’une conversion !r ne soit dé claré e.

Ajouté dans la version 3.8 : le signe é gal '='.

Si une conversion est spé cifié e, le ré sultat de l’é valuation de l’expression est converti avant d’ê tre formaté . La conver-
sion '!s' appelle str() sur le ré sultat, '!r' appelle repr() et '!a' appelle ascii().
The result is then formatted using the format() protocol. The format specifier is passed to the __format__()
method of the expression or conversion result. An empty string is passed when the format specifier is omitted. The
formatted result is then included in the final value of the whole string.
Top-level format specifiers may include nested replacement fields. These nested fields may include their own conver-
sion fields and format specifiers, but may not include more deeply nested replacement fields. The format specifier
mini-language is the same as that used by the [Link]() method.
Les chaînes formaté es litté rales peuvent ê tre concaté né es mais les champs à remplacer ne peuvent pas ê tre divisé s
entre les litté raux.
Quelques exemples de chaines formaté es litté rales :
>>> name = "Fred"
>>> f"He said his name is {name!r}."
"He said his name is 'Fred'."
>>> f"He said his name is {repr(name)}." # repr() is equivalent to !r
"He said his name is 'Fred'."
>>> width = 10
>>> precision = 4
>>> value = [Link]("12.34567")
>>> f"result: {value:{width}.{precision}}" # nested fields
'result: 12.35'
>>> today = datetime(year=2017, month=1, day=27)
>>> f"{today:%B %d, %Y}" # using date format specifier
'January 27, 2017'
>>> f"{today=:%B %d, %Y}" # using date format specifier and debugging
'today=January 27, 2017'
>>> number = 1024
>>> f"{number:#0x}" # using integer format specifier
'0x400'
>>> foo = "bar"
>>> f"{ foo = }" # preserves whitespace
" foo = 'bar'"
>>> line = "The mill's closed"
(suite sur la page suivante)

2.4. Littéraux 13
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

>>> f"{line = }"
'line = "The mill\'s closed"'
>>> f"{line = :20}"
"line = The mill's closed "
>>> f"{line = !r:20}"
'line = "The mill\'s closed" '

Reusing the outer f-string quoting type inside a replacement field is permitted :

>>> a = dict(x=2)
>>> f"abc {a["x"]} def"
'abc 2 def'

Modifié dans la version 3.12 : Prior to Python 3.12, reuse of the same quoting type of the outer f-string inside a
replacement field was not possible.
Backslashes are also allowed in replacement fields and are evaluated the same way as in any other context :

>>> a = ["a", "b", "c"]

>>> print(f"List a contains:\n{"\n".join(a)}")
List a contains:
a
b
c

Modifié dans la version 3.12 : Prior to Python 3.12, backslashes were not permitted inside an f-string replacement
field.
Une chaine formaté e litté rale ne peut pas ê tre utilisé e en tant que docstring, mê me si elle ne comporte pas d’expression.

>>> def foo():

... f"Not a docstring"
...
>>> foo.__doc__ is None
True

Consultez aussi la PEP 498 qui propose l’ajout des chaines formaté es litté rales et [Link]() qui utilise un
mé canisme similaire pour formater les chaînes de caractè res.

2.4.4 Littéraux numériques

There are three types of numeric literals : integers, floating-point numbers, and imaginary numbers. There are no
complex literals (complex numbers can be formed by adding a real number and an imaginary number).
Notez que les litté raux numé riques ne comportent pas de signe ; une phrase telle que -1 est en fait une expression
composé e de l’opé rateur unitaire - et du litté ral 1.

2.4.5 Entiers littéraux

Les entiers litté raux sont dé crits par les dé finitions lexicales suivantes :

integer ::= decinteger | bininteger | octinteger | hexinteger

decinteger ::= nonzerodigit (["_"] digit)* | "0"+ (["_"] "0")*
bininteger ::= "0" ("b" | "B") (["_"] bindigit)+
octinteger ::= "0" ("o" | "O") (["_"] octdigit)+
hexinteger ::= "0" ("x" | "X") (["_"] hexdigit)+
nonzerodigit ::= "1"..."9"
digit ::= "0"..."9"
bindigit ::= "0" | "1"

14 Chapitre 2. Analyse lexicale

 The Python Language Reference, Version 3.13.7

octdigit ::= "0"..."7"

hexdigit ::= digit | "a"..."f" | "A"..."F"

Il n’y a pas de limite pour la longueur des entiers litté raux, sauf celle relative à la capacité mé moire.
Les tirets bas sont ignoré s pour dé terminer la valeur numé rique du litté ral. Ils peuvent ê tre utilisé s pour grouper les
chiffres afin de faciliter la lecture. Un souligné peut ê tre placé entre des chiffres ou aprè s la spé cification de la base
telle que 0x.
Notez que placer des zé ros en tê te de nombre pour un nombre dé cimal diffé rent de zé ro n’est pas autorisé . Cela
permet d’é viter l’ambigü ité avec les litté raux en base octale selon le style C que Python utilisait avant la version 3.0.
Quelques exemples d’entiers litté raux :

7 2147483647 0o177 0b100110111

3 79228162514264337593543950336 0o377 0xdeadbeef
100_000_000_000 0b_1110_0101

Modifié dans la version 3.6 : Les tirets bas ne sont pas autorisé s pour grouper les litté raux.

2.4.6 Floating-point literals

Floating-point literals are described by the following lexical definitions :

floatnumber ::= pointfloat | exponentfloat

pointfloat ::= [digitpart] fraction | digitpart "."
exponentfloat ::= (digitpart | pointfloat) exponent
digitpart ::= digit (["_"] digit)*
fraction ::= "." digitpart
exponent ::= ("e" | "E") ["+" | "-"] digitpart
Note that the integer and exponent parts are always interpreted using radix 10. For example, 077e010 is legal, and
denotes the same number as 77e10. The allowed range of floating-point literals is implementation-dependent. As in
integer literals, underscores are supported for digit grouping.
Some examples of floating-point literals :

3.14 10. .001 1e100 3.14e-10 0e0 3.14_15_93

Modifié dans la version 3.6 : Les tirets bas ne sont pas autorisé s pour grouper les litté raux.

2.4.7 Imaginaires littéraux

Les nombres imaginaires sont dé crits par les dé finitions lexicales suivantes :

imagnumber ::= (floatnumber | digitpart) ("j" | "J")

An imaginary literal yields a complex number with a real part of 0.0. Complex numbers are represented as a pair of
floating-point numbers and have the same restrictions on their range. To create a complex number with a nonzero
real part, add a floating-point number to it, e.g., (3+4j). Some examples of imaginary literals :

3.14j 10.j 10j .001j 1e100j 3.14e-10j 3.14_15_93j

2.5 Opérateurs
Les lexè mes suivants sont des opé rateurs :

+ - * ** / // % @
<< >> & | ^ ~ :=
< > <= >= == !=

2.5. Opérateurs 15
The Python Language Reference, Version 3.13.7

2.6 Délimiteurs
Les lexè mes suivants servent de dé limiteurs dans la grammaire :

( ) [ ] { }
, : ! . ; @ =
-> += -= *= /= //= %=
@= &= |= ^= >>= <<= **=

Le point peut aussi apparaître dans les litté raux de nombres à virgule flottante et imaginaires. Une suite de trois points
possè de une signification spé ciale : c’est une ellipse litté rale. La deuxiè me partie de la liste, les opé rateurs d’affectation
augmenté s, servent de dé limiteurs pour l’analyseur lexical mais sont aussi des opé rateurs.
Les caractè res ASCII suivants ont une signification spé ciale en tant que partie d’autres lexè mes ou ont une signification
particuliè re pour l’analyseur lexical :

' " # \

Les caractè res ASCII suivants ne sont pas utilisé s en Python. S’ils apparaissent en dehors de chaines litté rales ou de
commentaires, ils produisent une erreur :

$ ? `

Notes

16 Chapitre 2. Analyse lexicale

 CHAPITRE 3

Modèle de données

3.1 Objets, valeurs et types

En Python, les donné es sont repré senté es sous forme d’objets. Toutes les donné es d’un programme Python sont re-
pré senté es par des objets ou par des relations entre les objets (dans un certain sens, et en conformité avec le modè le
de Von Neumann d’« ordinateur à programme enregistré », le code est aussi repré senté par des objets).
Every object has an identity, a type and a value. An object’s identity never changes once it has been created ; you
may think of it as the object’s address in memory. The is operator compares the identity of two objects ; the id()
function returns an integer representing its identity.
en CPython, id(x) est l’adresse mé moire où est stocké x.
Le type de l’objet dé termine les opé rations que l’on peut appliquer à l’objet (par exemple, « a-t-il une longueur ? »)
et dé finit aussi les valeurs possibles pour les objets de ce type. La fonction type() renvoie le type de l’objet (qui est
lui-mê me un objet). Comme l’identifiant, le type d’un objet ne peut pas ê tre modifié 1 .
La valeur de certains objets peut changer. Les objets dont la valeur peut changer sont dits mutables ; les objets dont
la valeur est dé finitivement fixé e à leur cré ation sont dits immuables (immutable en anglais). La valeur d’un objet
conteneur immuable qui contient une ré fé rence vers un objet mutable peut varier lorsque la valeur de l’objet mutable
change ; cependant, le conteneur est quand mê me considé ré comme immuable parce que l’ensemble des objets qu’il
contient ne peut pas ê tre modifié . Ainsi, l’immuabilité n’est pas strictement é quivalente au fait d’avoir une valeur non
modifiable, c’est plus subtil. La muabilité d’un objet est dé finie par son type ; par exemple, les nombres, les chaînes
de caractè res et les n-uplets sont immuables alors que les dictionnaires et les listes sont mutables.
Un objet n’est jamais explicitement dé truit ; cependant, lorsqu’il ne peut plus ê tre atteint, il a vocation à ê tre supprimé
par le ramasse-miettes (garbage-collector en anglais). L’implé mentation peut retarder cette opé ration ou mê me ne pas
la faire du tout — la façon dont fonctionne le ramasse-miette est particuliè re à chaque implé mentation, l’important
é tant qu’il ne supprime pas d’objet qui peut encore ê tre atteint.
CPython utilise aujourd’hui un mé canisme de compteur de ré fé rences avec une dé tection, en temps diffé ré et option-
nelle, des cycles d’objets. Ce mé canisme supprime la plupart des objets dè s qu’ils ne sont plus accessibles mais il ne
garantit pas la suppression des objets où il existe des ré fé rences circulaires. Consultez la documentation du module
gc pour tout ce qui concerne la suppression des cycles. D’autres implé mentations agissent diffé remment et CPython
pourrait é voluer. Ne vous reposez pas sur la finalisation immé diate des objets devenus inaccessibles (ainsi, vous devez
toujours fermer les fichiers explicitement).
1. Il est possible, dans certains cas, de changer le type d’un objet, sous certaines conditions. Cependant, ce n’est gé né ralement pas une bonne
idé e car cela peut conduire à un comportement trè s é trange si ce n’est pas gé ré correctement.

17
The Python Language Reference, Version 3.13.7

Note that the use of the implementation’s tracing or debugging facilities may keep objects alive that would normally
be collectable. Also note that catching an exception with a try ...except statement may keep objects alive.
Some objects contain references to ”external” resources such as open files or windows. It is understood that these
resources are freed when the object is garbage-collected, but since garbage collection is not guaranteed to happen,
such objects also provide an explicit way to release the external resource, usually a close() method. Programs
are strongly recommended to explicitly close such objects. The try ...finally statement and the with statement
provide convenient ways to do this.
Certains objets contiennent des ré fé rences à d’autres objets ; on les appelle conteneurs. Comme exemples de conte-
neurs, nous pouvons citer les n-uplets, les listes et les dictionnaires. Les ré fé rences sont parties inté grantes de la valeur
d’un conteneur. Dans la plupart des cas, lorsque nous parlons de la valeur d’un conteneur, nous parlons des valeurs,
pas des identifiants des objets contenus ; cependant, lorsque nous parlons de la muabilité d’un conteneur, seuls les
identifiants des objets immé diatement contenus sont concerné s. Ainsi, si un conteneur immuable (comme un n-uplet)
contient une ré fé rence à un objet mutable, sa valeur change si cet objet mutable est modifié .
Types affect almost all aspects of object behavior. Even the importance of object identity is affected in some sense :
for immutable types, operations that compute new values may actually return a reference to any existing object with
the same type and value, while for mutable objects this is not allowed. For example, after a = 1; b = 1, a and b
may or may not refer to the same object with the value one, depending on the implementation. This is because int
is an immutable type, so the reference to 1 can be reused. This behaviour depends on the implementation used, so
should not be relied upon, but is something to be aware of when making use of object identity tests. However, after
c = []; d = [], c and d are guaranteed to refer to two different, unique, newly created empty lists. (Note that e
= f = [] assigns the same object to both e and f.)

3.2 Hiérarchie des types standards

Vous trouvez ci-dessous une liste des types natifs de Python. Des modules d’extension (é crits en C, Java ou d’autres
langages) peuvent dé finir des types supplé mentaires. Les futures versions de Python pourront ajouter des types à
cette hié rarchie (par exemple les nombres rationnels, des tableaux d’entiers stocké s efficacement, etc.), bien que de
tels ajouts se trouvent souvent plutô t dans la bibliothè que standard.
Quelques descriptions des types ci-dessous contiennent un paragraphe listant des « attributs spé ciaux ». Ces attributs
donnent accè s à l’implé mentation et n’ont, en gé né ral, pas vocation à ê tre utilisé s. Leur dé finition peut changer dans
le futur.

3.2.1 None
Ce type ne possè de qu’une seule valeur. Il n’existe qu’un seul objet avec cette valeur. Vous accé dez à cet objet avec le
nom natif None. Il est utilisé pour signifier l’absence de valeur dans de nombreux cas, par exemple pour des fonctions
qui ne renvoient rien explicitement. Sa valeur boolé enne est fausse.

3.2.2 NotImplemented
This type has a single value. There is a single object with this value. This object is accessed through the built-in
name NotImplemented. Numeric methods and rich comparison methods should return this value if they do not
implement the operation for the operands provided. (The interpreter will then try the reflected operation, or some
other fallback, depending on the operator.) It should not be evaluated in a boolean context.
Consultez implementing-the-arithmetic-operations pour davantage de dé tails.
Modifié dans la version 3.9 : Evaluating NotImplemented in a boolean context is deprecated. While it currently
evaluates as true, it will emit a DeprecationWarning. It will raise a TypeError in a future version of Python.

3.2.3 Ellipse
Ce type ne possè de qu’une seule valeur. Il n’existe qu’un seul objet avec cette valeur. Vous accé dez à cet objet avec le
litté ral ... ou le nom natif Ellipsis. Sa valeur boolé enne est vraie.

18 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

3.2.4 [Link]
Ces objets sont cré és par les litté raux numé riques et renvoyé s en tant que ré sultats par les opé rateurs et les fonctions
arithmé tiques natives. Les objets numé riques sont immuables ; une fois cré és, leur valeur ne change pas. Les nombres
Python sont bien sû r trè s fortement corré lé s aux nombres mathé matiques mais ils sont soumis aux limitations des
repré sentations numé riques par les ordinateurs.
Les repré sentations sous forme de chaînes de caractè res des objets numé riques, produites par __repr__() et
__str__(), ont les proprié té s suivantes :
— Ce sont des litté raux numé riques valides qui, s’ils sont passé s au constructeur de leur classe, produisent un
objet qui a la valeur numé rique de l’objet d’origine.
— La repré sentation est en base 10, si possible.
— Les zé ros en tê te, sauf en ce qui concerne un zé ro seul avant la virgule (repré senté e par un point en Python
conformé ment à la convention anglo-saxonne), ne sont pas affiché s.
— Les zé ros en fin, sauf en ce qui concerne un zé ro seul aprè s la virgule, ne sont pas affiché s.
— Le signe n’est affiché que lorsque le nombre est né gatif.
Python distinguishes between integers, floating-point numbers, and complex numbers :

[Link]

Ils repré sentent des é lé ments de l’ensemble mathé matique des entiers (positifs ou né gatifs).

® Note

Les rè gles pour la repré sentation des entiers ont pour objet de donner l’interpré tation la plus naturelle pour les
opé rations de dé calage et masquage qui impliquent des entiers né gatifs.

Il existe deux types d’entiers :

Entiers (int)
Ils repré sentent les nombres, sans limite de taille, sous ré serve de pouvoir ê tre stocké s en mé moire (virtuelle).
Afin de pouvoir effectuer des dé calages et appliquer des masques, on considè re qu’ils ont une repré sentation
binaire. Les nombres né gatifs sont repré senté s comme une variante du complé ment à 2, qui donne l’illusion
d’une chaîne infinie de bits de signe s’é tendant vers la gauche.
Booléens (bool)
Ils repré sentent les valeurs faux et vrai. Deux objets, False et True, sont les seuls objets boolé ens. Le type
boolé en est un sous-type du type entier et les valeurs boolé ennes se comportent comme les valeurs 0 (pour
False) et 1 (pour True) dans presque tous les contextes. L’exception concerne la conversion en chaîne de
caractè res où "False" et "True" sont renvoyé es.

[Link] (float)

These represent machine-level double precision floating-point numbers. You are at the mercy of the underlying ma-
chine architecture (and C or Java implementation) for the accepted range and handling of overflow. Python does
not support single-precision floating-point numbers ; the savings in processor and memory usage that are usually the
reason for using these are dwarfed by the overhead of using objects in Python, so there is no reason to complicate
the language with two kinds of floating-point numbers.

[Link] (complex)

These represent complex numbers as a pair of machine-level double precision floating-point numbers. The same
caveats apply as for floating-point numbers. The real and imaginary parts of a complex number z can be retrieved
through the read-only attributes [Link] and [Link].

3.2.5 Séquences
These represent finite ordered sets indexed by non-negative numbers. The built-in function len() returns the number
of items of a sequence. When the length of a sequence is n, the index set contains the numbers 0, 1, ..., n-1. Item
i of sequence a is selected by a[i]. Some sequences, including built-in sequences, interpret negative subscripts by

3.2. Hiérarchie des types standards 19

The Python Language Reference, Version 3.13.7

adding the sequence length. For example, a[-2] equals a[n-2], the second to last item of sequence a with length
n.

Sequences also support slicing : a[i:j] selects all items with index k such that i <= k < j. When used as an expression,
a slice is a sequence of the same type. The comment above about negative indexes also applies to negative slice
positions.
Quelques sé quences gè rent le « dé coupage é tendu » (extended slicing en anglais) avec un troisiè me paramè tre :
a[i:j:k] sé lectionne tous les é lé ments de a d’indice x où x = i + n*k, avec n >= 0 et i <= x < j.

Les sé quences se diffé rencient en fonction de leur muabilité :

Séquences immuables
Un objet de type de sé quence immuable ne peut pas ê tre modifié une fois qu’il a é té cré é. Si l’objet contient des
ré fé rences à d’autres objets, ces autres objets peuvent ê tre mutables et peuvent ê tre modifié s ; cependant, les objets
directement ré fé rencé s par un objet immuable ne peuvent pas ê tre modifié s.
Les types suivants sont des sé quences immuables :

Chaînes de caractères
A string is a sequence of values that represent Unicode code points. All the code points in the range U+0000
- U+10FFFF can be represented in a string. Python doesn’t have a char type ; instead, every code point in
the string is represented as a string object with length 1. The built-in function ord() converts a code point
from its string form to an integer in the range 0 - 10FFFF ; chr() converts an integer in the range 0 -
10FFFF to the corresponding length 1 string object. [Link]() can be used to convert a str to bytes
using the given text encoding, and [Link]() can be used to achieve the opposite.
n-uplets (tuples en anglais)
Les é lé ments d’un n-uplet peuvent ê tre n’importe quel objet Python. Les n-uplets de deux é lé ments ou plus sont
formé s par une liste d’expressions dont les é lé ments sont sé paré s par des virgules. Un n-uplet composé d’un
seul é lé ment (un « singleton ») est formé en suffixant une expression avec une virgule (une expression en tant
que telle ne cré e pas un n-uplet car les parenthè ses doivent rester disponibles pour grouper les expressions).
Un n-uplet vide est formé à l’aide d’une paire de parenthè ses vide.
Chaînes d’octets (ou bytes)
A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0 <= x
< 256. Bytes literals (like b'abc') and the built-in bytes() constructor can be used to create bytes objects.
Also, bytes objects can be decoded to strings via the decode() method.

Séquences mutables
Les sé quences mutables peuvent ê tre modifié es aprè s leur cré ation. Les notations de tranches et de sous-ensembles
peuvent ê tre utilisé es en tant que cibles d’une affectation ou de l’instruction del (suppression).

® Note

The collections and array module provide additional examples of mutable sequence types.

Il existe aujourd’hui deux types intrinsè ques de sé quences mutables :

Listes
N’importe quel objet Python peut ê tre é lé ment d’une liste. Les listes sont cré ées en plaçant entre crochets une
liste d’expressions dont les é lé ments sont sé paré s par des virgules (notez que les listes de longueur 0 ou 1 ne
sont pas des cas particuliers).
Tableaux d’octets
Un objet bytearray est un tableau mutable. Il est cré é par la fonction native constructeur bytearray(). À
part la proprié té d’ê tre mutable (et donc de ne pas pouvoir calculer son empreinte par hachage), un tableau
d’octets possè de la mê me interface et les mê mes fonctionnalité s qu’un objet immuable bytes.

20 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

3.2.6 Ensembles
Ils repré sentent les ensembles d’objets, non ordonné s, finis et dont les é lé ments sont uniques. Tels quels, ils ne peuvent
pas ê tre indicé s. Cependant, il est possible d’ité rer dessus et la fonction native len() renvoie le nombre d’é lé ments
de l’ensemble. Les utilisations classiques des ensembles sont les tests d’appartenance rapides, la suppression de dou-
blons dans une sé quence et le calcul d’opé rations mathé matiques telles que l’intersection, l’union, la diffé rence et le
complé mentaire.
Pour les é lé ments des ensembles, les mê mes rè gles concernant l’immuabilité s’appliquent que pour les clé s de diction-
naires. Notez que les types numé riques obé issent aux rè gles normales pour les comparaisons numé riques : si deux
nombres sont é gaux (pour l’opé ration de comparaison, par exemple 1 et 1.0), un seul é lé ment est conservé dans
l’ensemble.
Actuellement, il existe deux types d’ensembles natifs :
Ensembles
Ils repré sentent les ensembles mutables. Un ensemble est cré é par la fonction native constructeur set() et
peut ê tre modifié par la suite à l’aide de diffé rentes mé thodes, par exemple add().
Ensembles figés
Ils repré sentent les ensembles immuables. Ils sont cré és par la fonction native constructeur frozenset().
Comme un ensemble figé est immuable et hachable, il peut ê tre utilisé comme é lé ment d’un autre ensemble
ou comme clé de dictionnaire.

3.2.7 Tableaux de correspondances

Ils repré sentent les ensembles finis d’objets indicé s par des ensembles index arbitraires. La notation a[k] sé lectionne
l’é lé ment indicé par k dans le tableau de correspondances a ; elle peut ê tre utilisé e dans des expressions, comme cible
d’une affectation ou avec l’instruction del. La fonction native len() renvoie le nombre d’é lé ments du tableau de
correspondances.
Il n’existe actuellement qu’un seul type natif pour les tableaux de correspondances :

Dictionnaires
Ils repré sentent les ensembles finis d’objets indicé s par des valeurs presque arbitraires. Les seuls types de valeurs non
reconnus comme clé s sont les valeurs contenant des listes, des dictionnaires ou les autres types mutables qui sont
comparé s par valeur plutô t que par l’identifiant de l’objet. La raison de cette limitation est qu’une implé mentation
efficace de dictionnaire requiert que l’empreinte par hachage des clé s reste constante dans le temps. Les types numé -
riques obé issent aux rè gles normales pour les comparaisons numé riques : si deux nombres sont é gaux pour l’opé ration
de comparaison, par exemple 1 et 1.0, alors ces deux nombres peuvent ê tre utilisé s indiffé remment pour dé signer
la mê me entré e du dictionnaire.
Les dictionnaires pré servent l’ordre d’insertion, ce qui signifie que les clé s sont renvoyé es sé quentiellement dans le
mê me ordre que celui de l’insertion. Remplacer une clé existante ne change pas l’ordre. Par contre, la retirer puis la
ré insé rer la met à la fin et non à sa pré cé dente position.
Dictionaries are mutable ; they can be created by the {} notation (see section Agencements de dictionnaires).
Les modules d’extensions [Link] et [Link] apportent d’autres exemples de types tableaux de correspondances,
de mê me que le module collections.
Modifié dans la version 3.7 : les dictionnaires ne conservaient pas l’ordre d’insertion dans les versions anté rieures à Py-
thon 3.6. Dans CPython 3.6, l’ordre d’insertion é tait dé jà conservé , mais considé ré comme un dé tail d’implé mentation
et non comme une garantie du langage.

3.2.8 Types appelables

Ce sont les types sur lesquels on peut faire un appel de fonction (lisez la section Appels) :

3.2. Hiérarchie des types standards 21

The Python Language Reference, Version 3.13.7

Fonctions définies par l’utilisateur

Un objet fonction dé finie par l’utilisateur (mais ce n’est pas forcé ment l’utilisateur courant qui a dé fini cette fonction)
est cré é par la dé finition d’une fonction (voir la section Définition de fonctions). Il doit ê tre appelé avec une liste
d’arguments contenant le mê me nombre d’é lé ments que la liste des paramè tres formels de la fonction.

Special read-only attributes

Attribut Signification
A reference to the dictionary that holds the func-
function.__globals__ tion’s global variables -- the global namespace of the
module in which the function was defined.
None or a tuple of cells that contain bindings for the
function.__closure__ names specified in the co_freevars attribute of the
function’s code object.
Un objet cellule possè de un attribut cell_contents.
Il peut ê tre utilisé pour obtenir la valeur de la cellule et
pour en dé finir la valeur.

Special writable attributes

Most of these attributes check the type of the assigned value :

Attribut Signification
The function’s documentation string, or None if unavai-
function.__doc__ lable.

The function’s name. See also : __name__

function.__name__ attributes.

The function’s qualified name. See also :

function.__qualname__ __qualname__ attributes.
Ajouté dans la version 3.3.
Nom du module où la fonction est dé finie ou None si ce
function.__module__ nom n’est pas disponible.

A tuple containing default parameter values for those

function.__defaults__ parameters that have defaults, or None if no parameters
have a default value.
The code object representing the compiled function
function.__code__ body.

The namespace supporting arbitrary function attributes.

function.__dict__ See also : __dict__ attributes.

A dictionary containing annotations of parameters.

function.__annotations__ The keys of the dictionary are the parameter names, and
'return' for the return annotation, if provided. See
also : annotations-howto.
A dictionary containing defaults for keyword-only
function.__kwdefaults__ parameters.

A tuple containing the type parameters of a generic

function.__type_params__ function.
Ajouté dans la version 3.12.

22 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

Function objects also support getting and setting arbitrary attributes, which can be used, for example, to attach me-
tadata to functions. Regular attribute dot-notation is used to get and set such attributes.
Particularité de l’implémentation CPython : CPython’s current implementation only supports function attributes
on user-defined functions. Function attributes on built-in functions may be supported in the future.
Additional information about a function’s definition can be retrieved from its code object (accessible via the __code__
attribute).

Méthodes d’instances
Un objet mé thode d’instance combine une classe, une instance de classe et tout objet appelable (normalement une
fonction dé finie par l’utilisateur).
Special read-only attributes :

Refers to the class instance object to which the method

method.__self__ is bound

Refers to the original function object

method.__func__

The method’s documentation (same as method.

method.__doc__ __func__.__doc__). A string if the original func-
tion had a docstring, else None.
The name of the method (same as method.
method.__name__ __func__.__name__)

The name of the module the method was defined in, or

method.__module__ None if unavailable.

Methods also support accessing (but not setting) the arbitrary function attributes on the underlying function object.
User-defined method objects may be created when getting an attribute of a class (perhaps via an instance of that
class), if that attribute is a user-defined function object or a classmethod object.
When an instance method object is created by retrieving a user-defined function object from a class via one of its
instances, its __self__ attribute is the instance, and the method object is said to be bound. The new method’s
__func__ attribute is the original function object.

When an instance method object is created by retrieving a classmethod object from a class or instance, its
__self__ attribute is the class itself, and its __func__ attribute is the function object underlying the class me-
thod.
When an instance method object is called, the underlying function (__func__) is called, inserting the class instance
(__self__) in front of the argument list. For instance, when C is a class which contains a definition for a function
f(), and x is an instance of C, calling x.f(1) is equivalent to calling C.f(x, 1).

When an instance method object is derived from a classmethod object, the ”class instance” stored in __self__
will actually be the class itself, so that calling either x.f(1) or C.f(1) is equivalent to calling f(C,1) where f is
the underlying function.
It is important to note that user-defined functions which are attributes of a class instance are not converted to bound
methods ; this only happens when the function is an attribute of the class.

Fonctions génératrices (ou générateurs)

Une fonction ou une mé thode qui utilise l’instruction yield (voir la section L’instruction yield) est appelé e fonction
génératrice. Une telle fonction, lorsqu’elle est appelé e, renvoie toujours un objet itérateur qui peut ê tre utilisé pour
exé cuter le corps de la fonction : appeler la mé thode iterator.__next__() de l’ité rateur exé cute la fonction
jusqu’à ce qu’elle renvoie une valeur à l’aide de l’instruction yield. Quand la fonction exé cute l’instruction return

3.2. Hiérarchie des types standards 23

The Python Language Reference, Version 3.13.7

ou se termine, une exception StopIteration est levé e et l’ité rateur a atteint la fin de l’ensemble de valeurs qu’il
peut renvoyer.

Fonctions coroutines
Une fonction ou mé thode dé finie en utilisant async def est appelé e fonction coroutine. Une telle fonction, quand elle
est appelé e, renvoie un objet coroutine. Elle peut contenir des expressions await ou async with ou des instructions
async for. Voir é galement la section Objets coroutines.

Fonctions génératrices (ou générateurs) asynchrones

Une fonction ou une mé thode dé finie avec async def et qui utilise l’instruction yield est appelé e fonction généra-
trice asynchrone. Une telle fonction, quand elle est appelé e, renvoie un objet itérateur asynchrone qui peut ê tre utilisé
dans des instructions async for pour exé cuter le corps de la fonction.
Appeler la mé thode aiterator.__anext__ de l’ité rateur asynchrone renvoie un awaitable qui, lorsqu’on l’attend,
s’exé cute jusqu’à ce qu’il fournisse une valeur à l’aide de l’expression yield. Quand la fonction exé cute une instruction
return (sans valeur) ou arrive à la fin, une exception StopAsyncIteration est levé e et l’ité rateur asynchrone a
atteint la fin de l’ensemble des valeurs qu’il peut produire.

Fonctions natives
A built-in function object is a wrapper around a C function. Examples of built-in functions are len() and math.
sin() (math is a standard built-in module). The number and type of the arguments are determined by the C function.
Special read-only attributes :
— __doc__ is the function’s documentation string, or None if unavailable. See function.__doc__.
— __name__ is the function’s name. See function.__name__.
— __self__ is set to None (but see the next item).
— __module__ is the name of the module the function was defined in or None if unavailable. See function.
__module__.

Méthodes natives
This is really a different disguise of a built-in function, this time containing an object passed to the C function as an
implicit extra argument. An example of a built-in method is [Link](), assuming alist is a list object. In
this case, the special read-only attribute __self__ is set to the object denoted by alist. (The attribute has the same
semantics as it does with other instance methods.)

Classes
Classes are callable. These objects normally act as factories for new instances of themselves, but variations are possible
for class types that override __new__(). The arguments of the call are passed to __new__() and, in the typical case,
to __init__() to initialize the new instance.

Instances de classe
Les instances d’une classe peuvent devenir des appelables si vous dé finissez la mé thode __call__() de leur classe.

3.2.9 Modules
Modules are a basic organizational unit of Python code, and are created by the import system as invoked either by the
import statement, or by calling functions such as importlib.import_module() and built-in __import__().
A module object has a namespace implemented by a dictionary object (this is the dictionary referenced by the
__globals__ attribute of functions defined in the module). Attribute references are translated to lookups in this
dictionary, e.g., m.x is equivalent to m.__dict__["x"]. A module object does not contain the code object used to
initialize the module (since it isn’t needed once the initialization is done).
L’affectation d’un attribut met à jour le dictionnaire d’espace de nommage du module, par exemple m.x = 1 est
é quivalent à m.__dict__["x"] = 1.

24 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

Import-related attributes on module objects

Module objects have the following attributes that relate to the import system. When a module is created using the
machinery associated with the import system, these attributes are filled in based on the module’s spec, before the
loader executes and loads the module.
To create a module dynamically rather than using the import system, it’s recommended to use [Link].
module_from_spec(), which will set the various import-controlled attributes to appropriate values. It’s also pos-
sible to use the [Link] constructor to create modules directly, but this technique is more error-prone,
as most attributes must be manually set on the module object after it has been created when using this approach.

Ϫ Prudence

With the exception of __name__, it is strongly recommended that you rely on __spec__ and its attributes ins-
tead of any of the other individual attributes listed in this subsection. Note that updating an attribute on __spec__
will not update the corresponding attribute on the module itself :
>>> import typing
>>> typing.__name__, typing.__spec__.name
('typing', 'typing')
>>> typing.__spec__.name = 'spelling'
>>> typing.__name__, typing.__spec__.name
('typing', 'spelling')
>>> typing.__name__ = 'keyboard_smashing'
>>> typing.__name__, typing.__spec__.name
('keyboard_smashing', 'spelling')

module.__name__
The name used to uniquely identify the module in the import system. For a directly executed module, this will
be set to "__main__".
This attribute must be set to the fully qualified name of the module. It is expected to match the value of
module.__spec__.name.

module.__spec__
A record of the module’s import-system-related state.
Set to the module spec that was used when importing the module. See Spécificateurs de modules for more
details.
Ajouté dans la version 3.4.
module.__package__
The package a module belongs to.
If the module is top-level (that is, not a part of any specific package) then the attribute should be set to ''
(the empty string). Otherwise, it should be set to the name of the module’s package (which can be equal to
module.__name__ if the module itself is a package). See PEP 366 for further details.

This attribute is used instead of __name__ to calculate explicit relative imports for main modules. It defaults to
None for modules created dynamically using the [Link] constructor ; use [Link].
module_from_spec() instead to ensure the attribute is set to a str.

It is strongly recommended that you use module.__spec__.parent instead of module.__package__.

__package__ is now only used as a fallback if __spec__.parent is not set, and this fallback path is de-
precated.
Modifié dans la version 3.4 : This attribute now defaults to None for modules created dynamically using the
[Link] constructor. Previously the attribute was optional.

Modifié dans la version 3.6 : The value of __package__ is expected to be the same as __spec__.parent.
__package__ is now only used as a fallback during import resolution if __spec__.parent is not defined.

3.2. Hiérarchie des types standards 25

The Python Language Reference, Version 3.13.7

Modifié dans la version 3.10 : ImportWarning is raised if an import resolution falls back to __package__
instead of __spec__.parent.
Modifié dans la version 3.12 : Raise DeprecationWarning instead of ImportWarning when falling back
to __package__ during import resolution.
Deprecated since version 3.13, will be removed in version 3.15 : __package__ will cease to be set or taken
into consideration by the import system or standard library.
module.__loader__
The loader object that the import machinery used to load the module.
This attribute is mostly useful for introspection, but can be used for additional loader-specific functionality, for
example getting data associated with a loader.
__loader__ defaults to None for modules created dynamically using the [Link] constructor ;
use [Link].module_from_spec() instead to ensure the attribute is set to a loader object.
It is strongly recommended that you use module.__spec__.loader instead of module.__loader__.
Modifié dans la version 3.4 : This attribute now defaults to None for modules created dynamically using the
[Link] constructor. Previously the attribute was optional.

Deprecated since version 3.12, will be removed in version 3.16 : Setting __loader__ on a module while
failing to set __spec__.loader is deprecated. In Python 3.16, __loader__ will cease to be set or taken
into consideration by the import system or the standard library.
module.__path__
A (possibly empty) sequence of strings enumerating the locations where the package’s submodules will be
found. Non-package modules should not have a __path__ attribute. See l’attribut __path__ des modules for
more details.
It is strongly recommended that you use module.__spec__.submodule_search_locations instead of
module.__path__.

module.__file__

module.__cached__
__file__ and __cached__ are both optional attributes that may or may not be set. Both attributes should
be a str when they are available.
__file__ indicates the pathname of the file from which the module was loaded (if loaded from a file), or the
pathname of the shared library file for extension modules loaded dynamically from a shared library. It might
be missing for certain types of modules, such as C modules that are statically linked into the interpreter, and
the import system may opt to leave it unset if it has no semantic meaning (for example, a module loaded from
a database).
If __file__ is set then the __cached__ attribute might also be set, which is the path to any compiled version
of the code (for example, a byte-compiled file). The file does not need to exist to set this attribute ; the path
can simply point to where the compiled file would exist (see PEP 3147).
Note that __cached__ may be set even if __file__ is not set. However, that scenario is quite atypical.
Ultimately, the loader is what makes use of the module spec provided by the finder (from which __file__
and __cached__ are derived). So if a loader can load from a cached module but otherwise does not load from
a file, that atypical scenario may be appropriate.
It is strongly recommended that you use module.__spec__.cached instead of module.__cached__.
Deprecated since version 3.13, will be removed in version 3.15 : Setting __cached__ on a module while
failing to set __spec__.cached is deprecated. In Python 3.15, __cached__ will cease to be set or taken
into consideration by the import system or standard library.

26 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

Other writable attributes on module objects

As well as the import-related attributes listed above, module objects also have the following writable attributes :
module.__doc__
The module’s documentation string, or None if unavailable. See also : __doc__ attributes.
module.__annotations__
Dictionnaire des annotations de variable trouvé es lors de l’exé cution du code du module. Pour plus de dé tails
sur l’attribut __annotations__, voir annotations-howto.

Module dictionaries
Module objects also have the following special read-only attribute :
module.__dict__
The module’s namespace as a dictionary object. Uniquely among the attributes listed here, __dict__ cannot
be accessed as a global variable from within a module ; it can only be accessed as an attribute on module
objects.
en raison de la maniè re dont CPython nettoie les dictionnaires de modules, le dictionnaire du module est effacé
quand le module n’est plus visible, mê me si le dictionnaire possè de encore des ré fé rences actives. Pour é viter
ceci, copiez le dictionnaire ou gardez le module dans votre champ de visibilité tant que vous souhaitez utiliser
le dictionnaire directement.

3.2.10 Classes déclarées par le développeur

Custom class types are typically created by class definitions (see section Définition de classes). A class has a namespace
implemented by a dictionary object. Class attribute references are translated to lookups in this dictionary, e.g., C.x
is translated to C.__dict__["x"] (although there are a number of hooks which allow for other means of locating
attributes). When the attribute name is not found there, the attribute search continues in the base classes. This search
of the base classes uses the C3 method resolution order which behaves correctly even in the presence of ’diamond’
inheritance structures where there are multiple inheritance paths leading back to a common ancestor. Additional
details on the C3 MRO used by Python can be found at python_2.3_mro.
When a class attribute reference (for class C, say) would yield a class method object, it is transformed into an instance
method object whose __self__ attribute is C. When it would yield a staticmethod object, it is transformed into
the object wrapped by the static method object. See section Implémentation de descripteurs for another way in which
attributes retrieved from a class may differ from those actually contained in its __dict__.
Les affectations d’un attribut de classe mettent à jour le dictionnaire de la classe, jamais le dictionnaire d’une classe
de base.
Un objet classe peut ê tre appelé (voir ci-dessus) pour produire une instance de classe (voir ci-dessous).

3.2. Hiérarchie des types standards 27

The Python Language Reference, Version 3.13.7

Special attributes

Attribut Signification
The class’s name. See also : __name__ attributes.
type.__name__

The class’s qualified name. See also : __qualname__

type.__qualname__ attributes.

Nom du module où la classe a é té dé finie.

type.__module__

A mapping proxy providing a read-only view of the

type.__dict__ class’s namespace. See also : __dict__ attributes.

A tuple containing the class’s bases. In most cases,

type.__bases__ for a class defined as class X(A, B, C), X.
__bases__ will be exactly equal to (A, B, C).
The class’s documentation string, or None if undefined.
type.__doc__ Not inherited by subclasses.

A dictionary containing variable annotations collected

type.__annotations__ during class body execution. For best practices on wor-
king with __annotations__, please see annotations-
howto.

Ϫ Prudence

Accessing the __annotations__ attribute of a

class object directly may yield incorrect results in
the presence of metaclasses. In addition, the attri-
bute may not exist for some classes. Use inspect.
get_annotations() to retrieve class annota-
tions safely.

A tuple containing the type parameters of a generic

type.__type_params__ class.
Ajouté dans la version 3.12.
A tuple containing names of attributes of this class
type.__static_attributes__ which are assigned through self.X from any function
in its body.
Ajouté dans la version 3.13.
The line number of the first line of the class defini-
type.__firstlineno__ tion, including decorators. Setting the __module__ at-
tribute removes the __firstlineno__ item from the
type’s dictionary.
Ajouté dans la version 3.13.
The tuple of classes that are considered when looking
type.__mro__ for base classes during method resolution.

Special methods
In addition to the special attributes described above, all Python classes also have the following two methods available :

[Link]()
This method can be overridden by a metaclass to customize the method resolution order for its instances. It is

28 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

called at class instantiation, and its result is stored in __mro__.

type.__subclasses__()
Each class keeps a list of weak references to its immediate subclasses. This method returns a list of all those
references still alive. The list is in definition order. Example :

>>> class A: pass

>>> class B(A): pass
>>> A.__subclasses__()
[<class 'B'>]

3.2.11 Instances de classe

A class instance is created by calling a class object (see above). A class instance has a namespace implemented as a
dictionary which is the first place in which attribute references are searched. When an attribute is not found there,
and the instance’s class has an attribute by that name, the search continues with the class attributes. If a class attribute
is found that is a user-defined function object, it is transformed into an instance method object whose __self__
attribute is the instance. Static method and class method objects are also transformed ; see above under ”Classes”.
See section Implémentation de descripteurs for another way in which attributes of a class retrieved via its instances
may differ from the objects actually stored in the class’s __dict__. If no class attribute is found, and the object’s
class has a __getattr__() method, that is called to satisfy the lookup.
Les affectations et suppressions d’attributs mettent à jour le dictionnaire de l’instance, jamais le dictionnaire de la
classe. Si la classe possè de une mé thode __setattr__() ou __delattr__(), elle est appelé e au lieu de mettre à
jour le dictionnaire de l’instance directement.
Les instances de classes peuvent pré tendre ê tre des nombres, des sé quences ou des tableaux de correspondances si
elles ont des mé thodes avec des noms spé ciaux. Voir la section Méthodes spéciales.

Special attributes
object.__class__
Classe de l’instance de classe.
object.__dict__
A dictionary or other mapping object used to store an object’s (writable) attributes. Not all instances have a
__dict__ attribute ; see the section on créneaux prédéfinis (__slots__) for more details.

3.2.12 Objets entrées-sorties (ou objets fichiers)

Un objet fichier repré sente un fichier ouvert. Diffé rents raccourcis existent pour cré er des objets fichiers : la fonc-
tion native open() et aussi [Link](), [Link]() ou la mé thode makefile() des objets connecteurs (et
sû rement d’autres fonctions ou mé thodes fournies par les modules d’extensions).
Les objets [Link], [Link] et [Link] sont initialisé s à des objets fichiers correspondant à l’entré e
standard, la sortie standard et le flux d’erreurs de l’interpré teur ; ils sont tous ouverts en mode texte et se conforment
donc à l’interface dé finie par la classe abstraite [Link].

3.2.13 Types internes

Quelques types utilisé s en interne par l’interpré teur sont accessibles à l’utilisateur. Leur dé finition peut changer dans
les futures versions de l’interpré teur mais ils sont donné s ci-dessous à fin d’exhaustivité .

Objets Code
Un objet code repré sente le code Python sous sa forme compilé e en code intermédiaire. La diffé rence entre un objet
code et un objet fonction est que l’objet fonction contient une ré fé rence explicite vers les globales de la fonction (le
module dans lequel elle est dé finie) alors qu’un objet code ne contient aucun contexte ; par ailleurs, les valeurs par
dé faut des arguments sont stocké es dans l’objet fonction, pas dans l’objet code (parce que ce sont des valeurs calculé es
au moment de l’exé cution). Contrairement aux objets fonctions, les objets codes sont immuables et ne contiennent
aucune ré fé rence (directe ou indirecte) à des objets mutables.

3.2. Hiérarchie des types standards 29

The Python Language Reference, Version 3.13.7

Special read-only attributes

The function name

codeobject.co_name

The fully qualified function name

codeobject.co_qualname Ajouté dans la version 3.11.

The total number of positional parameters (including

codeobject.co_argcount positional-only parameters and parameters with default
values) that the function has
The number of positional-only parameters (including
codeobject.co_posonlyargcount arguments with default values) that the function has

The number of keyword-only parameters (including ar-

codeobject.co_kwonlyargcount guments with default values) that the function has

The number of local variables used by the function (in-

codeobject.co_nlocals cluding parameters)

A tuple containing the names of the local variables in

codeobject.co_varnames the function (starting with the parameter names)

A tuple containing the names of local variables that

codeobject.co_cellvars are referenced from at least one nested scope inside the
function
A tuple containing the names of free (closure) va-
codeobject.co_freevars riables that a nested scope references in an outer scope.
See also function.__closure__.
Note : references to global and builtin names are not
included.
A string representing the sequence of bytecode instruc-
codeobject.co_code tions in the function

A tuple containing the literals used by the bytecode in

codeobject.co_consts the function

A tuple containing the names used by the bytecode in

codeobject.co_names the function

The name of the file from which the code was compiled
codeobject.co_filename

The line number of the first line of the function

codeobject.co_firstlineno

A string encoding the mapping from bytecode offsets

codeobject.co_lnotab to line numbers. For details, see the source code of the
interpreter.
Obsolè te depuis la version 3.12 : This attribute of code
objects is deprecated, and may be removed in Python
3.15.
The required stack size of the code object
codeobject.co_stacksize

An integer encoding a number of flags for the inter-

codeobject.co_flags preter.

30 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

The following flag bits are defined for co_flags : bit 0x04 is set if the function uses the *arguments syntax to
accept an arbitrary number of positional arguments ; bit 0x08 is set if the function uses the **keywords syntax to
accept arbitrary keyword arguments ; bit 0x20 is set if the function is a generator. See inspect-module-co-flags for
details on the semantics of each flags that might be present.
Future feature declarations (for example, from __future__ import division) also use bits in co_flags to
indicate whether a code object was compiled with a particular feature enabled. See compiler_flag.
Other bits in co_flags are reserved for internal use.
If a code object represents a function, the first item in co_consts is the documentation string of the function, or
None if undefined.

Methods on code objects

codeobject.co_positions()
Returns an iterable over the source code positions of each bytecode instruction in the code object.
The iterator returns tuples containing the (start_line, end_line, start_column, end_column).
The i-th tuple corresponds to the position of the source code that compiled to the i-th code unit. Column
information is 0-indexed utf-8 byte offsets on the given source line.
L’information sur la position peut ê tre manquante. Ce peut ê tre le cas si (liste non exhaustive) :
— l’interpré teur est lancé avec l’option -X no_debug_ranges ;
— le fichier .pyc est le produit d’une compilation avec l’option -X no_debug_ranges ;
— le n-uplet de position correspond à des instructions artificielles ;
— les lignes et colonnes ne peuvent pas ê tre repré senté es en tant que nombre, en raison de limitations dues à
l’implé mentation ;
Dans ce cas, certains ou tous les é lé ments du n-uplet peuvent valoir None.
Ajouté dans la version 3.11.

® Note

cette fonctionnalité né cessite de stocker les positions de colonne dans les objets code, ce qui peut conduire
à une lé gè re augmentation de l’utilisation du disque par les fichiers Python compilé s ou de l’utilisation de
la mé moire. Pour é viter de stocker cette information supplé mentaire ou pour dé sactiver l’affichage supplé -
mentaire dans la pile d’appels, vous pouvez activer l’option de ligne de commande -X no_debug_ranges
ou la variable d’environnement PYTHONNODEBUGRANGES.

codeobject.co_lines()
Returns an iterator that yields information about successive ranges of bytecodes. Each item yielded is a
(start, end, lineno) tuple :
— start (an int) represents the offset (inclusive) of the start of the bytecode range
— end (an int) represents the offset (exclusive) of the end of the bytecode range
— lineno is an int representing the line number of the bytecode range, or None if the bytecodes in the
given range have no line number
The items yielded will have the following properties :
— The first range yielded will have a start of 0.
— The (start, end) ranges will be non-decreasing and consecutive. That is, for any pair of tuples, the
start of the second will be equal to the end of the first.
— No range will be backwards : end >= start for all triples.
— The last tuple yielded will have end equal to the size of the bytecode.
Zero-width ranges, where start == end, are allowed. Zero-width ranges are used for lines that are present
in the source code, but have been eliminated by the bytecode compiler.
Ajouté dans la version 3.10.

3.2. Hiérarchie des types standards 31

The Python Language Reference, Version 3.13.7

µ Voir aussi

PEP 626 - Precise line numbers for debugging and other tools.
The PEP that introduced the co_lines() method.

[Link](**kwargs)
Return a copy of the code object with new values for the specified fields.
Code objects are also supported by the generic function [Link]().
Ajouté dans la version 3.8.

Objets cadres
Frame objects represent execution frames. They may occur in traceback objects, and are also passed to registered
trace functions.

Special read-only attributes

Points to the previous stack frame (towards the caller),

frame.f_back or None if this is the bottom stack frame

The code object being executed in this frame. Acces-

frame.f_code sing this attribute raises an auditing event object.
__getattr__ with arguments obj and "f_code".
The mapping used by the frame to look up local va-
frame.f_locals riables. If the frame refers to an optimized scope, this
may return a write-through proxy object.
Modifié dans la version 3.13 : Return a proxy for opti-
mized scopes.
The dictionary used by the frame to look up global va-
frame.f_globals riables

The dictionary used by the frame to look up built-in (in-

frame.f_builtins trinsic) names

The ”precise instruction” of the frame object (this is an

frame.f_lasti index into the bytecode string of the code object)

32 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

Special writable attributes

If not None, this is a function called for various events

frame.f_trace during code execution (this is used by debuggers). Nor-
mally an event is triggered for each new source line (see
f_trace_lines).
Set this attribute to False to disable triggering a tracing
frame.f_trace_lines event for each source line.

Set this attribute to True to allow per-opcode events

frame.f_trace_opcodes to be requested. Note that this may lead to undefined
interpreter behaviour if exceptions raised by the trace
function escape to the function being traced.
The current line number of the frame -- writing to this
frame.f_lineno from within a trace function jumps to the given line
(only for the bottom-most frame). A debugger can im-
plement a Jump command (aka Set Next Statement) by
writing to this attribute.

Frame object methods

Les objets cadres comprennent une mé thode :

[Link]()
This method clears all references to local variables held by the frame. Also, if the frame belonged to a generator,
the generator is finalized. This helps break reference cycles involving frame objects (for example when catching
an exception and storing its traceback for later use).
RuntimeError is raised if the frame is currently executing or suspended.

Ajouté dans la version 3.4.

Modifié dans la version 3.13 : Attempting to clear a suspended frame raises RuntimeError (as has always
been the case for executing frames).

Objets traces d’appels

Traceback objects represent the stack trace of an exception. A traceback object is implicitly created when an exception
occurs, and may also be explicitly created by calling [Link].
Modifié dans la version 3.7 : Traceback objects can now be explicitly instantiated from Python code.
For implicitly created tracebacks, when the search for an exception handler unwinds the execution stack, at each
unwound level a traceback object is inserted in front of the current traceback. When an exception handler is entered,
the stack trace is made available to the program. (See section L’instruction try.) It is accessible as the third item of
the tuple returned by sys.exc_info(), and as the __traceback__ attribute of the caught exception.
When the program contains no suitable handler, the stack trace is written (nicely formatted) to the standard error
stream ; if the interpreter is interactive, it is also made available to the user as sys.last_traceback.
For explicitly created tracebacks, it is up to the creator of the traceback to determine how the tb_next attributes
should be linked to form a full stack trace.
Special read-only attributes :

3.2. Hiérarchie des types standards 33

The Python Language Reference, Version 3.13.7

Points to the execution frame of the current level.

traceback.tb_frame Accessing this attribute raises an auditing event
object.__getattr__ with arguments obj and
"tb_frame".
Gives the line number where the exception occurred
traceback.tb_lineno

Indicates the ”precise instruction”.

traceback.tb_lasti

The line number and last instruction in the traceback may differ from the line number of its frame object if the
exception occurred in a try statement with no matching except clause or with a finally clause.
traceback.tb_next
The special writable attribute tb_next is the next level in the stack trace (towards the frame where the ex-
ception occurred), or None if there is no next level.
Modifié dans la version 3.7 : This attribute is now writable

Objets tranches
Un objet tranche est utilisé pour repré senter des dé coupes des mé thodes __getitem__(). Ils sont aussi cré és par
la fonction native slice().
Attributs spé ciaux en lecture seule : start est la borne infé rieure ; stop est la borne supé rieure ; step est la valeur
du pas ; chaque attribut vaut None s’il est omis. Ces attributs peuvent ê tre de n’importe quel type.
Les objets tranches comprennent une mé thode :
[Link](self, length)
Cette mé thode prend un argument entier length et calcule les informations de la tranche que l’objet slice dé crit
s’il est appliqué à une sé quence de length é lé ments. Elle renvoie un triplet d’entiers ; respectivement, ce sont les
indices de début et fin ainsi que le pas de dé coupe. Les indices manquants ou en dehors sont gé ré s de maniè re
cohé rente avec les tranches normales.

Objets méthodes statiques

Les objets mé thodes statiques permettent la transformation des objets fonctions en objets mé thodes dé crits au-dessus.
Un objet mé thode statique encapsule tout autre objet, souvent un objet mé thode dé finie par l’utilisateur. Quand un
objet mé thode statique est ré cupé ré depuis une classe ou une instance de classe, l’objet ré ellement renvoyé est un objet
encapsulé , qui n’a pas vocation à ê tre transformé encore une fois. Les objets mé thodes statiques sont aussi appelables.
Les objets mé thodes statiques sont cré és par le constructeur natif staticmethod().

Objets méthodes de classes

A class method object, like a static method object, is a wrapper around another object that alters the way in which
that object is retrieved from classes and class instances. The behaviour of class method objects upon such retrieval
is described above, under ”instance methods”. Class method objects are created by the built-in classmethod()
constructor.

3.3 Méthodes spéciales

Une classe peut implé menter certaines opé rations que l’on invoque par une syntaxe spé ciale (telles que les opé rations
arithmé tiques ou la dé coupe en tranches) en dé finissant des mé thodes aux noms particuliers. C’est l’approche utilisé e
par Python pour la surcharge d’opérateur, permettant à une classe de dé finir son propre comportement vis-à -vis des
opé rateurs du langage. Par exemple, si une classe dé finit une mé thode __getitem__() et que x est une instance

34 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

de cette classe, alors x[i] est globalement é quivalent à type(x).__getitem__(x, i). Sauf lorsque c’est men-
tionné , toute tentative d’appliquer une opé ration alors que la mé thode approprié e n’est pas dé finie lè ve une exception
(typiquement AttributeError ou TypeError).
Dé finir une mé thode spé ciale à None indique que l’opé ration correspondante n’est pas disponible. Par exemple, si une
classe assigne None à __iter__(), vous ne pouvez pas ité rer sur la classe et appeler iter() sur une instance lè ve
TypeError (sans se replier sur __getitem__()) 2 .

Lorsque vous implé mentez une classe qui é mule un type natif, il est important que cette é mulation n’implé mente
que ce qui fait sens pour l’objet qui est modé lisé . Par exemple, la recherche d’é lé ments individuels d’une sé quence
peut faire sens, mais pas l’extraction d’une tranche (un exemple est l’interface de NodeList dans le modè le objet des
documents W3C).

3.3.1 Personnalisation de base

object.__new__(cls , ... )[ ]
Appelé e pour cré er une nouvelle instance de la classe cls. La mé thode __new__() est statique (c’est un cas
particulier, vous n’avez pas besoin de la dé clarer comme telle) qui prend comme premier argument la classe pour
laquelle on veut cré er une instance. Les autres arguments sont ceux passé s à l’expression de l’objet constructeur
(l’appel à la classe). La valeur de retour de __new__() doit ê tre l’instance du nouvel objet (classiquement une
instance de cls).
Typical implementations create a new instance of the class by invoking the superclass’s __new__() method
using super().__new__(cls[, ...]) with appropriate arguments and then modifying the newly created
instance as necessary before returning it.
Si __new__() est appelé e pendant la construction de l’objet et renvoie une instance de cls, alors la mé thode
__init__() de la nouvelle instance est invoqué e avec __init__(self[, …]) où self est la nouvelle ins-
tance et les autres arguments sont les mê mes que ceux passé s au constructeur de l’objet.
Si __new__() ne renvoie pas une instance de cls, alors la mé thode __init__() de la nouvelle instance n’est
pas invoqué e.
L’objectif de __new__() est principalement, pour les sous-classes de types immuables (comme int, str ou
tuple), d’autoriser la cré ation sur mesure des instances. Elle est aussi souvent surchargé e dans les mé taclasses
pour particulariser la cré ation des classes.
object.__init__(self , ... ) [ ]
Appelé e aprè s la cré ation de l’instance (par __new__()), mais avant le retour vers l’appelant. Les argu-
ments sont ceux passé s à l’expression du constructeur de classe. Si une classe de base possè de une mé thode
__init__(), la mé thode __init__() de la classe dé rivé e, si elle existe, doit explicitement appeler cette mé -
thode pour assurer une initialisation correcte de la partie classe de base de l’instance ; par exemple : super().
__init__([args…]).
Comme __new__() et __init__() travaillent ensemble pour cré er des objets (__new__() pour le cré er,
__init__() pour le particulariser), __init__() ne doit pas renvoyer de valeur None ; sinon une exception
TypeError est levé e à l’exé cution.
object.__del__(self )
Appelé e au moment où une instance est sur le point d’ê tre dé truite. On l’appelle aussi finaliseur ou (impro-
prement) destructeur. Si une classe de base possè de une mé thode __del__(), la mé thode __del__() de
la classe dé rivé e, si elle existe, doit explicitement l’appeler pour s’assurer de l’effacement correct de la partie
classe de base de l’instance.
Il est possible (mais pas recommandé ) que la mé thode __del__() retarde la destruction de l’instance en
cré ant une nouvelle ré fé rence vers cet objet. Python appelle ceci la résurrection d’objet. En fonction de l’implé -
mentation, __del__() peut ê tre appelé e une deuxiè me fois au moment où l’objet ressuscité va ê tre dé truit ;
l’implé mentation actuelle de CPython ne l’appelle qu’une fois.
It is not guaranteed that __del__() methods are called for objects that still exist when the interpreter exits.
[Link] provides a straightforward way to register a cleanup function to be called when an object
2. The __hash__(), __iter__(), __reversed__(), __contains__(), __class_getitem__() and __fspath__() methods have
special handling for this. Others will still raise a TypeError, but may do so by relying on the behavior that None is not callable.

3.3. Méthodes spéciales 35

The Python Language Reference, Version 3.13.7

is garbage collected.

® Note

del x n’appelle pas directement x.__del__() — la premiè re dé cré mente le compteur de ré fé rences de
x. La seconde n’est appelé e que quand le compteur de ré fé rences de x atteint zé ro.

Particularité de l’implémentation CPython : It is possible for a reference cycle to prevent the reference count
of an object from going to zero. In this case, the cycle will be later detected and deleted by the cyclic garbage
collector. A common cause of reference cycles is when an exception has been caught in a local variable. The
frame’s locals then reference the exception, which references its own traceback, which references the locals of
all frames caught in the traceback.

µ Voir aussi

Documentation du module gc.

Á Avertissement

en raison des conditions particuliè res qui rè gnent quand __del__() est appelé e, les exceptions levé es
pendant son exé cution sont ignoré es et, à la place, un avertissement est affiché sur [Link]. En par-
ticulier :
— __del__() peut ê tre invoqué e quand du code arbitraire est en cours d’exé cution, et ce dans n’im-
porte quel fil d’exé cution. Si __del__() a besoin de poser un verrou ou d’accé der à tout autre
ressource bloquante, elle peut provoquer un blocage mutuel (deadlock en anglais) car la ressource
peut ê tre dé jà utilisé e par le code qui est interrompu pour exé cuter la mé thode __del__().
— __del__() peut ê tre exé cuté e pendant que l’interpré teur se ferme. En consé quence, les variables
globales auxquelles elle souhaite accé der (y compris les autres modules) peuvent dé jà ê tre dé truites
ou assigné es à None. Python garantit que les variables globales dont le nom commence par un
tiret bas sont supprimé es de leur module avant que les autres variables globales ne le soient ; si
aucune autre ré fé rence vers ces variables globales n’existe, cela peut aider à s’assurer que les modules
importé s soient toujours accessibles au moment où la mé thode __del__() est appelé e.

object.__repr__(self )
Appelé e par la fonction native repr() pour calculer la repré sentation « officielle » en chaîne de caractè res
d’un objet. Tout est fait pour que celle-ci ressemble à une expression Python valide pouvant ê tre utilisé e pour
recré er un objet avec la mê me valeur (dans un environnement donné ). Si ce n’est pas possible, une chaîne
de la forme <…une description utile…> est renvoyé e. La valeur renvoyé e doit ê tre un objet chaîne de
caractè res. Si une classe dé finit __repr__() mais pas __str__(), alors __repr__() est aussi utilisé e quand
une repré sentation « informelle » en chaîne de caractè res est demandé e pour une instance de cette classe.
This is typically used for debugging, so it is important that the representation is information-rich and unambi-
guous. A default implementation is provided by the object class itself.
object.__str__(self )
Called by str(object), the default __format__() implementation, and the built-in function print(), to
compute the ”informal” or nicely printable string representation of an object. The return value must be a str
object.
Cette mé thode diffè re de object.__repr__() car il n’est pas attendu que __str__() renvoie une expres-
sion Python valide : une repré sentation plus agré able à lire ou plus concise peut ê tre utilisé e.
L’implé mentation par dé faut du type natif object appelle object.__repr__() .
object.__bytes__(self )
Called by bytes to compute a byte-string representation of an object. This should return a bytes object. The

36 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

object class itself does not provide this method.

object.__format__(self, format_spec)
Appelé e par la fonction native format() et, par extension, lors de l’é valuation de chaînes de caractères littérales
formatées et la mé thode [Link](). Elle produit une chaîne de caractè res « formaté e » repré sentant un
objet. L’argument format_spec est une chaîne de caractè res contenant la description des options de forma-
tage voulues. L’interpré tation de l’argument format_spec est laissé e au type implé mentant __format__().
Cependant, la plupart des classes dé lè guent le formatage aux types natifs ou utilisent une syntaxe similaire
pour les options de formatage.
Lisez formatspec pour une description de la syntaxe standard du formatage.
La valeur renvoyé e doit ê tre un objet chaîne de caractè res.
The default implementation by the object class should be given an empty format_spec string. It delegates to
__str__().
Modifié dans la version 3.4 : la mé thode __format__ de object lui-mê me lè ve une TypeError si vous lui
passez une chaîne non vide.
Modifié dans la version 3.7 : object.__format__(x, '') est maintenant é quivalent à str(x) plutô t qu’à
format(str(x), '').

object.__lt__(self, other)
object.__le__(self, other)
object.__eq__(self, other)
object.__ne__(self, other)
object.__gt__(self, other)
object.__ge__(self, other)
Ce sont les mé thodes dites de « comparaisons riches ». La correspondance entre les symboles opé rateurs et les
noms de mé thodes est la suivante : x<y appelle x.__lt__(y), x<=y appelle x.__le__(y), x==y appelle
x.__eq__(y), x!=y appelle x.__ne__(y), x>y appelle x.__gt__(y) et x>=y appelle x.__ge__(y).
A rich comparison method may return the singleton NotImplemented if it does not implement the operation
for a given pair of arguments. By convention, False and True are returned for a successful comparison.
However, these methods can return any value, so if the comparison operator is used in a Boolean context (e.g.,
in the condition of an if statement), Python will call bool() on the value to determine if the result is true or
false.
By default, object implements __eq__() by using is, returning NotImplemented in the case of a
false comparison : True if x is y else NotImplemented. For __ne__(), by default it delegates to
__eq__() and inverts the result unless it is NotImplemented. There are no other implied relationships
among the comparison operators or default implementations ; for example, the truth of (x<y or x==y) does
not imply x<=y. To automatically generate ordering operations from a single root operation, see functools.
total_ordering().
By default, the object class provides implementations consistent with Comparaisons de valeurs : equality
compares according to object identity, and order comparisons raise TypeError. Each default method may
generate these results directly, but may also return NotImplemented.
Lisez le paragraphe __hash__() pour connaître certaines notions importantes relatives à la cré ation d’objets
hachables qui acceptent les opé rations de comparaison personnalisé es et qui sont utilisables en tant que clé s
de dictionnaires.
There are no swapped-argument versions of these methods (to be used when the left argument does not sup-
port the operation but the right argument does) ; rather, __lt__() and __gt__() are each other’s reflection,
__le__() and __ge__() are each other’s reflection, and __eq__() and __ne__() are their own reflection.
If the operands are of different types, and the right operand’s type is a direct or indirect subclass of the left
operand’s type, the reflected method of the right operand has priority, otherwise the left operand’s method has
priority. Virtual subclassing is not considered.
When no appropriate method returns any value other than NotImplemented, the == and != operators will
fall back to is and is not, respectively.

3.3. Méthodes spéciales 37

The Python Language Reference, Version 3.13.7

object.__hash__(self )
Appelé e par la fonction native hash() et par les opé rations sur les membres de collections haché es (ce qui
comprend set, frozenset et dict). La mé thode __hash__() doit renvoyer un entier. La seule proprié té
requise est que les objets qui sont é gaux pour la comparaison doivent avoir la mê me valeur de hachage ; il est
conseillé de mé langer les valeurs de hachage des composants d’un objet qui jouent un rô le dans la comparaison
des objets, en les emballant dans un n-uplet dont on calcule l’empreinte. Par exemple :

def __hash__(self):
return hash(([Link], [Link], [Link]))

® Note

hash() limite la valeur renvoyé e d’un objet ayant une mé thode __hash__() personnalisé e à la taille d’un
Py_ssize_t. C’est classiquement 8 octets pour une implé mentation 64 bits et 4 octets sur une implé men-
tation 32 bits. Si la mé thode __hash__() d’un objet doit ê tre interopé rable sur des plateformes ayant
des implé mentations diffé rentes, assurez-vous de vé rifier la taille du hachage sur toutes les plateformes.
Une maniè re facile de le faire est la suivante : python -c "import sys; print(sys.hash_info.
width)".

If a class does not define an __eq__() method it should not define a __hash__() operation either ; if it
defines __eq__() but not __hash__(), its instances will not be usable as items in hashable collections. If a
class defines mutable objects and implements an __eq__() method, it should not implement __hash__(),
since the implementation of hashable collections requires that a key’s hash value is immutable (if the object’s
hash value changes, it will be in the wrong hash bucket).
User-defined classes have __eq__() and __hash__() methods by default (inherited from the object class) ;
with them, all objects compare unequal (except with themselves) and x.__hash__() returns an appropriate
value such that x == y implies both that x is y and hash(x) == hash(y).
Une classe qui surcharge __eq__() et qui ne dé finit pas __hash__() a sa mé thode __hash__() implici-
tement assigné e à None. Quand la mé thode __hash__() d’une classe est None, une instance de cette classe
lè ve TypeError quand un programme essaie de demander son empreinte et elle est correctement identifié e
comme non hachable quand on vé rifie isinstance(obj, [Link]).
Si une classe qui surcharge __eq__() a besoin de conserver l’implé mentation de __hash__() de la classe pa-
rente, vous devez l’indiquer explicitement à l’interpré teur en dé finissant __hash__ = <ClasseParente>.
__hash__.
Si une classe ne surcharge pas __eq__() et veut supprimer le calcul des empreintes, elle doit inclure
__hash__ = None dans la dé finition de la classe. Une classe qui dé finit sa propre mé thode __hash__()
qui lè ve explicitement TypeError serait incorrectement identifié e comme hachable par un appel à
isinstance(obj, [Link]).

® Note

par dé faut, les valeurs renvoyé es par __hash__() pour les chaînes et les bytes sont « salé es » avec une
valeur alé atoire non pré visible. Bien qu’une empreinte reste constante tout au long d’un processus Python,
sa valeur n’est pas pré visible entre deux invocations de Python.
This is intended to provide protection against a denial-of-service caused by carefully chosen inputs that
exploit the worst case performance of a dict insertion, O(n2 ) complexity. See [Link]
[Link] for details.
Modifier les empreintes obtenues par hachage modifie l’ordre d’ité ration sur les sets. Python n’a jamais
donné de garantie sur cet ordre (d’ailleurs, l’ordre n’est pas le mê me entre les implé mentations 32 et 64
bits).
Voir aussi PYTHONHASHSEED.

38 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

Modifié dans la version 3.3 : la randomisation des empreintes est activé e par dé faut.
object.__bool__(self )
Called to implement truth value testing and the built-in operation bool() ; should return False or True.
When this method is not defined, __len__() is called, if it is defined, and the object is considered true if its
result is nonzero. If a class defines neither __len__() nor __bool__() (which is true of the object class
itself), all its instances are considered true.

3.3.2 Personnalisation de l’accès aux attributs

Les mé thodes suivantes peuvent ê tre dé finies pour personnaliser l’accè s aux attributs (utilisation, assignation, sup-
pression de [Link]) pour les instances de classes.
object.__getattr__(self, name)
Called when the default attribute access fails with an AttributeError (either __getattribute__() raises
an AttributeError because name is not an instance attribute or an attribute in the class tree for self ; or
__get__() of a name property raises AttributeError). This method should either return the (computed)
attribute value or raise an AttributeError exception. The object class itself does not provide this method.
Note that if the attribute is found through the normal mechanism, __getattr__() is not called. (This is
an intentional asymmetry between __getattr__() and __setattr__().) This is done both for efficiency
reasons and because otherwise __getattr__() would have no way to access other attributes of the instance.
Note that at least for instance variables, you can take total control by not inserting any values in the instance
attribute dictionary (but instead inserting them in another object). See the __getattribute__() method
below for a way to actually get total control over attribute access.
object.__getattribute__(self, name)
Appelé e de maniè re inconditionnelle pour implé menter l’accè s aux attributs des instances de la
classe. Si la classe dé finit é galement __getattr__(), cette derniè re n’est pas appelé e à moins que
__getattribute__() ne l’appelle explicitement ou ne lè ve une exception AttributeError. Cette mé -
thode doit renvoyer la valeur (calculé e) de l’attribut ou lever une exception AttributeError. Afin d’é viter
une ré cursion infinie sur cette mé thode, son implé mentation doit toujours appeler la mé thode de la classe de
base avec le mê me paramè tre name pour accé der à n’importe quel attribut dont elle a besoin. Par exemple,
object.__getattribute__(self, name).

® Note

This method may still be bypassed when looking up special methods as the result of implicit invocation via
language syntax or built-in functions. See Recherche des méthodes spéciales.

Pour les accè s à certains attributs sensibles, lè ve un é vé nement d’audit object.__getattr__ avec les argu-
ments obj et name.
object.__setattr__(self, name, value)
Appelé e lors d’une assignation d’attribut. Elle est appelé e à la place du mé canisme normal (c’est-à -dire stocker
la valeur dans le dictionnaire de l’instance). name est le nom de l’attribut, value est la valeur à assigner à cet
attribut.
Si __setattr__() veut assigner un attribut d’instance, elle doit appeler la mé thode de la classe de base avec
le mê me nom, par exemple object.__setattr__(self, name, value).
Pour les assignations de certains attributs sensibles, lè ve un é vé nement d’audit object.__setattr__ avec
les arguments obj, name et value.
object.__delattr__(self, name)
Comme __setattr__() mais pour supprimer un attribut au lieu de l’assigner. Elle ne doit ê tre implé menté e
que si del [Link] a du sens pour cet objet.
Pour les suppressions de certains attributs sensibles, lè ve un é vé nement d’audit object.__deltattr__ avec
les arguments obj et name.

3.3. Méthodes spéciales 39

The Python Language Reference, Version 3.13.7

object.__dir__(self )
Called when dir() is called on the object. An iterable must be returned. dir() converts the returned iterable
to a list and sorts it.

Personnalisation de l’accès aux attributs d’un module

module.__getattr__()
module.__dir__()

Les noms spé ciaux __getattr__ et __dir__ peuvent aussi ê tre personnalisé s pour accé der aux attributs du module.
La fonction __getattr__ au niveau du module doit accepter un argument qui est un nom d’attribut et doit renvoyer
la valeur calculé e ou lever une AttributeError. Si un attribut n’est pas trouvé dans l’objet module en utilisant
la recherche normale, c’est-à -dire object.__getattribute__(), alors Python recherche __getattr__ dans le
__dict__ du module avant de lever une AttributeError. S’il la trouve, il l’appelle avec le nom de l’attribut et
renvoie le ré sultat.
The __dir__ function should accept no arguments, and return an iterable of strings that represents the names ac-
cessible on module. If present, this function overrides the standard dir() search on a module.
module.__class__

Pour une personnalisation plus fine du comportement d’un module (assignation des attributs, proprié té s, etc.), vous
pouvez assigner l’attribut __class__ d’un objet module à une sous-classe de [Link]. Par exemple :
import sys
from types import ModuleType

class VerboseModule(ModuleType):
def __repr__(self):
return f'Verbose {self.__name__}'

def __setattr__(self, attr, value):

print(f'Setting {attr}...')
super().__setattr__(attr, value)

[Link][__name__].__class__ = VerboseModule

® Note

dé finir __getattr__ du module et __class__ pour le module impacte uniquement les recherches qui utilisent
la syntaxe d’accè s aux attributs — accé der directement aux globales d’un module (soit par le code dans le module,
soit via une ré fé rence au dictionnaire des variables globales du module) fonctionne toujours de la mê me façon.

Modifié dans la version 3.5 : l’attribut __class__ du module est maintenant en lecture-é criture.
Ajouté dans la version 3.7 : attributs __getattr__ et __dir__ du module.

µ Voir aussi

PEP 562 — __getattr__ et __dir__ pour un module

Dé crit les fonctions __getattr__ et __dir__ des modules.

Implémentation de descripteurs
The following methods only apply when an instance of the class containing the method (a so-called descriptor class)
appears in an owner class (the descriptor must be in either the owner’s class dictionary or in the class dictionary for
one of its parents). In the examples below, ”the attribute” refers to the attribute whose name is the key of the property
in the owner class’ __dict__. The object class itself does not implement any of these protocols.

40 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

object.__get__(self, instance, owner=None)

Appelé e pour obtenir l’attribut de la classe proprié taire (accè s à un attribut de classe) ou d’une instance de cette
classe (accè s à un attribut d’instance). L’argument optionnel owner est la classe proprié taire alors que instance
est l’instance par laquelle on accè de à l’attribut ou None lorsque l’on accè de par la classe owner.
Il convient que cette mé thode renvoie la valeur calculé e de l’attribut ou lè ve une exception AttributeError.
La PEP 252 spé cifie que __get__() soit un appelable avec un ou deux arguments. Les descripteurs natifs
de Python suivent cette spé cification ; cependant, il est probable que des outils tiers aient des descripteurs qui
requiè rent les deux arguments. L’implé mentation de __getattribute__() de Python passe toujours les
deux arguments, qu’ils soient requis ou non.
object.__set__(self, instance, value)
Appelé e pour dé finir l’attribut d’une instance instance de la classe proprié taire à la nouvelle valeur value.
Notez que ajouter __set__() ou __delete__() modifie la nature du descripteur vers un « descripteur de
donné e ». Reportez-vous à Invocation des descripteurs pour plus de dé tails.
object.__delete__(self, instance)
Appelé e pour supprimer l’attribut de l’instance instance de la classe proprié taire.
Instances of descriptors may also have the __objclass__ attribute present :
object.__objclass__
The attribute __objclass__ is interpreted by the inspect module as specifying the class where this object
was defined (setting this appropriately can assist in runtime introspection of dynamic class attributes). For
callables, it may indicate that an instance of the given type (or a subclass) is expected or required as the first
positional argument (for example, CPython sets this attribute for unbound methods that are implemented in
C).

Invocation des descripteurs

En gé né ral, un descripteur est un attribut d’objet dont le comportement est « lié » (binding dehavior en anglais),
c’est-à -dire que les accè s aux attributs ont é té surchargé s par des mé thodes conformes au protocole des descripteurs :
__get__(), __set__() et __delete__(). Si l’une de ces mé thodes est dé finie pour un objet, il est ré puté ê tre
un descripteur.
Le comportement par dé faut pour la gestion d’un attribut est de dé finir, obtenir et supprimer cet attribut du dic-
tionnaire de l’objet. Par exemple, pour a.x Python commence d’abord par rechercher a.__dict__['x'], puis
type(a).__dict__['x'] ; ensuite Python continue en remontant les classes de base de type(a), en excluant les
mé taclasses.
Cependant, si la valeur cherché e est un objet qui dé finit une des mé thodes de descripteur, alors Python modifie son
comportement et invoque la mé thode du descripteur à la place. Le moment où cela intervient dans la recherche cité e
ci-dessus dé pend de l’endroit où a é té dé finie la mé thode de descripteur et comment elle a é té appelé e.
Le point de dé part pour une invocation de descripteur est la liaison a.x. La façon dont les arguments sont assemblé s
dé pend de a :
Appel direct
Le plus simple et le plus rare des appels est quand l’utilisateur code directement l’appel à la mé thode du
descripteur : x.__get__(a).
Liaison avec une instance
Si elle est lié e à un objet instance, a.x est transformé en l’appel suivant : type(a).__dict__['x'].
__get__(a, type(a)).
Liaison avec une classe
Si elle est lié e à une classe, A.x est transformé en l’appel suivant : A.__dict__['x'].__get__(None,
A).
Liaison super
Une recherche avec un point telle que super(A, a).x cherche a.__class__.__mro__ pour une classe
de base B qui suit (dans l’ordre MRO) A, puis renvoie B.__dict__['x'].__get__(a, A). Si ce n’est pas
un descripteur, x est renvoyé inchangé .

3.3. Méthodes spéciales 41

The Python Language Reference, Version 3.13.7

For instance bindings, the precedence of descriptor invocation depends on which descriptor methods are defined.
A descriptor can define any combination of __get__(), __set__() and __delete__(). If it does not define
__get__(), then accessing the attribute will return the descriptor object itself unless there is a value in the object’s
instance dictionary. If the descriptor defines __set__() and/or __delete__(), it is a data descriptor ; if it defines
neither, it is a non-data descriptor. Normally, data descriptors define both __get__() and __set__(), while non-
data descriptors have just the __get__() method. Data descriptors with __get__() and __set__() (and/or
__delete__()) defined always override a redefinition in an instance dictionary. In contrast, non-data descriptors
can be overridden by instances.
Les mé thodes Python (y compris celles dé coré es par @staticmethod et @classmethod) sont implé menté es
comme des descripteurs hors-donné es. De la mê me maniè re, les instances peuvent redé finir et surcharger les mé -
thodes. Ceci permet à chaque instance d’avoir un comportement qui diffè re des autres instances de la mê me classe.
La fonction property() est implé menté e en tant que descripteur de donné es. Ainsi, les instances ne peuvent pas
surcharger le comportement d’une proprié té .

créneaux prédéfinis (__slots__)

Les cré neaux pré dé finis (__slots__) vous permettent de dé clarer des membres d’une donné e (comme une proprié té )
et d’interdire la cré ation de __dict__ ou de __weakref__ (à moins qu’ils ne soient explicitement dé claré s dans le
__slots__ ou pré sent dans le parent).
L’espace gagné par rapport à l’utilisation d’un __dict__ peut ê tre significatif. La recherche d’attribut peut aussi
s’avé rer beaucoup plus rapide.
object.__slots__
Cette variable de classe peut ê tre assigné e avec une chaîne, un ité rable ou une sé quence de chaînes avec les
noms de variables utilisé s par les instances. __slots__ ré serve de la place pour ces variables dé claré es et interdit
la cré ation automatique de __dict__ et __weakref__ pour chaque instance.
Notes on using __slots__ :
— Lorsque vous hé ritez d’une classe sans __slots__, les attributs __dict__ et __weakref__ des instances sont
toujours accessibles.
— Sans variable __dict__, les instances ne peuvent pas assigner de nouvelles variables (non listé es dans la dé fi-
nition de __slots__). Les tentatives d’assignation sur un nom de variable non listé lè ve AttributeError. Si
l’assignation dynamique de nouvelles variables est né cessaire, ajoutez '__dict__' à la sé quence de chaînes
dans la dé claration __slots__.
— Sans variable __weakref__ pour chaque instance, les classes qui dé finissent __slots__ ne gè rent pas les
références faibles vers leurs instances. Si vous avez besoin de gé rer des ré fé rences faibles, ajoutez
'__weakref__' à la sé quence de chaînes dans la dé claration de __slots__.
— Les __slots__ sont implé menté s au niveau de la classe en cré ant des descripteurs pour chaque nom de variable.
Ainsi, les attributs de classe ne peuvent pas ê tre utilisé s pour des valeurs par dé faut aux variables d’instances
dé finies par __slots__ ; sinon, l’attribut de classe surchargerait l’assignation par descripteur.
— The action of a __slots__ declaration is not limited to the class where it is defined. __slots__ declared in parents
are available in child classes. However, instances of a child subclass will get a __dict__ and __weakref__
unless the subclass also defines __slots__ (which should only contain names of any additional slots).
— Si une classe dé finit un slot dé jà dé fini dans une classe de base, la variable d’instance dé finie par la classe de
base est inaccessible (sauf à utiliser le descripteur de la classe de base directement). Cela rend la signification
du programme indé finie. Dans le futur, une vé rification sera ajouté e pour empê cher cela.
— TypeError will be raised if nonempty __slots__ are defined for a class derived from a "variable-length"
built-in type such as int, bytes, and tuple.
— Tout itérable, sauf les chaînes de caractè res, peuvent ê tre affecté s à __slots__.
— Si vous affectez __slots__ à un dictionnaire, les clé s du dictionnaires seront les noms du slot. Les valeurs
du dictionnaire peuvent ê tre utilisé es en tant que chaines de description (docstrings) et sont reconnues par
[Link]() qui les affiche dans la sortie de help().
— __class__ assignment works only if both classes have the same __slots__.
— L’hé ritage multiple avec plusieurs classes parentes qui ont des __slots__ est possible, mais seul un parent
peut avoir des attributs cré és par __slots__ (les autres classes parentes doivent avoir des __slots__ vides). La
violation de cette rè gle lè ve TypeError.
— Si un itérateur est utilisé pour __slots__, alors un descripteur est cré é pour chacune des valeurs de l’ité rateur.
Cependant, l’attribut __slots__ est un ité rateur vide.

42 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

3.3.3 Personnalisation de la création de classes

Quand une classe hé rite d’une classe parente, la mé thode __init_subclass__() de la classe parente est appelé e.
Ainsi, il est possible d’é crire des classes qui modifient le comportement des sous-classes. Ce comportement est corré lé
aux dé corateurs de classes mais, alors que les dé corateurs de classes agissent seulement sur la classe qu’ils dé corent,
__init_subclass__ agit uniquement sur les futures sous-classes de la classe qui dé finit cette mé thode.

classmethod object.__init_subclass__(cls)
Cette mé thode est appelé e quand la classe est sous-classé e. cls est alors la nouvelle sous-classe. Si elle est dé finie
en tant que mé thode d’instance normale, cette mé thode est implicitement convertie en mé thode de classe.
Keyword arguments which are given to a new class are passed to the parent class’s __init_subclass__.
For compatibility with other classes using __init_subclass__, one should take out the needed keyword
arguments and pass the others over to the base class, as in :

class Philosopher:
def __init_subclass__(cls, /, default_name, **kwargs):
super().__init_subclass__(**kwargs)
cls.default_name = default_name

class AustralianPhilosopher(Philosopher, default_name="Bruce"):

pass

L’implé mentation par dé faut de object.__init_subclass__ ne fait rien sans argument, mais lè ve une
erreur si elle est appelé e avec un argument ou plus.

® Note

l’indication de mé taclasse metaclass est absorbé e par le reste du mé canisme de types et n’est jamais pas-
sé e à l’implé mentation de __init_subclass__. La mé taclasse ré elle (plutô t que l’indication explicite)
peut ê tre ré cupé ré e par type(cls).

Ajouté dans la version 3.6.

Lorsqu’une classe est cré ée, type.__new__() exé cute le point d’entré e ___set_name__() de toute variable de la
classe qui en possè de un.
object.__set_name__(self, owner, name)
Appelé e automatiquement au moment où la classe proprié taire owner est cré ée. L’objet self a é té assigné à
name dans owner :

class A:
x = C() # Automatically calls: x.__set_name__(A, 'x')

Si l’affectation se produit aprè s la cré ation de la classe, le point d’entré e __set_name__() n’est pas appelé
automatiquement. Mais il est autorisé d’appeler __set_name__() manuellement :

class A:
pass

c = C()
A.x = c # The hook is not called
c.__set_name__(A, 'x') # Manually invoke the hook

Consultez Création de l’objet classe pour davantage de dé tails.

Ajouté dans la version 3.6.

3.3. Méthodes spéciales 43

The Python Language Reference, Version 3.13.7

Métaclasses
Par dé faut, les classes sont construites en utilisant type(). Le corps de la classe est exé cuté dans un nouvel espace
de nommage et le nom de la classe est lié localement au ré sultat de type(name, bases, namespace).
Le dé roulement de cré ation de la classe peut ê tre personnalisé en passant l’argument nommé metaclass dans la ligne
de dé finition de la classe ou en hé ritant d’une classe existante qui comporte dé jà un tel argument. Dans l’exemple qui
suit, MyClass et MySubclass sont des instances de Meta :

class Meta(type):
pass

class MyClass(metaclass=Meta):
pass

class MySubclass(MyClass):
pass

Tout autre argument nommé spé cifié dans la dé finition de la classe est passé aux opé rations de mé taclasses dé crites
auparavant.
Quand la dé finition d’une classe est exé cuté e, les diffé rentes é tapes suivies sont :
— les entré es MRO sont ré solues ;
— la mé taclasse approprié e est dé terminé e ;
— l’espace de nommage de la classe est pré paré ;
— le corps de la classe est exé cuté ;
— l’objet classe est cré é.

Résolution des entrées MRO

object.__mro_entries__(self, bases)
If a base that appears in a class definition is not an instance of type, then an __mro_entries__() method
is searched on the base. If an __mro_entries__() method is found, the base is substituted with the result
of a call to __mro_entries__() when creating the class. The method is called with the original bases tuple
passed to the bases parameter, and must return a tuple of classes that will be used instead of the base. The
returned tuple may be empty : in these cases, the original base is ignored.

µ Voir aussi

types.resolve_bases()
Dynamically resolve bases that are not instances of type.
types.get_original_bases()
Retrieve a class’s ”original bases” prior to modifications by __mro_entries__().
PEP 560
Core support for typing module and generic types.

Détermination de la métaclasse appropriée

La mé taclasse approprié e pour une dé finition de classe est dé terminé e de la maniè re suivante :
— si aucune classe et aucune mé taclasse n’est donné e, alors type() est utilisé e ;
— si une mé taclasse explicite est donné e et que ce n’est pas une instance de type(), alors elle est utilisé e
directement en tant que mé taclasse ;
— si une instance de type() est donné e comme mé taclasse explicite ou si bases est dé finie, alors la mé taclasse
la plus dé rivé e est utilisé e.
La mé taclasse la plus dé rivé e est choisie à partir des mé taclasses explicitement spé cifié es (s’il y en a) et les mé taclasses
(c’est-à -dire les type(cls)) de toutes les classes de base spé cifié es. La mé taclasse la plus dé rivé e est celle qui est
un sous-type de toutes ces mé taclasses candidates. Si aucune des mé taclasses candidates ne remplit ce critè re, alors
la dé finition de la classe é choue en levant TypeError.

44 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

Préparation de l’espace de nommage de la classe

Une fois que la mé taclasse approprié e est identifié e, l’espace de nommage de la classe est pré paré . Si la mé taclasse
possè de un attribut __prepare__, il est appelé avec namespace = metaclass.__prepare__(name, bases,
**kwds) (où les arguments nommé s supplé mentaires, s’il y en a, sont les arguments de la dé finition de la classe). La
mé thode __prepare__ doit ê tre implé menté e comme une méthode de classe). L’espace de nommage renvoyé
par __prepare__ est passé à __new__, mais quand l’instance finale est cré ée, l’espace de nommage est copié vers
un nouveau dict.
Si la mé taclasse ne possè de pas d’attribut __prepare__, alors l’espace de nommage de la classe est initialisé en tant
que tableau de correspondances ordonné .

µ Voir aussi

PEP 3115 — Métaclasses dans Python 3000

introduction de la fonction automatique __prepare__ de l’espace de nommage

Exécution du corps de la classe

Le corps de la classe est exé cuté (approximativement) avec exec(body, globals(), namespace). La princi-
pale diffé rence avec un appel normal à exec() est que la porté e lexicale autorise le corps de la classe (y compris les
mé thodes) à faire ré fé rence aux noms de la porté e courante et des porté es externes lorsque la dé finition de classe a
lieu dans une fonction.
Cependant, mê me quand une dé finition de classe intervient dans une fonction, les mé thodes dé finies à l’inté rieur de
la classe ne peuvent pas voir les noms dé finis en dehors de la porté e de la classe. On accè de aux variables de la classe
via le premier paramè tre des mé thodes d’instance ou de classe, ou via la ré fé rence implicite __class__ incluse dans
la porté e lexicale et dé crite dans la section suivante.

Création de l’objet classe

Quand l’espace de nommage a é té rempli en exé cutant le corps de la classe, l’objet classe est cré é en appelant
metaclass(name, bases, namespace, **kwds) (les arguments nommé s supplé mentaires passé s ici sont les
mê mes que ceux passé s à __prepare__).
Cet objet classe est celui qui est ré fé rencé par la forme sans argument de super(). __class__ est une ré fé rence
implicite cré ée par le compilateur si une mé thode du corps de la classe fait ré fé rence soit à __class__, soit à super.
Ceci permet que la forme sans argument de super() identifie la classe en cours de dé finition en fonction de la porté e
lexicale, tandis que la classe ou l’instance utilisé e pour effectuer l’appel en cours est identifié e en fonction du premier
argument transmis à la mé thode.
dans CPython 3.6 et suivants, la cellule __class__ est passé e à la mé taclasse en tant qu’entré e __classcell__
dans l’espace de nommage de la classe. Si elle est pré sente, elle doit ê tre propagé e à l’appel type.__new__ pour que
la classe soit correctement initialisé e. Ne pas le faire se traduit par un RuntimeError dans Python 3.8.
Quand vous utilisez la mé taclasse par dé faut type ou toute autre mé taclasse qui finit par appeler type.__new__,
les é tapes de personnalisation supplé mentaires suivantes sont suivies aprè s la cré ation de l’objet classe :
1) type.__new__ ré cupè re, dans l’espace de nommage de la classe, tous les descripteurs qui dé finissent une
mé thode __set_name__() ;
2) Toutes ces mé thodes __set_name__ sont appelé es avec la classe en cours de dé finition et le nom assigné à
chaque descripteur ;
3) La mé thode automatique __init_subclass__() est appelé e sur le parent immé diat de la nouvelle classe
en utilisant l’ordre de ré solution des mé thodes.
Aprè s la cré ation de l’objet classe, il est passé aux dé corateurs de la classe, y compris ceux inclus dans la dé finition
de la classe (s’il y en a) et l’objet ré sultant est lié à l’espace de nommage local en tant que classe dé finie.
When a new class is created by type.__new__, the object provided as the namespace parameter is copied to a new
ordered mapping and the original object is discarded. The new copy is wrapped in a read-only proxy, which becomes
the __dict__ attribute of the class object.

3.3. Méthodes spéciales 45

The Python Language Reference, Version 3.13.7

µ Voir aussi

PEP 3135 — Nouvelle méthode super

Dé crit la ré fé rence à la fermeture (closure en anglais) de la __class__ implicite

Cas d’utilisations des métaclasses

Les utilisations possibles des mé taclasses sont immenses. Quelques pistes ont dé jà é té exploré es comme l’é numé ra-
tion, la gestion des traces, le contrô le des interfaces, la dé lé gation automatique, la cré ation automatique de proprié té s,
les mandataires, les frameworks ainsi que le verrouillage ou la synchronisation automatique de ressources.

3.3.4 Personnalisation des instances et vérification des sous-classes

Les mé thodes suivantes sont utilisé es pour surcharger le comportement par dé faut des fonctions natives
isinstance() et issubclass().

En particulier, la mé taclasse [Link] implé mente ces mé thodes pour autoriser l’ajout de classes de base abs-
traites (ABC pour Abstract Base Classes en anglais) en tant que « classes de base virtuelles » pour toute classe ou
type (y compris les types natifs).
type.__instancecheck__(self, instance)
Renvoie True si instance doit ê tre considé ré e comme une instance (directe ou indirecte) de class. Si elle est
dé finie, elle est appelé e pour implé menter isinstance(instance, class).
type.__subclasscheck__(self, subclass)
Renvoie True si subclass doit ê tre considé ré e comme une sous-classe (directe ou indirecte) de class. Si elle est
dé finie, appelé e pour implé menter issubclass(subclass, class).
Notez que ces mé thodes sont recherché es dans le type (la mé taclasse) d’une classe. Elles ne peuvent pas ê tre dé finies
en tant que mé thodes de classe dans la classe ré elle. C’est cohé rent avec la recherche des mé thodes spé ciales qui sont
appelé es pour les instances, sauf qu’ici l’instance est elle-mê me une classe.

µ Voir aussi

PEP 3119 — Introduction aux classes de bases abstraites

Includes the specification for customizing isinstance() and issubclass() behavior through
__instancecheck__() and __subclasscheck__(), with motivation for this functionality in the
context of adding Abstract Base Classes (see the abc module) to the language.

3.3.5 Émulation de types génériques

Lors de l’utilisation d’annotations de types, il est souvent utile de paramètrer un type générique en se servant de la
notation crochets de Python. Par exemple, l’annotation list[int] peut ê tre utilisé e pour signifier une liste dans
laquelle tous les é lé ments sont de type entiers.

µ Voir aussi

PEP 343 — Indications de types

Introduction à l’annotation de types en Python (document en anglais)
Types alias génériques
Documentation pour les objets qui repré sentent des classes gé né riques paramé tré es
Generics, Types génériques définis par l’utilisateur et classe [Link] (classe de base
abstraite pour les types génériques)
Documentation sur la maniè re d’implé menter des classes gé né riques qui peuvent ê tre paramé tré es à l’exé -
cution et comprises par les vé rificateurs statiques de types.

46 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

Généralement, une classe ne peut ê tre paramé tré e que si elle dé finit une mé thode spé ciale de classe
__class_getitem__().

classmethod object.__class_getitem__(cls, key)

Renvoie un objet repré sentant la spé cialisation d’une classe gé né rique en fonction des arguments types trouvé s
dans key.
Lorsqu’elle est dé finie dans une classe, __class_getitem__() est automatiquement une mé thode de classe.
Ainsi, il est superflu de la dé corer avec @classmethod lors de sa dé finition.

Intention de __class_getitem__
Le but de __class_getitem__() est de permettre la paramé trisation à l’exé cution des classes gé né riques de la
bibliothè que standard de façon à pouvoir appliquer plus facilement des annotations de type à ces classes.
Pour implé menter des classes gé né riques particularisé es pouvant ê tre paramé tré es à l’exé cution, et comprises
par les vé rificateurs statiques de type, vous pouvez soit hé riter d’une classe de la bibliothè que standard qui im-
plé mente dé jà __class_getitem__(), ou hé riter de [Link], qui a sa propre implé mentation de
__class_getitem__().
Les implé mentations particularisé es de __class_getitem__() sur des classes dé finies ailleurs que la biblio-
thè que standard peuvent ne pas ê tre comprises par des vé rificateurs de types tiers tels que mypy. L’utilisation de
__class_getitem__() pour tout autre objectif que l’annotation de type n’est pas conseillé e.

__class_getitem__ contre __getitem__

D’habitude, l’indiçage d’un objet en utilisant des crochets appelle la mé thode __getitem__() de l’instance, dé finie
dans la classe de l’objet. Cependant, si l’objet dont on cherche un indice est lui-mê me une classe, la mé thode de classe
__class_getitem__() peut ê tre appelé e à la place. __class_getitem__() doit renvoyer un objet GenericAlias
si elle est correctement dé finie.
Lorsqu’on lui pré sente l’expression obj[x], l’interpré teur Python suit une sorte de processus suivant pour dé cider s’il
faut appeler __getitem__() ou __class_getitem__() :

from inspect import isclass

def subscribe(obj, x):

"""Return the result of the expression 'obj[x]'"""

class_of_obj = type(obj)

# If the class of obj defines __getitem__,

# call class_of_obj.__getitem__(obj, x)
if hasattr(class_of_obj, '__getitem__'):
return class_of_obj.__getitem__(obj, x)

# Else, if obj is a class and defines __class_getitem__,

# call obj.__class_getitem__(x)
elif isclass(obj) and hasattr(obj, '__class_getitem__'):
return obj.__class_getitem__(x)

# Else, raise an exception

else:
raise TypeError(
f"'{class_of_obj.__name__}' object is not subscriptable"
)

En Python, toutes les classes sont des instances d’autres classes. La classe d’une classe est appelé e la métaclasse de la
classe et la plupart des classes ont la classe type comme mé taclasse. type ne dé finit pas __getitem__(), ce qui
veut dire que des expressions telles que list[int], dict[str, float] et tuple[str, bytes] aboutissent
toutes à l’appel de __class_getitem__() :

3.3. Méthodes spéciales 47

The Python Language Reference, Version 3.13.7

>>> # list has class "type" as its metaclass, like most classes:
>>> type(list)
<class 'type'>
>>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)
True
>>> # "list[int]" calls "list.__class_getitem__(int)"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type(list[int])
<class '[Link]'>

Cependant, si une classe a une mé taclasse particularisé e qui dé finit __getitem__(), l’indiçage de la classe peut
conduire à un comportement diffé rent. Un exemple peut ê tre trouvé dans le module enum :

>>> from enum import Enum

>>> class Menu(Enum):
... """A breakfast menu"""
... SPAM = 'spam'
... BACON = 'bacon'
...
>>> # Enum classes have a custom metaclass:
>>> type(Menu)
<class '[Link]'>
>>> # EnumMeta defines __getitem__,
>>> # so __class_getitem__ is not called,
>>> # and the result is not a GenericAlias object:
>>> Menu['SPAM']
<[Link]: 'spam'>
>>> type(Menu['SPAM'])
<enum 'Menu'>

µ Voir aussi

PEP 560 — Gestion de base pour les types modules et les types génériques
Introduction de __class_getitem__(), et pré sentation des cas où un indiçage conduit à l’appel de
__class_getitem__() au lieu de __getitem__()

3.3.6 Émulation d’objets appelables

[
object.__call__(self , args... ) ]
Called when the instance is ”called” as a function ; if this method is defined, x(arg1, arg2, ...) roughly
translates to type(x).__call__(x, arg1, ...). The object class itself does not provide this method.

3.3.7 Émulation de types conteneurs

The following methods can be defined to implement container objects. None of them are provided by the object
class itself. Containers usually are sequences (such as lists or tuples) or mappings (like dictionaries), but can
represent other containers as well. The first set of methods is used either to emulate a sequence or to emulate a
mapping ; the difference is that for a sequence, the allowable keys should be the integers k for which 0 <= k < N
where N is the length of the sequence, or slice objects, which define a range of items. It is also recommended
that mappings provide the methods keys(), values(), items(), get(), clear(), setdefault(), pop(),
popitem(), copy(), and update() behaving similar to those for Python’s standard dictionary objects. The
[Link] module provides a MutableMapping abstract base class to help create those methods from a
base set of __getitem__(), __setitem__(), __delitem__(), and keys(). Mutable sequences should provide

48 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

methods append(), count(), index(), extend(), insert(), pop(), remove(), reverse() and sort(),
like Python standard list objects. Finally, sequence types should implement addition (meaning concatenation) and
multiplication (meaning repetition) by defining the methods __add__(), __radd__(), __iadd__(), __mul__(),
__rmul__() and __imul__() described below ; they should not define other numerical operators. It is recommen-
ded that both mappings and sequences implement the __contains__() method to allow efficient use of the in
operator ; for mappings, in should search the mapping’s keys ; for sequences, it should search through the values. It
is further recommended that both mappings and sequences implement the __iter__() method to allow efficient
iteration through the container ; for mappings, __iter__() should iterate through the object’s keys ; for sequences,
it should iterate through the values.
object.__len__(self )
Called to implement the built-in function len(). Should return the length of the object, an integer >= 0. Also,
an object that doesn’t define a __bool__() method and whose __len__() method returns zero is considered
to be false in a Boolean context.
Particularité de l’implémentation CPython : In CPython, the length is required to be at most [Link].
If the length is larger than [Link] some features (such as len()) may raise OverflowError. To
prevent raising OverflowError by truth value testing, an object must define a __bool__() method.
object.__length_hint__(self )
Called to implement operator.length_hint(). Should return an estimated length for the object (which
may be greater or less than the actual length). The length must be an integer >= 0. The return value may also
be NotImplemented, which is treated the same as if the __length_hint__ method didn’t exist at all. This
method is purely an optimization and is never required for correctness.
Ajouté dans la version 3.4.

® Note

le dé coupage est effectué uniquement à l’aide des trois mé thodes suivantes. Un appel comme
a[1:2] = b

est traduit en
a[slice(1, 2, None)] = b

et ainsi de suite. Les é lé ments manquants sont remplacé s par None.

object.__getitem__(self, key)
Called to implement evaluation of self[key]. For sequence types, the accepted keys should be integers.
Optionally, they may support slice objects as well. Negative index support is also optional. If key is of an
inappropriate type, TypeError may be raised ; if key is a value outside the set of indexes for the sequence
(after any special interpretation of negative values), IndexError should be raised. For mapping types, if key
is missing (not in the container), KeyError should be raised.

® Note

for s’attend à ce qu’une IndexError soit levé e en cas d’indice illé gal afin de dé tecter correctement la fin
de la sé quence.

® Note

quand on vous spécifiez un indice pour une classe, la mé thode de classe spé ciale __class_getitem__()
peut ê tre appelé e au lieu de __getitem__(). Reportez-vous à __class_getitem__ contre __getitem__ pour
plus de dé tails.

object.__setitem__(self, key, value)

3.3. Méthodes spéciales 49

The Python Language Reference, Version 3.13.7

Appelé e pour implé menter l’assignation à self[key]. La mê me note que pour __getitem__() s’applique.
Elle ne doit ê tre implé menté e que pour les tableaux de correspondances qui autorisent les modifications de
valeurs des clé s, ceux pour lesquels on peut ajouter de nouvelles clé s ou, pour les sé quences, celles dont les
é lé ments peuvent ê tre remplacé s. Les mê mes exceptions que pour la mé thode __getitem__() doivent ê tre
levé es en cas de mauvaises valeurs de clé s.
object.__delitem__(self, key)
Appelé e pour implé menter la suppression de self[key]. La mê me note que pour __getitem__() s’ap-
plique. Elle ne doit ê tre implé menté e que pour les tableaux de correspondances qui autorisent les suppressions
de clé s ou pour les sé quences dont les é lé ments peuvent ê tre supprimé s de la sé quence. Les mê mes exceptions
que pour la mé thode __getitem__() doivent ê tre levé es en cas de mauvaises valeurs de clé s.
object.__missing__(self, key)
Appelé e par dict.__getitem__() pour implé menter self[key] dans les sous-classes de dictionnaires
lorsque la clé n’est pas dans le dictionnaire.
object.__iter__(self )
Cette mé thode est appelé e quand un itérateur est requis pour un conteneur. Cette mé thode doit renvoyer un
nouvel objet ité rateur qui peut ité rer sur tous les objets du conteneur. Pour les tableaux de correspondances,
elle doit ité rer sur les clé s du conteneur.
object.__reversed__(self )
Appelé e (si elle existe) par la fonction native reversed() pour implé menter l’ité ration en sens inverse. Elle
doit renvoyer un nouvel objet ité rateur qui itè re sur tous les objets du conteneur en sens inverse.
Si la mé thode __reversed__() n’est pas fournie, la fonction native reversed() se replie sur le protocole de
sé quence (__len__() et __getitem__()). Les objets qui connaissent le protocole de sé quence ne doivent
fournir __reversed__() que si l’implé mentation qu’ils proposent est plus efficace que celle de reversed().
Les opé rateurs de tests d’appartenance (in et not in) sont normalement implé menté s comme des ité rations sur un
conteneur. Cependant, les objets conteneurs peuvent fournir les mé thodes spé ciales suivantes avec une implé menta-
tion plus efficace, qui ne requiè rent d’ailleurs pas que l’objet soit ité rable.
object.__contains__(self, item)
Appelé e pour implé menter les opé rateurs de test d’appartenance. Elle doit renvoyer True si item est dans self et
False sinon. Pour les tableaux de correspondances, seules les clé s sont considé ré es (pas les valeurs des paires
clé s-valeurs).
Pour les objets qui ne dé finissent pas __contains__(), les tests d’appartenance essaient d’abord d’ité rer avec
__iter__() puis avec le vieux protocole d’ité ration sur les sé quences via __getitem__(), reportez-vous à
cette section dans la référence du langage.

3.3.8 Émulation de types numériques

Les mé thodes suivantes peuvent ê tre dé finies pour é muler des objets numé riques. Les mé thodes correspondant à des
opé rations qui ne sont pas autorisé es pour la caté gorie de nombres considé ré e (par exemple, les opé rations bit à bit
pour les nombres qui ne sont pas entiers) doivent ê tre laissé es indé finies.
object.__add__(self, other)
object.__sub__(self, other)
object.__mul__(self, other)
object.__matmul__(self, other)
object.__truediv__(self, other)
object.__floordiv__(self, other)
object.__mod__(self, other)
object.__divmod__(self, other)
[
object.__pow__(self, other , modulo ) ]
object.__lshift__(self, other)

50 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

object.__rshift__(self, other)
object.__and__(self, other)
object.__xor__(self, other)
object.__or__(self, other)
Ces mé thodes sont appelé es pour implé menter les opé rations arithmé tiques binaires (+, -, *, @, /, //, %,
divmod(), pow(), **, <<, >>, &, ^, |). Par exemple, pour é valuer l’expression x + y, où x est une instance
d’une classe qui possè de une mé thode __add__(), type(x).__add__(x, y) est appelé e. La mé thode
__divmod__() doit ê tre l’é quivalent d’appeler __floordiv__() et __mod__() ; elle ne doit pas ê tre relié e
à __truediv__(). Notez que __pow__() doit ê tre dé finie de maniè re à accepter un troisiè me argument
optionnel si la version ternaire de la fonction native pow() est autorisé e.
If one of those methods does not support the operation with the supplied arguments, it should return
NotImplemented.
object.__radd__(self, other)
object.__rsub__(self, other)
object.__rmul__(self, other)
object.__rmatmul__(self, other)
object.__rtruediv__(self, other)
object.__rfloordiv__(self, other)
object.__rmod__(self, other)
object.__rdivmod__(self, other)
object.__rpow__(self, other , modulo ) [ ]
object.__rlshift__(self, other)
object.__rrshift__(self, other)
object.__rand__(self, other)
object.__rxor__(self, other)
object.__ror__(self, other)
These methods are called to implement the binary arithmetic operations (+, -, *, @, /, //, %, divmod(),
pow(), **, <<, >>, &, ^, |) with reflected (swapped) operands. These functions are only called if the left
operand does not support the corresponding operation 3 and the operands are of different types. 4 For instance,
to evaluate the expression x - y, where y is an instance of a class that has an __rsub__() method, type(y).
__rsub__(y, x) is called if type(x).__sub__(x, y) returns NotImplemented.
Notez que la fonction ternaire pow() n’essaie pas d’appeler __rpow__() (les rè gles de coercition seraient trop
compliqué es).

® Note

si le type de l’opé rande de droite est une sous-classe du type de l’opé rande de gauche et que cette sous-
classe fournit une implé mentation diffé rente de la mé thode symé trique pour l’opé ration, cette mé thode est
appelé e avant la mé thode originelle de l’opé rande gauche. Ce comportement permet à des sous-classes de
surcharger les opé rations de leurs ancê tres.

object.__iadd__(self, other)
object.__isub__(self, other)
object.__imul__(self, other)
object.__imatmul__(self, other)
object.__itruediv__(self, other)

3. ”Does not support” here means that the class has no such method, or the method returns NotImplemented. Do not set the method to
None if you want to force fallback to the right operand’s reflected method—that will instead have the opposite effect of explicitly blocking such
fallback.
4. Pour des opé randes de mê me type, on considè re que si la mé thode originelle (telle que __add__()) é choue, alors l’opé ration en tant que
telle n’est pas autorisé e et donc la mé thode symé trique n’est pas appelé e.

3.3. Méthodes spéciales 51

The Python Language Reference, Version 3.13.7

object.__ifloordiv__(self, other)
object.__imod__(self, other)
[
object.__ipow__(self, other , modulo ) ]
object.__ilshift__(self, other)
object.__irshift__(self, other)
object.__iand__(self, other)
object.__ixor__(self, other)
object.__ior__(self, other)
These methods are called to implement the augmented arithmetic assignments (+=, -=, *=, @=, /=, //=, %=,
**=, <<=, >>=, &=, ^=, |=). These methods should attempt to do the operation in-place (modifying self) and
return the result (which could be, but does not have to be, self). If a specific method is not defined, or if that
method returns NotImplemented, the augmented assignment falls back to the normal methods. For instance,
if x is an instance of a class with an __iadd__() method, x += y is equivalent to x = x.__iadd__(y)
. If __iadd__() does not exist, or if x.__iadd__(y) returns NotImplemented, x.__add__(y) and y.
__radd__(x) are considered, as with the evaluation of x + y. In certain situations, augmented assignment
can result in unexpected errors (see faq-augmented-assignment-tuple-error), but this behavior is in fact part of
the data model.
object.__neg__(self )
object.__pos__(self )
object.__abs__(self )
object.__invert__(self )
Appelé es pour implé menter les opé rations arithmé tiques unaires (-, +, abs() et ~).
object.__complex__(self )
object.__int__(self )
object.__float__(self )
Appelé es pour implé menter les fonctions natives complex(), int() et float(). Elles doivent renvoyer une
valeur du type approprié .
object.__index__(self )
Appelé e pour implé menter [Link]() et lorsque Python a besoin de convertir sans perte un objet
numé rique en objet entier (pour un dé coupage ou dans les fonctions natives bin(), hex() et oct()). La
pré sence de cette mé thode indique que l’objet numé rique est un type entier. Elle doit renvoyer un entier.
Si __int__(), __float__() et __complex__() ne sont pas dé finies, alors les fonctions natives int(),
float() et complex() redirigent par dé faut vers __index__().

[
object.__round__(self , ndigits ) ]
object.__trunc__(self )
object.__floor__(self )
object.__ceil__(self )
Appelé es pour implé menter la fonction native round() et les fonctions du module math trunc(), floor()
et ceil(). À moins que ndigits ne soit passé à __round__(), toutes ces mé thodes doivent renvoyer la valeur
de l’objet tronqué e pour donner un Integral (typiquement un int).
La fonction native int() se replie sur __trunc__() dans le cas où ni __int__() ni __index__() ne sont
dé finies.
Modifié dans la version 3.11 : la dé lé gation de int() vers __trunc__() est obsolè te.

3.3.9 Gestionnaire de contexte With

Un gestionnaire de contexte est un objet qui met en place un contexte pré dé fini au moment de l’exé cution de l’instruction
with. Le gestionnaire de contexte gè re l’entré e et la sortie de ce contexte d’exé cution pour tout un bloc de code.
Les gestionnaires de contextes sont normalement invoqué s en utilisant une instruction with (dé crite dans la section
L’instruction with), mais ils peuvent aussi ê tre directement invoqué s par leurs mé thodes.

52 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

Les utilisations classiques des gestionnaires de contexte sont la sauvegarde et la restauration d’é tats divers, le ver-
rouillage et le dé verrouillage de ressources, la fermeture de fichiers ouverts, etc.
For more information on context managers, see typecontextmanager. The object class itself does not provide the
context manager methods.
object.__enter__(self )
Entre dans le contexte d’exé cution relatif à cet objet. L’instruction with lie la valeur de retour de cette mé thode
à une (ou plusieurs) cible spé cifié e par la clause as de l’instruction, si elle est spé cifié e.
object.__exit__(self, exc_type, exc_value, traceback)
Sort du contexte d’exé cution relatif à cet objet. Les paramè tres dé crivent l’exception qui a causé la sortie du
contexte. Si l’on sort du contexte sans exception, les trois arguments sont à None.
Si une exception est indiqué e et que la mé thode souhaite supprimer l’exception (c’est-à -dire qu’elle ne veut pas
que l’exception soit propagé e), elle doit renvoyer True. Sinon, l’exception est traité e normalement à la sortie
de cette mé thode.
Note that __exit__() methods should not reraise the passed-in exception ; this is the caller’s responsibility.

µ Voir aussi

PEP 343 — L’instruction with

La spé cification, les motivations et des exemples de l’instruction with en Python.

3.3.10 Arguments positionnels dans le filtrage par motif sur les classes
When using a class name in a pattern, positional arguments in the pattern are not allowed by default, i.e. case
MyClass(x, y) is typically invalid without special support in MyClass. To be able to use that kind of pattern, the
class needs to define a __match_args__ attribute.
object.__match_args__
Cet attribut de la classe est un n-uplet de chaînes. Lorsque la classe apparaît dans un filtre avec des arguments
positionnels, ils sont convertis en arguments nommé s avec les noms du n-uplet, dans l’ordre. Si l’attribut n’est
pas dé fini, tout se passe comme si sa valeur é tait le n-uplet vide ().
Ainsi, si UneClasse.__match_args__ est mis à ("gauche", "milieu", "droite"), le filtre case
UneClasse(x, y) est é quivalent à case UneClasse(gauche=x, milieu=y). Le filtre doit comporter au
maximum autant d’arguments positionnels que la longueur __match_args__. Dans le cas contraire, le filtrage lè ve
l’exception TypeError.
Ajouté dans la version 3.10.

µ Voir aussi

PEP 634 — Filtrage par motif structurel

Spé cification de l’instruction match.

3.3.11 Emulating buffer types

The buffer protocol provides a way for Python objects to expose efficient access to a low-level memory array. This
protocol is implemented by builtin types such as bytes and memoryview, and third-party libraries may define
additional buffer types.
While buffer types are usually implemented in C, it is also possible to implement the protocol in Python.
object.__buffer__(self, flags)
Called when a buffer is requested from self (for example, by the memoryview constructor). The flags argument

3.3. Méthodes spéciales 53

The Python Language Reference, Version 3.13.7

is an integer representing the kind of buffer requested, affecting for example whether the returned buffer is read-
only or writable. [Link] provides a convenient way to interpret the flags. The method must
return a memoryview object.
object.__release_buffer__(self, buffer)
Called when a buffer is no longer needed. The buffer argument is a memoryview object that was previously
returned by __buffer__(). The method must release any resources associated with the buffer. This method
should return None. Buffer objects that do not need to perform any cleanup are not required to implement this
method.
Ajouté dans la version 3.12.

µ Voir aussi

PEP 688 - Making the buffer protocol accessible in Python

Introduces the Python __buffer__ and __release_buffer__ methods.
[Link]
ABC for buffer types.

3.3.12 Recherche des méthodes spéciales

Pour les classes dé finies par le dé veloppeur, l’invocation implicite de mé thodes spé ciales n’est garantie que si ces
mé thodes sont dé finies par le type d’objet, pas dans le dictionnaire de l’objet instance. Ce comportement explique
pourquoi le code suivant lè ve une exception :

>>> class C:
... pass
...
>>> c = C()
>>> c.__len__ = lambda: 5
>>> len(c)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: object of type 'C' has no len()

La raison de ce comportement vient de certaines mé thodes spé ciales telles que __hash__() et __repr__() qui
sont implé menté es par tous les objets, y compris les objets types. Si la recherche effectué e par ces mé thodes utilisait
le processus normal de recherche, elles ne fonctionneraient pas si on les appelait sur l’objet type lui-mê me :

>>> 1 .__hash__() == hash(1)

True
>>> int.__hash__() == hash(int)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: descriptor '__hash__' of 'int' object needs an argument

Essayer d’invoquer une mé thode non lié e d’une classe de cette maniè re est parfois appelé « confusion de mé taclasse »
et se contourne en shuntant l’instance lors de la recherche des mé thodes spé ciales :

>>> type(1).__hash__(1) == hash(1)

True
>>> type(int).__hash__(int) == hash(int)
True

En plus de shunter les attributs des instances pour fonctionner correctement, la recherche des mé thodes spé ciales
implicites shunte aussi la mé thode __getattribute__() mê me dans la mé taclasse de l’objet :

54 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

>>> class Meta(type):

... def __getattribute__(*args):
... print("Metaclass getattribute invoked")
... return type.__getattribute__(*args)
...
>>> class C(object, metaclass=Meta):
... def __len__(self):
... return 10
... def __getattribute__(*args):
... print("Class getattribute invoked")
... return object.__getattribute__(*args)
...
>>> c = C()
>>> c.__len__() # Explicit lookup via instance
Class getattribute invoked
10
>>> type(c).__len__(c) # Explicit lookup via type
Metaclass getattribute invoked
10
>>> len(c) # Implicit lookup
10

En shuntant le mé canisme de __getattribute__() de cette façon, cela permet d’optimiser la vitesse de l’interpré -
teur moyennant une certaine manœuvre dans la gestion des mé thodes spé ciales (la mé thode spé ciale doit ê tre dé finie
sur l’objet classe lui-mê me afin d’ê tre invoqué e de maniè re cohé rente par l’interpré teur).

3.4 Coroutines
3.4.1 Objets attendables (awaitable)
Un objet awaitable implé mente gé né ralement une mé thode __await__(). Les objets coroutine renvoyé s par les
fonctions async def sont des attendables (awaitable).

® Note

les objets itérateur de générateur renvoyé s par les gé né rateurs dé coré s par [Link]() sont aussi des
attendables (awaitable), mais ils n’implé mentent pas __await__().

object.__await__(self )
Must return an iterator. Should be used to implement awaitable objects. For instance, [Link]
implements this method to be compatible with the await expression. The object class itself is not awaitable
and does not provide this method.

® Note

The language doesn’t place any restriction on the type or value of the objects yielded by the iterator returned
by __await__, as this is specific to the implementation of the asynchronous execution framework (e.g.
asyncio) that will be managing the awaitable object.

Ajouté dans la version 3.5.

µ Voir aussi

PEP 492 pour les informations relatives aux objets attendables (awaitable).

3.4. Coroutines 55
The Python Language Reference, Version 3.13.7

3.4.2 Objets coroutines

Les objets coroutine sont des objets awaitable. L’exé cution d’une coroutine peut ê tre contrô lé e en appelant
__await__() et en ité rant sur le ré sultat. Quand la coroutine a fini de s’exé cuter et termine, l’ité rateur lè ve
StopIteration et l’attribut value de l’exception contient la valeur de retour. Si la coroutine lè ve une exception,
elle est propagé e par l’ité rateur. Les coroutines ne doivent pas lever directement des exceptions StopIteration
non gé ré es.
Les coroutines disposent aussi des mé thodes listé es ci-dessous, analogues à celles des gé né rateurs (voir Méthodes
des générateurs-itérateurs). Cependant, au contraire des gé né rateurs, vous ne pouvez pas ité rer directement sur des
coroutines.
Modifié dans la version 3.5.2 : utiliser await plus d’une fois sur une coroutine lè ve une RuntimeError.
[Link](value)
Starts or resumes execution of the coroutine. If value is None, this is equivalent to advancing the iterator
returned by __await__(). If value is not None, this method delegates to the send() method of the iterator
that caused the coroutine to suspend. The result (return value, StopIteration, or other exception) is the
same as when iterating over the __await__() return value, described above.
[Link](value)
[ [
[Link](type , value , traceback ]])
Lè ve l’exception spé cifié e dans la coroutine. Cette mé thode dé lè gue à la mé thode throw() de l’ité rateur qui
a causé la suspension de la coroutine, s’il possè de une telle mé thode. Sinon, l’exception est levé e au point de
suspension. Le ré sultat (valeur de retour, StopIteration ou une autre exception) est le mê me que lorsque
vous ité rez sur la valeur de retour de __await__(), dé crite ci-dessus. Si l’exception n’est pas gé ré e par la
coroutine, elle est propagé e à l’appelant.
Modifié dans la version 3.12 : The second signature (type[, value[, traceback]]) is deprecated and may be
removed in a future version of Python.
[Link]()
Demande à la coroutine de faire le mé nage et de se terminer. Si la coroutine est suspendue, cette mé thode
dé lè gue d’abord à la mé thode close() de l’ité rateur qui a causé la suspension de la coroutine, s’il possè de
une telle mé thode. Ensuite, elle lè ve GeneratorExit au point de suspension, ce qui fait le mé nage dans la
coroutine immé diatement. Enfin, la coroutine est marqué e comme ayant terminé son exé cution, mê me si elle
n’a jamais dé marré .
Les objets coroutines sont automatiquement fermé s en utilisant le processus dé crit au-dessus au moment où ils
sont dé truits.

3.4.3 Itérateurs asynchrones

Un itérateur asynchrone peut appeler du code asynchrone dans sa mé thode __anext__.
Les ité rateurs asynchrones peuvent ê tre utilisé s dans des instructions async for.
The object class itself does not provide these methods.
object.__aiter__(self )
Doit renvoyer un objet itérateur asynchrone.
object.__anext__(self )
Doit renvoyer un attendable (awaitable) qui se traduit par la valeur suivante de l’ité rateur. Doit lever une
StopAsyncIteration quand l’ité ration est terminé e.

Un exemple d’objet ité rateur asynchrone :

class Reader:
async def readline(self):
...

(suite sur la page suivante)

56 Chapitre 3. Modèle de données

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

def __aiter__(self):
return self

async def __anext__(self):

val = await [Link]()
if val == b'':
raise StopAsyncIteration
return val

Ajouté dans la version 3.5.

Modifié dans la version 3.7 : avant Python 3.7, __aiter__() pouvait renvoyer un attendable (awaitable) qui se
ré solvait potentiellement en un itérateur asynchrone.
À partir de Python 3.7, __aiter__() doit renvoyer un objet ité rateur asynchrone. Renvoyer autre chose entraine
une erreur TypeError.

3.4.4 Gestionnaires de contexte asynchrones

Un gestionnaire de contexte asynchrone est un gestionnaire de contexte qui est capable de suspendre son exé cution dans
ses mé thodes __aenter__ et __aexit__.
Les gestionnaires de contexte asynchrones peuvent ê tre utilisé s dans des instructions async with.
The object class itself does not provide these methods.
object.__aenter__(self )
Semantically similar to __enter__(), the only difference being that it must return an awaitable.
object.__aexit__(self, exc_type, exc_value, traceback)
Semantically similar to __exit__(), the only difference being that it must return an awaitable.
Un exemple de classe de gestionnaire de contexte asynchrone :

class AsyncContextManager:
async def __aenter__(self):
await log('entering context')

async def __aexit__(self, exc_type, exc, tb):

await log('exiting context')

Ajouté dans la version 3.5.

3.4. Coroutines 57
The Python Language Reference, Version 3.13.7

58 Chapitre 3. Modèle de données

 CHAPITRE 4

Modèle d’exécution

4.1 Structure d’un programme

Un programme Python est construit à partir de blocs de code. Un bloc est un morceau de texte de programme Python
qui est exé cuté en tant qu’unité . Les é lé ments suivants sont des blocs : un module, un corps de fonction et une dé finition
de classe. Chaque commande é crite dans l’interpré teur interactif de Python est un bloc. Un fichier de script (un fichier
donné en entré e standard à l’interpré teur ou spé cifié en tant qu’argument de ligne de commande à l’interpré teur) est
un bloc de code. Une commande de script (une commande spé cifié e en ligne de commande à l’interpré teur avec
l’option -c) est un bloc de code. Un module exé cuté en tant que script principal (module __main__) depuis la ligne
de commande en utilisant l’option -m est aussi un bloc de code. La chaîne passé e en argument aux fonctions natives
eval() et exec() est un bloc de code.

Un bloc de code est exé cuté dans un cadre d’exécution. Un cadre contient des informations administratives (utilisé es
pour le dé bogage) et dé termine où et comment l’exé cution se poursuit aprè s la fin de l’exé cution du bloc de code.

4.2 Noms et liaisons

4.2.1 Liaisons des noms
Les noms sont des ré fé rences aux objets. Ils sont cré és lors des opé rations de liaisons de noms (name binding en
anglais).
Les noms sont lié s via les constructions suivantes :
— paramè tres formels de fonctions,
— dé finitions de classes,
— dé finitions de fonctions,
— expressions d’affectation,
— cibles qui sont des identifiants, lorsque c’est une affectation :
— de l’entê te d’une boucle for,
— after as in a with statement, except clause, except* clause, or in the as-pattern in structural pattern
matching,
— dans un champ de recherche d’un filtrage par motifs
— des instructions import.
— type statements.
— type parameter lists.
L’instruction import sous la forme from ... import * lie tous les noms dé finis dans le module importé , sauf
ceux qui commencent par le caractè re souligné . Cette é criture ne peut ê tre utilisé e qu’au niveau du module.

59
The Python Language Reference, Version 3.13.7

Une cible qui apparaît dans une instruction del est aussi considé ré e comme une liaison à un nom dans ce cadre (bien
que la sé mantique vé ritable soit de dé lier le nom).
Chaque affectation ou instruction import a lieu dans un bloc dé fini par une dé finition de classe ou de fonction, ou au
niveau du module (le bloc de code de plus haut niveau).
If a name is bound in a block, it is a local variable of that block, unless declared as nonlocal or global. If a name
is bound at the module level, it is a global variable. (The variables of the module code block are local and global.) If
a variable is used in a code block but not defined there, it is a free variable.
Chaque occurrence d’un nom dans un programme fait ré fé rence à la liaison de ce nom é tablie par les rè gles de
ré solution des noms suivantes.

4.2.2 Résolution des noms

La portée dé finit la visibilité d’un nom dans un bloc. Si une variable locale est dé finie dans un bloc, sa porté e comprend
ce bloc. Si la dé finition intervient dans le bloc d’une fonction, la porté e s’é tend à tous les blocs contenus dans celui
qui comprend la dé finition, à moins qu’un bloc inté rieur ne dé finisse une autre liaison pour ce nom.
Quand un nom est utilisé dans un bloc de code, la ré solution utilise la porté e la plus petite. L’ensemble de toutes les
porté es visibles dans un bloc de code s’appelle l’environnement du bloc.
Quand un nom n’est trouvé nulle part, une exception NameError est levé e. Si la porté e courante est celle d’une
fonction et que le nom fait ré fé rence à une variable locale qui n’a pas encore é té lié e au moment où le nom est utilisé ,
une exception UnboundLocalError est levé e. UnboundLocalError est une sous-classe de NameError.
If a name binding operation occurs anywhere within a code block, all uses of the name within the block are treated
as references to the current block. This can lead to errors when a name is used within a block before it is bound. This
rule is subtle. Python lacks declarations and allows name binding operations to occur anywhere within a code block.
The local variables of a code block can be determined by scanning the entire text of the block for name binding
operations. See the FAQ entry on UnboundLocalError for examples.
If the global statement occurs within a block, all uses of the names specified in the statement refer to the bindings
of those names in the top-level namespace. Names are resolved in the top-level namespace by searching the global
namespace, i.e. the namespace of the module containing the code block, and the builtins namespace, the namespace
of the module builtins. The global namespace is searched first. If the names are not found there, the builtins
namespace is searched next. If the names are also not found in the builtins namespace, new variables are created in
the global namespace. The global statement must precede all uses of the listed names.
L’instruction global a la mê me porte qu’une opé ration de liaison du mê me bloc. Si la porté e englobante la plus
petite pour une variable libre contient une instruction global, la variable libre est considé ré e globale.
The nonlocal statement causes corresponding names to refer to previously bound variables in the nearest enclosing
function scope. SyntaxError is raised at compile time if the given name does not exist in any enclosing function
scope. Type parameters cannot be rebound with the nonlocal statement.
L’espace de nommage pour un module est cré é automatiquement la premiè re fois que le module est importé . Le
module principal d’un script s’appelle toujours __main__.
Class definition blocks and arguments to exec() and eval() are special in the context of name resolution. A class
definition is an executable statement that may use and define names. These references follow the normal rules for name
resolution with an exception that unbound local variables are looked up in the global namespace. The namespace of
the class definition becomes the attribute dictionary of the class. The scope of names defined in a class block is limited
to the class block ; it does not extend to the code blocks of methods. This includes comprehensions and generator
expressions, but it does not include annotation scopes, which have access to their enclosing class scopes. This means
that the following will fail :

class A:
a = 42
b = list(a + i for i in range(10))

However, the following will succeed :

60 Chapitre 4. Modèle d’exécution

 The Python Language Reference, Version 3.13.7

class A:
type Alias = Nested
class Nested: pass

print([Link].__value__) # <type '[Link]'>

4.2.3 Annotation scopes

Type parameter lists and type statements introduce annotation scopes, which behave mostly like function scopes, but
with some exceptions discussed below. Annotations currently do not use annotation scopes, but they are expected to
use annotation scopes in Python 3.13 when PEP 649 is implemented.
Annotation scopes are used in the following contexts :
— Type parameter lists for generic type aliases.
— Type parameter lists for generic functions. A generic function’s annotations are executed within the annotation
scope, but its defaults and decorators are not.
— Type parameter lists for generic classes. A generic class’s base classes and keyword arguments are executed
within the annotation scope, but its decorators are not.
— The bounds, constraints, and default values for type parameters (lazily evaluated).
— The value of type aliases (lazily evaluated).
Annotation scopes differ from function scopes in the following ways :
— Annotation scopes have access to their enclosing class namespace. If an annotation scope is immediately
within a class scope, or within another annotation scope that is immediately within a class scope, the code in
the annotation scope can use names defined in the class scope as if it were executed directly within the class
body. This contrasts with regular functions defined within classes, which cannot access names defined in the
class scope.
— Expressions in annotation scopes cannot contain yield, yield from, await, or := expressions. (These
expressions are allowed in other scopes contained within the annotation scope.)
— Names defined in annotation scopes cannot be rebound with nonlocal statements in inner scopes. This
includes only type parameters, as no other syntactic elements that can appear within annotation scopes can
introduce new names.
— While annotation scopes have an internal name, that name is not reflected in the qualified name of objects
defined within the scope. Instead, the __qualname__ of such objects is as if the object were defined in the
enclosing scope.
Ajouté dans la version 3.12 : Annotation scopes were introduced in Python 3.12 as part of PEP 695.
Modifié dans la version 3.13 : Annotation scopes are also used for type parameter defaults, as introduced by PEP
696.

4.2.4 Lazy evaluation

The values of type aliases created through the type statement are lazily evaluated. The same applies to the bounds,
constraints, and default values of type variables created through the type parameter syntax. This means that they
are not evaluated when the type alias or type variable is created. Instead, they are only evaluated when doing so is
necessary to resolve an attribute access.
Exemple :

>>> type Alias = 1/0

>>> Alias.__value__
Traceback (most recent call last):
...
ZeroDivisionError: division by zero
>>> def func[T: 1/0](): pass
>>> T = func.__type_params__[0]
>>> T.__bound__
Traceback (most recent call last):
(suite sur la page suivante)

4.2. Noms et liaisons 61

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

...
ZeroDivisionError: division by zero

Here the exception is raised only when the __value__ attribute of the type alias or the __bound__ attribute of the
type variable is accessed.
This behavior is primarily useful for references to types that have not yet been defined when the type alias or type
variable is created. For example, lazy evaluation enables creation of mutually recursive type aliases :

from typing import Literal

type SimpleExpr = int | Parenthesized

type Parenthesized = tuple[Literal["("], Expr, Literal[")"]]
type Expr = SimpleExpr | tuple[SimpleExpr, Literal["+", "-"], Expr]

Lazily evaluated values are evaluated in annotation scope, which means that names that appear inside the lazily
evaluated value are looked up as if they were used in the immediately enclosing scope.
Ajouté dans la version 3.12.

4.2.5 Noms natifs et restrictions d’exécution

L’utilisateur ne doit pas toucher à __builtins__ ; c’est et cela doit rester ré servé aux besoins de l’implé mentation.
Les utilisateurs qui souhaitent surcharger des valeurs dans l’espace de nommage natif doivent importer le module
builtins et modifier ses attributs judicieusement.

L’espace de nommage natif associé à l’exé cution d’un bloc de code est effectivement trouvé en cherchant le nom
__builtins__ dans l’espace de nommage globaux ; ce doit ê tre un dictionnaire ou un module (dans ce dernier cas,
le dictionnaire du module est utilisé ). Par dé faut, lorsque l’on se trouve dans le module __main__, __builtins__
est le module natif builtins ; lorsque l’on se trouve dans tout autre module, __builtins__ est un pseudonyme
du dictionnaire du module builtins lui-mê me.

4.2.6 Interaction avec les fonctionnalités dynamiques

La ré solution des noms de variables libres intervient à l’exé cution, pas à la compilation. Cela signifie que le code
suivant affiche 42 :

i = 10
def f():
print(i)
i = 42
f()

Les fonctions eval() et exec() n’ont pas accè s à l’environnement complet pour ré soudre les noms. Les noms
doivent ê tre ré solus dans les espaces de nommage locaux et globaux de l’appelant. Les variables libres ne sont pas
ré solues dans l’espace de nommage englobant le plus proche mais dans l’espace de nommage globaux 1 . Les fonctions
eval() et exec() possè dent des arguments optionnels pour surcharger les espaces de nommage globaux et locaux.
Si seulement un espace de nommage est spé cifié , il est utilisé pour les deux.

4.3 Exceptions
Les exceptions sont un moyen de sortir du flot normal d’exé cution d’un bloc de code de maniè re à gé rer des erreurs
ou des conditions exceptionnelles. Une exception est levée au moment où l’erreur est dé tecté e ; elle doit ê tre gérée par
le bloc de code qui l’entoure ou par tout bloc de code qui a, directement ou indirectement, invoqué le bloc de code
où l’erreur s’est produite.
1. En effet, le code qui est exé cuté par ces opé rations n’est pas connu au moment où le module est compilé .

62 Chapitre 4. Modèle d’exécution

 The Python Language Reference, Version 3.13.7

L’interpré teur Python lè ve une exception quand il dé tecte une erreur à l’exé cution (telle qu’une division par zé ro). Un
programme Python peut aussi lever explicitement une exception avec l’instruction raise. Les gestionnaires d’ex-
ception sont spé cifié s avec l’instruction try … except. La clause finally d’une telle instruction peut ê tre utilisé e
pour spé cifier un code de nettoyage qui ne gè re pas l’exception mais qui est exé cuté quoi qu’il arrive (exception ou
pas).
Python utilise le modè le par terminaison de gestion des erreurs : un gestionnaire d’exception peut trouver ce qui est
arrivé et continuer l’exé cution à un niveau plus é levé , mais il ne peut pas ré parer l’origine de l’erreur et ré -essayer
l’opé ration qui a é choué (sauf à entrer à nouveau dans le code en question par le haut).
Quand une exception n’est pas du tout gé ré e, l’interpré teur termine l’exé cution du programme ou retourne à la boucle
interactive. Dans ces cas, il affiche une trace de la pile d’appels, sauf si l’exception est SystemExit.
Les exceptions sont identifié es par des instances de classe. La clause except sé lectionné e dé pend de la classe de
l’instance : elle doit faire ré fé rence à la classe de l’instance ou à une de ses classes ancêtres non virtuelles. L’instance peut
ê tre transmise au gestionnaire et peut apporter des informations complé mentaires sur les conditions de l’exception.

® Note

Les messages d’exception ne font pas partie de l’API Python. Leur contenu peut changer d’une version de Python
à une autre sans avertissement et le code ne doit pas reposer sur ceux-ci s’il doit fonctionner sur plusieurs versions
de l’interpré teur.

Reportez-vous aussi aux descriptions de l’instruction try dans la section L’instruction try et de l’instruction raise
dans la section L’instruction raise.

Notes

4.3. Exceptions 63
The Python Language Reference, Version 3.13.7

64 Chapitre 4. Modèle d’exécution

 CHAPITRE 5

Le système d’importation

Le code Python d’un module peut accé der à du code d’un autre module par un mé canisme qui consiste à importer cet
autre module. L’instruction import est la façon la plus courante de faire appel à ce systè me d’importation, mais ce
n’est pas la seule. Les fonctions telles que importlib.import_module() et __import__() peuvent aussi ê tre
utilisé es pour mettre en œuvre le mé canisme d’importation.
L’instruction import effectue deux opé rations ; elle cherche le module dont le nom a é té donné puis elle lie le ré sultat
de cette recherche à un nom dans la porté e locale. L’opé ration de recherche de l’instruction import consiste à appeler
la fonction __import__() avec les arguments adé quats. La valeur renvoyé e par __import__() est utilisé e pour
effectuer l’opé ration de liaison avec le nom fourni à l’instruction import. Reportez-vous à l’instruction import pour
les dé tails exacts de l’opé ration de liaison avec le nom.
Un appel direct à __import__() effectue seulement la recherche du module et, s’il est trouvé , l’opé ration de cré ation
du module. Bien que des effets collaté raux puissent se produire, tels que l’importation de paquets parents et la mise
à jour de divers caches (y compris [Link]), il n’y a que l’instruction import qui dé clenche l’opé ration de
liaison avec le nom.
Quand une instruction import est exé cuté e, la fonction native __import__() est appelé e. D’autres mé ca-
nismes d’appel au systè me d’importation (tels que importlib.import_module()) peuvent choisir d’ignorer
__import__() et utiliser leurs propres solutions pour implé menter la sé mantique d’importation.

Quand un module est importé pour la premiè re fois, Python recherche le module et, s’il est trouvé , cré e un objet
module 1 en l’initialisant. Si le module n’est pas trouvé , une ModuleNotFoundError est levé e. Python implé mente
plusieurs straté gies pour rechercher le module d’un nom donné quand le mé canisme d’importation est invoqué . Ces
straté gies peuvent ê tre modifié es et é tendues par divers moyens dé crits dans les sections suivantes.
Modifié dans la version 3.3 : le systè me d’importation a é té mis à jour pour implé menter complè tement la deuxiè me
partie de la PEP 302. Il n’existe plus de mé canisme implicite d’importation (le systè me d’importation complet est
exposé via sys.meta_path). En complé ment, la gestion des paquets dans l’espace des noms natif a é té implé menté e
(voir la PEP 420).

5.1 importlib
Le module importlib fournit une API riche pour interagir avec le systè me d’importation. Par exemple,
importlib.import_module() fournit une API (que nous vous recommandons) plus simple que la fonction na-
tive __import__() pour mettre en œuvre le mé canisme d’importation. Reportez-vous à la documentation de la
bibliothè que importlib pour obtenir davantage de dé tails.
1. Voir [Link].

65
The Python Language Reference, Version 3.13.7

5.2 Les paquets

Python ne connait qu’un seul type d’objet module et tous les modules sont donc de ce type, que le module soit
implé menté en Python, en C ou quoi que ce soit d’autre. Pour aider à l’organisation des modules et fournir une
hié rarchie des noms, Python dé veloppe le concept de paquets.
Vous pouvez vous repré senter les paquets comme des ré pertoires dans le systè me de fichiers et les modules comme des
fichiers dans ces ré pertoires. Mais ne prenez pas trop cette analogie au pied de la lettre car les paquets et les modules
ne proviennent pas obligatoirement du systè me de fichiers. Dans le cadre de cette documentation, nous utilisons cette
analogie bien pratique des ré pertoires et des fichiers. Comme les ré pertoires du systè me de fichiers, les paquets sont
organisé s de maniè re hié rarchique et les paquets peuvent eux-mê mes contenir des sous-paquets ou des modules.
Il est important de garder à l’esprit que tous les paquets sont des modules mais que tous les modules ne sont pas
des paquets. Formulé autrement, les paquets sont juste un certain type de modules. Spé cifiquement, tout module qui
contient un attribut __path__ est ré puté ê tre un paquet.
Tous les modules ont un nom. Les noms des sous-paquets sont sé paré s du nom du paquet parent par un point (.), à
l’instar de la syntaxe standard d’accè s aux attributs en Python. Ainsi, vous pouvez avoir un paquet nommé email qui
possè de un sous-paquet nommé [Link] et un module dans ce sous-paquet nommé [Link].

5.2.1 Paquets classiques

Python dé finit deux types de paquets, les paquets classiques et les paquets espaces de nommage. Les paquets classiques
sont les paquets traditionnels tels qu’ils existaient dans Python 3.2 et anté rieurs. Un paquet classique est typiquement
implé menté sous la forme d’un ré pertoire contenant un fichier __init__.py. Quand un paquet classique est importé ,
ce fichier __init__.py est implicitement exé cuté .
Par exemple, l’arborescence suivante dé finit un paquet parent au niveau le plus haut avec trois sous-paquets :

parent/
__init__.py
one/
__init__.py
two/
__init__.py
three/
__init__.py

Importer [Link] exé cute implicitement parent/__init__.py et parent/one/__init__.py. Les im-

portations posté rieures de [Link] ou [Link] respectivement exé cutent parent/two/__init__.
py ou parent/three/__init__.py respectivement.

5.2.2 Paquets espaces de nommage

Un paquet-espace de nommage est la combinaison de plusieurs portions où chaque portion fournit un sous-paquet
au paquet parent. Les portions peuvent ê tre situé es à diffé rents endroits du systè me de fichiers. Les portions peuvent
aussi ê tre stocké es dans des fichiers zip, sur le ré seau ou à tout autre endroit dans lequel Python cherche pendant
l’importation. Les paquets-espaces de nommage peuvent correspondre directement à des objets du systè me de fichiers,
ou pas ; ils peuvent ê tre des modules virtuels qui n’ont aucune repré sentation concrè te.
Les paquets-espaces de nommage n’utilisent pas une liste ordinaire pour leur attribut __path__. Ils utilisent en lieu
et place un type ité rable personnalisé qui effectue automatiquement une nouvelle recherche de portions de paquets à
la tentative suivante d’importation dans ce paquet si le chemin de leur paquet parent (ou [Link] pour les paquets
de plus haut niveau) change.
Pour les paquets-espaces de nommage, il n’existe pas de fichier parent/__init__.py. En fait, il peut y avoir
plusieurs ré pertoires parent trouvé s pendant le processus d’importation, où chacun est apporté par une portion
diffé rente. Ainsi, parent/one n’est pas forcé ment physiquement à cô té de parent/two. Dans ce cas, Python cré e
un paquet-espace de nommage pour le paquet de plus haut niveau parent dè s que lui ou l’un de ses sous-paquet est
importé .
Voir aussi la PEP 420 pour les spé cifications des paquets-espaces de nommage.

66 Chapitre 5. Le système d’importation

 The Python Language Reference, Version 3.13.7

5.3 Recherche
Pour commencer la recherche, Python a besoin du nom qualifié du module (ou du paquet, mais ici cela ne fait pas
de diffé rence) que vous souhaitez importer. Le nom peut ê tre donné en argument à l’instruction import ou comme
paramè tre aux fonctions importlib.import_module() ou __import__().
Le nom est utilisé dans plusieurs phases de la recherche et peut ê tre un chemin sé paré par des points pour un
sous-module, par exemple [Link]. Dans ce cas, Python essaie d’abord d’importer truc puis
[Link] et enfin [Link]. Si n’importe laquelle des importations intermé diaires é choue, une
ModuleNotFoundError est levé e.

5.3.1 Cache des modules

Le premier endroit vé rifié pendant la recherche d’une importation est [Link]. Ce tableau de correspondances
est utilisé comme cache de tous les modules dé jà importé s, y compris les chemins intermé diaires. Ainsi, si truc.
[Link] a dé jà é té importé , [Link] contient les entré es correspondantes à truc, [Link]
et [Link]. À chaque chemin correspond une clé .
Pendant l’importation, le nom de module est cherché dans [Link] et, s’il est trouvé , la valeur associé e est le
module recherché et le processus est fini. Cependant, si la valeur est None, alors une ModuleNotFoundError est
levé e. Si le nom du module n’est pas trouvé , Python continue la recherche du module.
[Link] est accessible en lecture-é criture. Supprimer une clé peut ne pas dé truire le module associé (car
d’autres modules contiennent possiblement des ré fé rences vers ce module), mais cela invalide l’entré e du cache pour
ce nom de module. Python cherche alors un nouveau module pour ce nom. La clé peut aussi ê tre assigné e à None de
maniè re à forcer une ModuleNotFoundError lors de la prochaine importation du module.
Attention cependant : s’il reste une ré fé rence à l’objet module et que vous invalidez l’entré e dans le cache de sys.
modules puis ré -importez le module, les deux objets modules ne seront pas les mê mes. À l’inverse, importlib.
reload() ré -utilise le même objet module et ré -initialise simplement le contenu du module en ré -exé cutant le code
du module.

5.3.2 Chercheurs et chargeurs

Si le module n’est pas trouvé dans [Link], alors Python utilise son protocole d’importation pour chercher et
charger le module. Ce protocole se compose de deux objets conceptuels : les chercheurs et les chargeurs. Le travail
du chercheur consiste à trouver, à l’aide de diffé rentes straté gies, le module dont le nom a é té fourni. Les objets
qui implé mentent ces deux interfaces sont connus sous le vocable « importateurs » (ils renvoient une ré fé rence vers
eux-mê mes quand ils trouvent un module qui ré pond aux attentes).
Python inclut plusieurs chercheurs et importateurs par dé faut. Le premier sait comment trouver les modules natifs et
le deuxiè me sait comment trouver les modules figé s. Un troisiè me chercheur recherche les modules dans import path.
import path est une é numé ration sous forme de liste de chemins ou de fichiers zip. Il peut ê tre é tendu pour rechercher
aussi dans toute ressource qui dispose d’un identifiant pour la localiser, une URL par exemple.
Le mé canisme d’importation est extensible, vous pouvez donc ajouter de nouveaux chercheurs pour é tendre le do-
maine de recherche des modules.
Les chercheurs ne chargent pas les modules. S’il trouve le module demandé , un chercheur renvoie un spécificateur
de module, qui contient toutes les informations né cessaires pour importer le module ; celui-ci sera alors utilisé par le
mé canisme d’importation pour charger le module.
Les sections suivantes dé crivent plus en dé tail le protocole utilisé par les chercheurs et les chargeurs, y compris la
maniè re de les cré er et les enregistrer pour é tendre le mé canisme d’importation.
Modifié dans la version 3.4 : dans les versions pré cé dentes de Python, les chercheurs renvoyaient directement les
chargeurs. Doré navant, ils renvoient des spé cificateurs de modules qui contiennent les chargeurs. Les chargeurs sont
encore utilisé s lors de l’importation mais ont moins de responsabilité s.

5.3. Recherche 67
The Python Language Reference, Version 3.13.7

5.3.3 Points d’entrées automatiques pour l’importation

Le mé canisme d’importation est conçu pour ê tre extensible ; vous pouvez y insé rer des points d’entrée automatique
(hooks en anglais). Il existe deux types de points d’entré e automatique pour l’importation : les méta-points d’entrée et
les points d’entrée sur le chemin des importations.
Les mé ta-points d’entré e sont appelé s au dé but du processus d’importation, juste aprè s la vé rification dans le cache
[Link] mais avant tout le reste. Cela permet aux mé ta-points d’entré e de surcharger le traitement effectué
sur [Link], les modules figé s ou mê me les modules natifs. L’enregistrement des mé ta-points d’entré e se fait en
ajoutant de nouveaux objets chercheurs à sys.meta_path, comme dé crit ci-dessous.
Les points d’entré e sur le chemin des importations sont appelé s pendant le traitement de [Link] (ou package.
__path__), au moment où le chemin qui leur correspond est atteint. Les points d’entré e sur le chemin des importa-
tions sont enregistré s en ajoutant de nouveaux appelables à sys.path_hooks, comme dé crit ci-dessous.

5.3.4 Méta-chemins
Quand le module demandé n’est pas trouvé dans [Link], Python recherche alors dans sys.meta_path qui
contient une liste d’objets chercheurs dans des mé ta-chemins. Ces chercheurs sont interrogé s dans l’ordre pour voir
s’ils savent prendre en charge le module passé en paramè tre. Les chercheurs dans les mé ta-chemins implé mentent
une mé thode find_spec() qui prend trois arguments : un nom, un chemin d’importation et (optionnellement) un
module cible. Un chercheur dans les mé ta-chemins peut utiliser n’importe quelle straté gie pour dé terminer s’il est
apte à prendre en charge le module.
Si un chercheur dans les mé ta-chemins sait prendre en charge le module donné , il renvoie un objet spé cificateur. S’il
ne sait pas, il renvoie None. Si le traitement de sys.meta_path arrive à la fin de la liste sans qu’aucun chercheur
n’a renvoyé un objet spé cificateur, alors une ModuleNotFoundError est levé e. Toute autre exception levé e est
simplement propagé e à l’appelant, mettant fin au processus d’importation.
La mé thode find_spec() des chercheurs dans les mé ta-chemins est appelé e avec deux ou trois arguments. Le pre-
mier est le nom complè tement qualifié du module à importer, par exemple [Link]. Le deuxiè me
argument est l’ensemble des chemins dans lesquels chercher. Pour les modules de plus haut niveau, le deuxiè me argu-
ment est None mais pour les sous-modules ou les paquets, le deuxiè me argument est la valeur de l’attribut __path__
du paquet parent. Si l’attribut __path__ approprié n’est pas accessible, une ModuleNotFoundError est levé e. Le
troisiè me argument est un objet module existant qui va ê tre la cible du chargement (plus tard). Le systè me d’impor-
tation ne passe le module cible en paramè tre que lors d’un rechargement.
Le mé ta-chemin peut ê tre parcouru plusieurs fois pour une seule requê te d’importation. Par exemple, si nous
supposons qu’aucun des modules concerné s n’a dé jà é té mis en cache, importer [Link] effec-
tue une premiè re importation au niveau le plus haut, en appelant c_m_c.find_spec("truc", None, None)
pour chaque chercheur dans les mé ta-chemins (c_m_c). Aprè s que truc a é té importé , [Link] est im-
porté en parcourant le mé ta-chemin une deuxiè me fois, appelant c_m_c.find_spec("[Link]", truc.
__path__, None). Une fois [Link] importé , le parcours final appelle c_m_c.find_spec("truc.
[Link]", [Link].__path__, None).

Quelques chercheurs dans les mé ta-chemins ne gè rent que les importations de plus haut niveau. Ces importateurs
renvoient toujours None si on leur passe un deuxiè me argument autre que None.
Le sys.meta_path de Python comprend trois chercheurs par dé faut : un qui sait importer les modules natifs, un
qui sait importer les modules figé s et un qui sait importer les modules depuis un chemin des importations (c’est le
chercheur dans path).
Modifié dans la version 3.4 : La mé thode find_spec() des chercheurs dans les mé ta-chemins a remplacé
find_module(), devenue obsolè te. Bien qu’elle continue de fonctionner comme avant, le mé canisme d’importation
essaie find_module() uniquement si le chercheur n’implé mente pas find_spec().
Modifié dans la version 3.10 : L’utilisation de find_module() par le systè me d’importation lè ve maintenant un
ImportWarning.

Modifié dans la version 3.12 : find_module() a é té supprimé . Utiliser find_spec() à la place.

68 Chapitre 5. Le système d’importation

 The Python Language Reference, Version 3.13.7

5.4 Chargement
Quand un spé cificateur de module est trouvé , le mé canisme d’importation l’utilise (et le chargeur qu’il contient) pour
charger le module. Voici à peu prè s ce qui se passe au sein de l’importation pendant la phase de chargement :

module = None
if [Link] is not None and hasattr([Link], 'create_module'):
# It is assumed 'exec_module' will also be defined on the loader.
module = [Link].create_module(spec)
if module is None:
module = ModuleType([Link])
# The import-related module attributes get set here:
_init_module_attrs(spec, module)

if [Link] is None:
# unsupported
raise ImportError
if [Link] is None and spec.submodule_search_locations is not None:
# namespace package
[Link][[Link]] = module
elif not hasattr([Link], 'exec_module'):
module = [Link].load_module([Link])
else:
[Link][[Link]] = module
try:
[Link].exec_module(module)
except BaseException:
try:
del [Link][[Link]]
except KeyError:
pass
raise
return [Link][[Link]]

Notez les dé tails suivants :

— S’il existe un objet module dans [Link] avec le mê me nom, import l’aurait dé jà renvoyé .
— Le module existe dans [Link] avant que le chargeur exé cute le code du module. C’est crucial car le
code du module peut (directement ou indirectement) s’importer lui-mê me ; l’ajouter à [Link] avant
é vite les ré cursions infinies dans le pire cas et le chargement multiple dans le meilleur des cas.
— Si le chargement é choue, le module en cause (et seulement ce module) est enlevé de [Link]. Tout
module dé jà dans le cache de [Link] et tout module qui a é té chargé avec succè s par effet de bord
doit rester dans le cache. C’est diffé rent dans le cas d’un rechargement où mê me le module qui a é choué est
conservé dans [Link].
— Aprè s que le module est cré é mais avant son exé cution, le mé canisme d’importation dé finit les attributs re-
latifs à l’importation (_init_module_attrs dans l’exemple de pseudo-code ci-dessus), comme indiqué
briè vement dans une section que nous abordons ensuite.
— L’exé cution du module est le moment clé du chargement dans lequel l’espace de nommage du module est
peuplé . L’exé cution est entiè rement dé lé gué e au chargeur qui doit dé cider ce qui est peuplé et comment.
— Le modulé cré é pendant le chargement et passé à exec_module() peut ne pas ê tre celui qui est renvoyé à
la fin de l’importation 2 .
Modifié dans la version 3.4 : le systè me d’importation a pris en charge les responsabilité s des chargeurs. Celles-ci
é taient auparavant effectué es par la mé thode [Link].load_module().
2. L’implé mentation de importlib é vite d’utiliser directement la valeur de retour. À la place, elle ré cupè re l’objet module en recherchant le
nom du module dans [Link]. L’effet indirect est que le module importé peut remplacer le module de mê me nom dans [Link].
C’est un comportement spé cifique à l’implé mentation dont le ré sultat n’est pas garanti pour les autres implé mentations de Python.

5.4. Chargement 69
The Python Language Reference, Version 3.13.7

5.4.1 Chargeurs
Les chargeurs de modules fournissent la fonction critique du chargement : l’exé cution du module. Le mé canisme
d’importation appelle la mé thode [Link].exec_module() avec un unique argument, l’objet
module à exé cuter. Toute valeur renvoyé e par exec_module() est ignoré e.
Les chargeurs doivent satisfaire les conditions suivantes :
— Si le module est un module Python (par opposition aux modules natifs ou aux extensions chargé es dynami-
quement), le chargeur doit exé cuter le code du module dans l’espace des noms globaux du module (module.
__dict__).
— Si le chargeur ne peut pas exé cuter le module, il doit lever une ImportError, alors que toute autre exception
levé e durant exec_module() est propagé e.
Souvent, le chercheur et le chargeur sont le mê me objet ; dans ce cas, la mé thode find_spec() doit juste renvoyer
un spé cificateur avec le chargeur dé fini à self.
Les chargeurs de modules peuvent choisir de cré er l’objet module pendant le chargement en implé mentant une mé -
thode create_module(). Elle prend un argument, l’objet spé cificateur du module et renvoie le nouvel objet du
module à utiliser pendant le chargement. Notez que create_module() n’a besoin de dé finir aucun attribut sur
l’objet module. Si cette mé thode renvoie None, le mé canisme d’importation cré e le nouveau module lui-mê me.
Ajouté dans la version 3.4 : la mé thode create_module() des chargeurs.
Modifié dans la version 3.4 : la mé thode load_module() a é té remplacé e par exec_module() et le mé canisme
d’import assume toutes les responsabilité s du chargement.
Par compatibilité avec les chargeurs existants, le mé canisme d’importation utilise la mé thode load_module() des
chargeurs si elle existe et si le chargeur n’implé mente pas exec_module(). Cependant, load_module() est dé -
claré e obsolè te et les chargeurs doivent implé menter exec_module() à la place.
La mé thode load_module() doit implé menter toutes les fonctionnalité s de chargement dé crites ci-dessus en plus
de l’exé cution du module. Toutes les contraintes s’appliquent aussi, avec quelques pré cisions supplé mentaires :
— S’il y a un objet module existant avec le mê me nom dans [Link], le chargeur doit utiliser le module
existant (sinon, [Link]() ne fonctionnera pas correctement). Si le module considé ré n’est pas
trouvé dans [Link], le chargeur doit cré er un nouvel objet module et l’ajouter à [Link].
— Le module doit exister dans [Link] avant que le chargeur n’exé cute le code du module, afin d’é viter
les ré cursions infinies ou le chargement multiple.
— Si le chargement é choue, le chargeur ne doit enlever de [Link] que le (ou les) module ayant é choué
et seulement si le chargeur lui-mê me a chargé le module explicitement.
Modifié dans la version 3.5 : un avertissement DeprecationWarning est levé quand exec_module() est dé finie
mais create_module() ne l’est pas.
Modifié dans la version 3.6 : une exception ImportError est levé e quand exec_module() est dé finie mais
create_module() ne l’est pas.

Modifié dans la version 3.10 : l’utilisation de load_module() lè ve un ImportWarning.

5.4.2 Sous-modules
Quand un sous-module est chargé , quel que soit le mé canisme (par exemple avec les instructions import,
import-from ou avec la fonction native __import__()), une liaison est cré ée dans l’espace de nommage du mo-
dule parent vers l’objet sous-module. Par exemple, si le paquet spam possè de un sous-module foo, aprè s l’importation
de [Link], spam possè de un attribut foo qui est lié au sous-module. Supposons que nous ayons l’arborescence
suivante :

spam/
__init__.py
[Link]

et que le contenu de spam/__init__.py contienne :

from .foo import Foo

alors exé cuter les lignes suivantes cré e des liens vers foo et Foo dans le module spam :

70 Chapitre 5. Le système d’importation

 The Python Language Reference, Version 3.13.7

>>> import spam

>>> [Link]
<module '[Link]' from '/tmp/imports/spam/[Link]'>
>>> [Link]
<class '[Link]'>

Connaissant la façon habituelle dont Python effectue les liens, cela peut sembler surprenant. Mais c’est en fait une
fonctionnalité fondamentale du systè me d’importation. Si vous avez quelque part [Link]['spam'] et sys.
modules['[Link]'] (comme dans c’est le cas ci-dessus aprè s l’importation), alors le dernier doit apparaître
comme l’attribut foo du premier.

5.4.3 Spécificateurs de modules

Le mé canisme d’importation utilise diverses informations de chaque module pendant l’importation, spé cialement
avant le chargement. La plupart de ces informations sont communes à tous les modules. Le but d’un spé cificateur de
module est d’encapsuler ces informations relatives à l’importation au sein de chaque module.
Utiliser un spé cificateur pendant l’importation permet de transfé rer l’é tat entre les composants du systè me d’impor-
tation, par exemple entre le chercheur qui cré e le spé cificateur de module et le chargeur qui l’exé cute. Surtout, cela
permet au mé canisme d’importation d’effectuer toutes les opé rations classiques de chargement, alors que c’é tait le
chargeur qui en avait la responsabilité quand il n’y avait pas de spé cificateur.
L’attribut module.__spec__ doit contenir un lien vers le spé cificateur de module qui a é té utilisé lors de l’impor-
tation du module. Dé finir __spec__ correctement s’applique aussi lors de l’initialisation des modules au démarrage
de l’interpréteur. La seule exception est __main__ pour lequel la valeur de __spec__ peut être parfois None.
Lisez ModuleSpec pour davantage d’informations sur le contenu du spé cificateur de module.
Ajouté dans la version 3.4.

5.4.4 l’attribut __path__ des modules

L’attribut __path__ doit ê tre une sequence (possiblement vide) de chaînes de caractè res listant tous les emplacements
où se trouvent les sous-modules du paquet. Par dé finition, si un module a un attribut __path__ alors c’est un paquet
L’attribut __path__ d’un paquet est utilisé pendant l’importation de ses sous-paquets. Dans le mé canisme d’impor-
tation, son fonctionnement ressemble beaucoup à [Link], c’est-à -dire qu’il fournit une liste d’emplacements où
rechercher les modules pendant l’importation. Cependant, __path__ est beaucoup plus contraint que [Link].
Les mê mes rè gles que pour [Link] s’appliquent au __path__ d’un paquet. Les sys.path_hooks (dont la
description est donné e plus bas) sont consulté s pendant le parcours du __path__ du paquet.
Le fichier __init__.py d’un paquet peut dé finir ou modifier l’attribut __path__ d’un paquet, et c’est ainsi qu’é taient
implé menté s les paquets-espaces de nommage avant la PEP 420. Depuis l’adoption de la PEP 420, les paquets-
espaces de nommage n’ont plus besoin d’avoir des fichiers __init__.py qui ne font que de la manipulation de
__path__ ; le mé canisme d’importation dé finit automatiquement __path__ correctement pour un paquet-espace
de nommage.

5.4.5 Représentation textuelle d’un module

Par dé faut, tous les modules ont une repré sentation textuelle utilisable. Cependant, en utilisant les attributs dé finis
ci-dessus et dans le spé cificateur de module, vous pouvez explicitement mieux contrô ler l’affichage des objets modules.
Si le module possè de un spé cificateur (__spec__), le mé canisme d’importation essaie de gé né rer une repré sentation
avec celui-ci. S’il é choue ou s’il n’y a pas de spé cificateur, le systè me d’importation construit une repré sentation
par dé faut en utilisant toute information disponible sur le module. Il tente d’utiliser module.__name__, module.
__file__ et module.__loader__ comme entré es pour la repré sentation, avec des valeurs par dé faut lorsque
l’information est manquante.
Les rè gles exactes utilisé es sont :
— Si le module possè de un attribut __spec__, la valeur est utilisé e pour gé né rer la repré sentation. Les attributs
name, loader, origin et has_location sont consulté s.

5.4. Chargement 71
The Python Language Reference, Version 3.13.7

— Si le module possè de un attribut __file__, il est utilisé pour construire la repré sentation du module.
— Si le module ne possè de pas d’attribut __file__ mais possè de un __loader__ qui n’est pas None, alors la
repré sentation du chargeur est utilisé e pour construire la repré sentation du module.
— Sinon, il utilise juste le __name__ du module dans la repré sentation.
Modifié dans la version 3.12 : La mé thode module_repr() est obsolè te depuis Python 3.4, et a é té supprimé e en
Python 3.12 et n’est donc plus appelé e lors de la ré solution du __repr__() d’un module.

5.4.6 Invalidation de bytecode mis en cache

Avant que Python ne charge du bytecode en cache à partir d’un fichier .pyc, il vé rifie si ce cache est bien à jour par
rapport au fichier source .py. Python effectue cette vé rification en stockant l’horodatage de la derniè re modification
de la source ainsi que sa taille dans le fichier cache au moment où il l’é crit. À l’exé cution, le systè me d’importation
valide le fichier cache en comparant les mé tadonné es que le cache contient avec les mé tadonné es de la source.
Python gè re é galement les fichiers caches « avec empreintes », qui stockent une empreinte (hash en anglais) du
contenu de la source plutô t que des mé tadonné es. Il existe deux variations des fichiers .pyc avec empreintes : vé ri-
fié s et non-vé rifié s. Pour les fichiers .pyc avec empreinte vé rifié s, Python valide le fichier cache en calculant l’em-
preinte du fichier source et compare les empreintes. Si l’empreinte stocké e dans le fichier cache est invalide, Python
la recalcule et é crit un nouveau fichier cache avec empreinte. Pour les fichiers .pyc avec empreinte non vé rifié s,
Python considè re simplement que le fichier cache est valide s’il existe. La validation (ou non) des fichiers .pyc avec
empreinte peut ê tre dé finie avec l’option --check-hash-based-pycs.
Modifié dans la version 3.7 : ajout des fichiers .pyc avec empreinte. Auparavant, Python gé rait les caches de bytecode
sur la base de l’horodatage.

5.5 Le chercheur dans path

Comme indiqué pré cé demment, Python est livré par dé faut avec plusieurs chercheurs dans les mé ta-chemins. L’un
deux, appelé chercheur dans path (PathFinder), recherche dans le chemin des importations qui contient une liste
d’entrées dans path. Chaque entré e dé signe un emplacement où rechercher des modules.
Le chercheur dans path en tant que tel ne sait pas comment importer quoi que ce soit. Il ne fait que parcourir chaque
entré e de path et associe à chacune d’elle un « chercheur d’entré e dans path » qui sait comment gé rer le type particulier
de chemin considé ré .
L’ensemble par dé faut des « chercheurs d’entré e dans path » implé mente toute la sé mantique pour trouver des modules
dans le systè me de fichiers, gé rer des fichiers spé ciaux tels que le code source Python (fichiers .py), le bytecode
Python (fichiers .pyc) et les bibliothè ques partagé es (par exemple les fichiers .so). Quand le module zipimport
de la bibliothè que standard le permet, les « chercheurs d’entré e dans path » par dé faut savent aussi gé rer tous ces
types de fichiers (autres que les bibliothè ques partagé es) encapsulé s dans des fichiers zip.
Les chemins ne sont pas limité s au systè me de fichiers. Ils peuvent faire ré fé rence à des URL, des requê tes dans des
bases de donné es ou tout autre emplacement qui peut ê tre spé cifié dans une chaîne de caractè res.
Le chercheur dans path fournit aussi des points d’entré es (ou hooks) et des protocoles de maniè re à pouvoir é tendre
et personnaliser les types de chemins dans lesquels chercher. Par exemple, si vous voulez pouvoir chercher dans des
URL ré seau, vous pouvez é crire une fonction « point d’entré e » qui implé mente la sé mantique HTTP pour chercher
des modules sur la toile. Ce point d’entré e (qui doit ê tre un appelable) doit renvoyer un chercheur d’entrée dans path
qui gè re le protocole dé crit plus bas et qui sera utilisé pour obtenir un chargeur de module sur la toile.
Avertissement : cette section et la pré cé dente utilisent toutes les deux le terme chercheur, dans un cas chercheur
dans les méta-chemins et dans l’autre chercheur d’entrée dans path. Ces deux types de chercheurs sont trè s similaires,
gè rent des protocoles similaires et fonctionnent de maniè re semblable pendant le processus d’importation, mais il est
important de garder à l’esprit qu’ils sont subtilement diffé rents. En particulier, les chercheurs dans les mé ta-chemins
opè rent au dé but du processus d’importation, comme clé de parcours de sys.meta_path.
Au contraire, les « chercheurs d’entré e dans path » sont, dans un sens, un dé tail d’implé mentation du chercheur dans
path et, en fait, si le chercheur dans path é tait enlevé de sys.meta_path, aucune des sé mantiques des « chercheurs
d’entré e dans path » ne serait invoqué e.

72 Chapitre 5. Le système d’importation

 The Python Language Reference, Version 3.13.7

5.5.1 Chercheurs d’entrée dans path

Le chercheur dans path (path based finder en anglais) est responsable de trouver et charger les modules et les paquets
Python dont l’emplacement est spé cifié par une chaîne dite d’entrée dans path. La plupart de ces entré es dé signent
des emplacements sur le systè me de fichiers, mais il n’y a aucune raison de les limiter à ça.
En tant que chercheur dans les mé ta-chemins, un chercheur dans path implé mente le protocole find_spec() dé crit
pré cé demment. Cependant, il autorise des points d’entré e (hooks en anglais) supplé mentaires qui peuvent ê tre utilisé s
pour personnaliser la façon dont les modules sont trouvé s et chargé s depuis le chemin des importations.
Trois variables sont utilisé es par le chercheur dans path : [Link], sys.path_hooks et sys.
path_importer_cache. L’attribut __path__ des objets paquets est aussi utilisé . Il permet de personnaliser
encore davantage le mé canisme d’importation.
[Link] contient une liste de chaînes de caractè res indiquant des emplacements où chercher des modules ou des
paquets. Elle est initialisé e à partir de la variable d’environnement PYTHONPATH et de plusieurs autres valeurs par
dé faut qui dé pendent de l’installation et de l’implé mentation. Les entré es de [Link] dé signent des ré pertoires du
systè me de fichiers, des fichiers zip et possiblement d’autres « endroits » (lisez le module site) tels que des URL ou
des requê tes dans des bases de donné es où Python doit rechercher des modules. [Link] ne doit contenir que des
chaînes de caractè res ; tous les autres types sont ignoré s.
Le chercheur dans path est un chercheur dans les méta-chemins, donc le mé canisme d’importation commence la
recherche dans le chemin des importations par un appel à la mé thode find_spec() du chercheur dans path, comme
dé crit pré cé demment. Quand l’argument path de find_spec() est donné , c’est une liste de chemins à parcourir,
typiquement un attribut __path__ pour une importation à l’inté rieur d’un paquet. Si l’argument path est None, cela
indique une importation de niveau le plus haut et [Link] est utilisé e.
Le chercheur dans path itè re sur chaque entré e dans le path et, pour chacune, regarde s’il trouve un chercheur d’entrée
dans path (PathEntryFinder) approprié à cette entré e. Comme cette opé ration est coû teuse (elle peut faire appel
à plusieurs appels stat() pour cela), le chercheur dans path maintient un cache de correspondance entre les entré es
et les « chercheurs d’entré e dans path ». Ce cache est stocké sous sys.path_importer_cache (en dé pit de son
nom, ce cache stocke les objets chercheurs plutô t que les simples objets importateurs). Ainsi, la recherche coû teuse
pour une entrée de path spé cifique n’a besoin d’ê tre effectué e qu’une seule fois par le chercheur d’entrée dans path.
Le code de l’utilisateur peut trè s bien supprimer les entré es du cache sys.path_importer_cache, forçant ainsi
le chercheur dans path à effectuer une nouvelle fois la recherche sur chaque entré e.
Si une entré e n’est pas pré sente dans le cache, le chercheur dans path itè re sur chaque callable de sys.path_hooks.
Chaque point d’entrée sur une entrée de path de cette liste est appelé avec un unique argument, l’entré e dans laquelle
chercher. L’appelable peut soit renvoyer un chercheur d’entrée dans path apte à prendre en charge l’entré e ou lever
une ImportError. Une ImportError est utilisé e par le chercheur dans path pour signaler que le point d’entré e
n’a pas trouvé de chercheur d’entrée dans path pour cette entrée. L’exception est ignoré e et l’ité ration sur le chemin
des importations se poursuit. Le point d’entré e doit attendre qu’on lui passe soit une chaîne de caractè res soit une
chaîne d’octets ; l’encodage des chaînes d’octets est à la main du point d’entré e (par exemple, ce peut ê tre l’encodage
du systè me de fichiers, de l’UTF-8 ou autre chose) et, si le point d’entré e n’arrive pas à dé coder l’argument, il doit
lever une ImportError.
Si l’ité ration sur sys.path_hooks se termine sans qu’aucun chercheur d’entrée dans path ne soit renvoyé , alors la
mé thode find_spec() du chercheur dans path stocke None dans le sys.path_importer_cache (pour indiquer
qu’il n’y a pas de chercheur pour cette entré e) et renvoie None, indiquant que ce chercheur dans les méta-chemins n’a
pas trouvé le module.
Si un chercheur d’entrée dans path est renvoyé par un des points d’entrée de sys.path_hooks, alors le protocole
suivant est utilisé pour demander un spé cificateur de module au chercheur, spé cificateur qui sera utilisé pour charger
le module.
Le ré pertoire de travail courant — noté sous la forme d’une chaîne de caractè res vide — est gé ré d’une maniè re
lé gè rement diffé rente des autres entré es de [Link]. D’abord, si le ré pertoire de travail courant s’avè re ne pas
exister, aucune valeur n’est stocké e dans sys.path_importer_cache. Ensuite, la valeur pour le ré pertoire de tra-
vail courant est vé rifié e à chaque recherche de module. Enfin, le chemin utilisé pour sys.path_importer_cache
et renvoyé e par [Link].find_spec() est le nom ré el du ré pertoire de travail
courant et non pas la chaîne vide.

5.5. Le chercheur dans path 73

The Python Language Reference, Version 3.13.7

5.5.2 Protocole des chercheurs d’entrée dans path

Afin de gé rer les importations de modules, l’initialisation des paquets et d’ê tre capables de contribuer aux portions
des paquets-espaces de nommage, les chercheurs d’entré e dans path doivent implé menter la mé thode find_spec().
La mé thode find_spec() prend deux arguments : le nom complè tement qualifié du module en cours d’importa-
tion et (optionnellement) le module cible. find_spec() renvoie un spé cificateur de module pleinement peuplé . Ce
spé cificateur doit avoir son chargeur (attribut loader) dé fini, à une exception prè s.
Pour indiquer au mé canisme d’importation que le spé cificateur repré sente une portion d’un espace de nommage, le
chercheur d’entré e dans path dé finit l’attribut submodule_search_locations à une liste contenant la portion.
Modifié dans la version 3.4 : la mé thode find_spec() remplace find_loader() et find_module(), ces deux
mé thodes é tant doré navant obsolè tes mais restant utilisé es si find_spec() n’est pas dé finie.
Les vieux chercheurs d’entré e dans path peuvent implé menter une des deux mé thodes obsolè tes à la place de
find_spec(). Ces mé thodes sont toujours prises en compte dans le cadre de la compatibilité descendante. Cepen-
dant, si find_spec() est implé menté e par le chercheur d’entré e dans path, les mé thodes historiques sont ignoré es.
La mé thode find_loader() prend un argument : le nom complè tement qualifié du module en cours d’importation.
find_loader() renvoie un couple dont le premier é lé ment est le chargeur et le second est une portion d’espace de
nommage.
À fin de compatibilité descendante avec d’autres implé mentations du protocole d’importation, beaucoup de chercheurs
d’entré e dans path gè rent aussi la mé thode traditionnelle find_module() que l’on trouve dans les chercheurs dans les
mé ta-chemins. Cependant, les mé thodes find_module() des chercheurs d’entré e dans path ne sont jamais appelé es
avec un argument path (il est convenu qu’elles enregistrent les informations relatives au chemin approprié au moment
de leur appel initial au point d’entré e).
La mé thode find_module() des chercheurs d’entré e dans path est obsolè te car elle n’autorise pas le chercheur
d’entré e dans path à contribuer aux portions d’espaces de nommage des paquets-espaces de nommage. Si à la fois
find_loader() et find_module() sont dé finies pour un chercheur d’entré e dans path, le systè me d’importation
utilise toujours find_loader() plutô t que find_module().
Modifié dans la version 3.10 : Les appels à find_module() et find_loader() par le systè me d’importation lè vent
un ImportWarning.
Modifié dans la version 3.12 : find_module() et find_loader() ont é té supprimé es.

5.6 Remplacement du système d’importation standard

La maniè re la plus fiable de remplacer tout le systè me d’importation est de supprimer le contenu par dé faut de sys.
meta_path et de le remplacer complè tement par un chercheur dans les mé ta-chemins sur mesure.

S’il convient juste de modifier le comportement de l’instruction import sans affecter les autres API qui utilisent le
systè me d’importation, alors remplacer la fonction native __import__() peut ê tre suffisant. Cette technique peut
aussi ê tre employé e au niveau d’un module pour n’alté rer le comportement des importations qu’à l’inté rieur de ce
module.
Pour empê cher sé lectivement l’importation de certains modules par un point d’entré e placé en tê te dans
le mé ta-chemin (plutô t que de dé sactiver complè tement le systè me d’importation), il suffit de lever une
ModuleNotFoundError directement depuis find_spec() au lieu de renvoyer None. En effet, ce dernier indique
que la recherche dans le mé ta-chemin peut continuer alors que la levé e de l’exception termine immé diatement la
recherche.

5.7 Importations relatives au paquet

Les importations relatives commencent par une suite de points. Un seul point avant indique une importation relative,
dé marrant avec le paquet actuel. Deux points ou plus avant indiquent une importation relative au parent du paquet
actuel, un niveau par point avant le premier. Par exemple, en ayant le contenu suivant :

74 Chapitre 5. Le système d’importation

 The Python Language Reference, Version 3.13.7

package/
__init__.py
subpackage1/
__init__.py
[Link]
[Link]
subpackage2/
__init__.py
[Link]
[Link]

Dans subpackage1/[Link] ou subpackage1/__init__.py, les importations suivantes sont des impor-

tations relatives valides :

from .moduleY import spam

from .moduleY import spam as ham
from . import moduleY
from ..subpackage1 import moduleY
from ..[Link] import eggs
from ..moduleA import foo

Les importations absolues peuvent utiliser soit la syntaxe import <>, soit from <> import <>, mais les impor-
tations relatives doivent seulement utiliser la deuxiè me forme, la raison é tant :

import [Link]

doit exposer [Link] comme une expression utilisable, mais .moduleY n’est pas une expression valide.

5.8 Cas particulier de __main__

Le module __main__ est un cas particulier pour le systè me d’importation de Python. Comme indiqué par ailleurs, le
module __main__ est initialisé directement au dé marrage de l’interpré teur, un peu comme sys et builtins. Ce-
pendant, au contraire des deux cité s pré cé demment, ce n’est pas vraiment un module natif. Effectivement, la maniè re
dont est initialisé __main__ dé pend des drapeaux et options avec lesquels l’interpré teur est lancé .

5.8.1 __main__.__spec__
En fonction de la maniè re dont __main__ est initialisé , __main__.__spec__ est dé fini de maniè re conforme ou
mis à None.
Quand Python est dé marré avec l’option -m, __spec__ est dé fini à la valeur du spé cificateur du module ou paquet
correspondant. Python peuple aussi __spec__ quand le module __main__ est chargé en tant que partie de l’exé cution
d’un ré pertoire, d’un fichier zip ou d’une entré e de [Link].
Dans les autres cas, __main__.__spec__ est mis à None, car le code qui peuple __main__ ne trouve pas de
correspondance directe avec un module que l’on importe :
— invite de commande interactive
— l’option -c
— lecture depuis l’entré e standard
— lecture depuis un fichier de code source ou de bytecode
Notez que __main__.__spec__ vaut toujours None dans le dernier cas, même si le fichier pourrait techniquement
ê tre importé directement en tant que module. Utilisez l’option -m si vous souhaitez disposer de mé tadonné es valides
du module dans __main__.
Notez aussi que mê me quand __main__ correspond à un module importable et que __main__.__spec__ est dé fini
en consé quence, ils seront toujours considé ré s comme des modules distincts. Cela est dû au fait que le bloc encadré par
if __name__ == "__main__": ne s’exé cute que quand le module est utilisé pour peupler l’espace de nommage
de __main__, et pas durant une importation normale.

5.8. Cas particulier de __main__ 75

The Python Language Reference, Version 3.13.7

5.9 Références
Le mé canisme d’importation a considé rablement é volué depuis les dé buts de Python. La spé cification des paquets
originale est toujours disponible, bien que quelques dé tails ont changé depuis l’é criture de ce document.
La spé cification originale de sys.meta_path se trouve dans la PEP 302. La PEP 420 contient des extensions
significatives.
La PEP 420 a introduit les paquets-espaces de nommage pour Python 3.3. La PEP 420 a aussi introduit le protocole
find_loader() comme une alternative à find_module().

La PEP 366 dé crit l’ajout de l’attribut __package__ pour les importations relatives explicites dans les modules
principaux.
La PEP 328 a introduit les importations absolues et les importations relatives explicites. Elle a aussi proposé
__name__ pour la sé mantique que la PEP 366 attribuait à __package__.
PEP 338 dé finit l’exé cution de modules en tant que scripts.
PEP 451 ajoute l’encapsulation dans les objets spé cificateurs de l’é tat des importations, module par module. Elle
reporte aussi la majorité des responsabilité s des chargeurs vers le mé canisme d’importation. Ces changements per-
mettent de supprimer plusieurs API dans le systè me d’importation et d’ajouter de nouvelles mé thodes aux chercheurs
et chargeurs.

Notes

76 Chapitre 5. Le système d’importation

 CHAPITRE 6

Expressions

Ce chapitre explique la signification des é lé ments des expressions en Python.

Notes sur la syntaxe : dans ce chapitre et le suivant, nous utilisons la notation BNF é tendue pour dé crire la syntaxe,
pas l’analyse lexicale. Quand une rè gle de syntaxe est de la forme

name ::= othername

et qu’aucune sé mantique n’est donné e, la sé mantique de name est la mê me que celle de othername.

6.1 Conversions arithmétiques

Quand la description d’un opé rateur arithmé tique ci-dessous utilise la phrase « les arguments numé riques sont conver-
tis vers un type commun », cela signifie que l’implé mentation de l’opé rateur fonctionne de la maniè re suivante pour
les types natifs :
— Si l’un des deux arguments est du type nombre complexe, l’autre est converti en nombre complexe ;
— otherwise, if either argument is a floating-point number, the other is converted to floating point ;
— sinon, les deux doivent ê tre des entiers et aucune conversion n’est né cessaire.
Des rè gles supplé mentaires s’appliquent pour certains opé rateurs (par exemple, une chaîne comme opé rande de
gauche pour l’opé rateur %). Les extensions doivent dé finir leurs propres rè gles de conversion.

6.2 Atomes
Les atomes sont les é lé ments de base des expressions. Les atomes les plus simples sont les identifiants et les litté raux.
Les expressions entre parenthè ses, crochets ou accolades sont aussi classé es syntaxiquement comme des atomes. La
syntaxe pour les atomes est :

atom ::= identifier | literal | enclosure

enclosure ::= parenth_form | list_display | dict_display | set_display
| generator_expression | yield_atom

6.2.1 Identifiants (noms)

Un identifiant qui apparaît en tant qu’atome est un nom. Lisez la section Identifiants et mots-clés pour la dé finition
lexicale et la section Noms et liaisons pour la documentation sur les noms et les liaisons affé rentes.
Quand un nom est lié à un objet, l’é valuation de l’atome produit cet objet. Quand le nom n’est pas lié , toute tentative
de l’é valuer lè ve une exception NameError.

77
The Python Language Reference, Version 3.13.7

Private name mangling

When an identifier that textually occurs in a class definition begins with two or more underscore characters and does
not end in two or more underscores, it is considered a private name of that class.

µ Voir aussi

The class specifications.

More precisely, private names are transformed to a longer form before code is generated for them. If the transformed
name is longer than 255 characters, implementation-defined truncation may happen.
The transformation is independent of the syntactical context in which the identifier is used but only the following
private identifiers are mangled :
— Any name used as the name of a variable that is assigned or read or any name of an attribute being accessed.
The __name__ attribute of nested functions, classes, and type aliases is however not mangled.
— The name of imported modules, e.g., __spam in import __spam. If the module is part of a package (i.e.,
its name contains a dot), the name is not mangled, e.g., the __foo in import __foo.bar is not mangled.
— The name of an imported member, e.g., __f in from spam import __f.
The transformation rule is defined as follows :
— The class name, with leading underscores removed and a single leading underscore inserted, is inserted in front
of the identifier, e.g., the identifier __spam occurring in a class named Foo, _Foo or __Foo is transformed
to _Foo__spam.
— If the class name consists only of underscores, the transformation is the identity, e.g., the identifier __spam
occurring in a class named _ or __ is left as is.

6.2.2 Littéraux
Python gè re les litté raux de chaînes de caractè res, de chaînes d’octets et de plusieurs autres types numé riques :

literal ::= stringliteral | bytesliteral

| integer | floatnumber | imagnumber

Evaluation of a literal yields an object of the given type (string, bytes, integer, floating-point number, complex number)
with the given value. The value may be approximated in the case of floating-point and imaginary (complex) literals.
See section Littéraux for details.
Tous les litté raux sont de types immuables et donc l’identifiant de l’objet est moins important que sa valeur. Des
é valuations multiples de litté raux avec la mê me valeur (soit la mê me occurrence dans le texte du programme, soit
une autre occurrence) ré sultent dans le mê me objet ou un objet diffé rent avec la mê me valeur.

6.2.3 Formes parenthésées

Une forme parenthé sé e est une liste d’expressions (cette liste est en fait optionnelle) placé e à l’inté rieur de parenthè ses :

parenth_form ::= "(" [starred_expression] ")"

Une liste d’expressions entre parenthè ses produit ce que la liste de ces expressions produirait : si la liste contient au
moins une virgule, elle produit un n-uplet (type n-uplet) ; sinon, elle produit l’expression elle-mê me (qui constitue
donc elle-mê me la liste d’expressions).
Une paire de parenthè ses vide produit un objet n-uplet vide. Comme les n-uplets sont immuables, la mê me rè gle que
pour les litté raux s’applique (c’est-à -dire que deux occurrences du n-uplet vide peuvent, ou pas, produire le mê me
objet).
Notez que les n-uplets ne sont pas cré és par les parenthè ses mais par l’utilisation de la virgule. L’exception est le n-
uplet vide, pour lequel les parenthè ses sont requises (autoriser que « rien » ne soit pas parenthé sé dans les expressions
aurait gé né ré des ambigü ité s et aurait permis à certaines coquilles de passer inaperçu).

78 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

6.2.4 Agencements des listes, ensembles et dictionnaires

Pour construire une liste, un ensemble ou un dictionnaire, Python fournit des syntaxes spé ciales dites « agencements »
(displays en anglais), chaque agencement comportant deux variantes :
— soit le contenu du conteneur est listé explicitement,
— soit il est calculé à l’aide de la combinaison d’une boucle et d’instructions de filtrage, appelé e une compréhen-
sion (dans le sens de ce qui sert à dé finir un concept, par opposition à extension).
Les compré hensions sont constitué es des é lé ments de syntaxe communs suivants :

comprehension ::= assignment_expression comp_for

comp_for ::= ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter ::= comp_for | comp_if
comp_if ::= "if" or_test [comp_iter]

Une compré hension est constitué e par une seule expression suivie par au moins une clause for et zé ro ou plus clauses
for ou if. Dans ce cas, les é lé ments du nouveau conteneur sont ceux qui auraient é té produits si l’on avait considé ré
toutes les clauses for ou if comme des blocs, imbriqué s de la gauche vers la droite, et é valué l’expression pour
produire un é lé ment à chaque fois que le bloc le plus imbriqué é tait atteint.
Cependant, à part l’expression de l’ité rable dans la clause for la plus à gauche, la compré hension est exé cuté e dans
une porté e sé paré e, implicitement imbriqué e. Ceci assure que les noms assigné s dans la liste cible ne « fuient » pas
en dehors de cette porté e.
L’expression de l’ité rable dans la clause for la plus à gauche est é valué e directement dans la porté e englobante puis
passé e en tant qu’argument à la porté e implicite imbriqué e. Les clauses for suivantes et les filtres conditionnels de
la clause for la plus à gauche ne peuvent pas ê tre é valué s dans la porté e englobante, car ils peuvent dé pendre de
valeurs obtenues à partir de l’ité rable le plus à gauche. Par exemple : [x*y for x in range(10) for y in
range(x, x+10)].

Pour assurer que le ré sultat de la compré hension soit un conteneur du type approprié , les expressions yield et yield
from sont interdites dans la porté e implicite imbriqué e.

Since Python 3.6, in an async def function, an async for clause may be used to iterate over a asynchronous
iterator. A comprehension in an async def function may consist of either a for or async for clause following
the leading expression, may contain additional for or async for clauses, and may also use await expressions.
If a comprehension contains async for clauses, or if it contains await expressions or other asynchronous com-
prehensions anywhere except the iterable expression in the leftmost for clause, it is called an asynchronous compre-
hension. An asynchronous comprehension may suspend the execution of the coroutine function in which it appears.
See also PEP 530.
Ajouté dans la version 3.6 : Les compré hensions asynchrones ont é té introduites.
Modifié dans la version 3.8 : yield et yield from sont interdites dans la porté e implicite imbriqué e.
Modifié dans la version 3.11 : les compré hensions asynchrones sont maintenant autorisé es dans les compré hensions
des fonctions asynchrones. Les compré hensions englobantes deviennent implicitement asynchrones.

6.2.5 Agencements de listes

Un agencement de liste est une suite (possiblement vide) d’expressions à l’inté rieur de crochets :

list_display ::= "[" [flexible_expression_list | comprehension] "]"

Un agencement de liste produit un nouvel objet liste, dont le contenu est spé cifié soit par une liste d’expression soit
par une compré hension. Quand une liste d’expressions (dont les é lé ments sont sé paré s par des virgules) est fournie,
ces é lé ments sont é valué s de la gauche vers la droite et placé s dans l’objet liste, dans cet ordre. Quand c’est une
compré hension qui est fournie, la liste est construite à partir des é lé ments produits par la compré hension.

6.2. Atomes 79
The Python Language Reference, Version 3.13.7

6.2.6 Agencements d’ensembles

Un agencement d’ensemble (type set) est dé limité par des accolades et se distingue de l’agencement d’un dictionnaire
par le fait qu’il n’y a pas de « deux points » : pour sé parer les clé s et les valeurs :

set_display ::= "{" (flexible_expression_list | comprehension) "}"

Un agencement d’ensemble produit un nouvel objet ensemble mutable, le contenu é tant spé cifié soit par une sé quence
d’expression, soit par une compré hension. Quand une liste (dont les é lé ments sont sé paré s par des virgules) est fournie,
ses é lé ments sont é valué s de la gauche vers la droite et ajouté s à l’objet ensemble. Quand une compré hension est
fournie, l’ensemble est construit à partir des é lé ments produits par la compré hension.
Un ensemble vide ne peut pas ê tre construit par {} ; cette é criture construit un dictionnaire vide.

6.2.7 Agencements de dictionnaires

Un agencement de dictionnaire est une sé rie (possiblement vide) de couples clé s-valeurs entouré e par des accolades :

dict_display ::= "{" [dict_item_list | dict_comprehension] "}"

dict_item_list ::= dict_item ("," dict_item)* [","]
dict_item ::= expression ":" expression | "**" or_expr
dict_comprehension ::= expression ":" expression comp_for

Un agencement de dictionnaire produit un nouvel objet dictionnaire.

Si une sé quence (dont les é lé ments sont sé paré s par des virgules) de couples clé s-valeurs est fournie, les couples
sont é valué s de la gauche vers la droite pour dé finir les entré es du dictionnaire : chaque objet clé est utilisé comme
clé dans le dictionnaire pour stocker la valeur correspondante. Cela signifie que vous pouvez spé cifier la mê me clé
plusieurs fois dans la liste des couples clé s-valeurs et, dans ce cas, la valeur finalement stocké e dans le dictionnaire
est la derniè re donné e.
Une double asté risque ** demande de dépaqueter le dictionnaire. L’opé rande doit ê tre un tableau de correspondances.
Chaque é lé ment du tableau de correspondances est ajouté au nouveau dictionnaire. Les valeurs les plus ré centes rem-
placent les valeurs dé jà dé finies par des couples clé s-valeurs anté rieurs ou par d’autres dé paquetages de dictionnaires
anté rieurs.
Ajouté dans la version 3.5 : le dé paquetage peut se faire vers un agencement de dictionnaire, proposé à l’origine par
la PEP 448.
Une compré hension de dictionnaire, au contraire des compré hensions de listes ou d’ensembles, requiert deux expres-
sions sé paré es par une virgule et suivies par les clauses usuelles ”for” et ”if”. Quand la compré hension est exé cuté e,
les é lé ments clé s-valeurs sont insé ré s dans le nouveau dictionnaire dans l’ordre dans lequel ils sont produits.
Les restrictions relatives aux types des clé s sont donné es dans la section Hiérarchie des types standards (pour ré sumer,
le type de la clé doit ê tre hachable, ce qui exclut tous les objets mutables). Les collisions entre les clé s dupliqué es ne
sont pas dé tecté es ; la derniè re valeur (celle qui apparaît le plus à droite dans l’agencement) stocké e pré vaut pour une
clé donné e.
Modifié dans la version 3.8 : Avant Python 3.8, dans les compré hensions de dictionnaires, l’ordre d’é valuation entre
les clé s et les valeurs n’é tait pas bien dé fini. Dans CPython, la valeur é tait é valué e avant la clé . À partir de la version
3.8, la clé est é valué e avant la valeur, comme proposé par la PEP 572.

6.2.8 Expressions génératrices

Une expression gé né ratrice est une notation concise pour un gé né rateur, entouré e de parenthè ses :

generator_expression ::= "(" expression comp_for ")"

Une expression gé né ratrice produit un nouvel objet gé né rateur. Sa syntaxe est la mê me que celle des compré hensions,
sauf qu’elle est entouré e de parenthè ses au lieu de crochets ou d’accolades.
Variables used in the generator expression are evaluated lazily when the __next__() method is called for the gene-
rator object (in the same fashion as normal generators). However, the iterable expression in the leftmost for clause
is immediately evaluated, and the iterator is immediately created for that iterable, so that an error produced while

80 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

creating the iterator will be emitted at the point where the generator expression is defined, rather than at the point
where the first value is retrieved. Subsequent for clauses and any filter condition in the leftmost for clause cannot be
evaluated in the enclosing scope as they may depend on the values obtained from the leftmost iterable. For example :
(x*y for x in range(10) for y in range(x, x+10)).

Les parenthè ses peuvent ê tre omises pour les appels qui ne possè dent qu’un seul argument. Voir la section Appels
pour les dé tails.
Pour é viter d’interfé rer avec l’opé ration attendue de l’expression gé né ratrice elle-mê me, les expressions yield et
yield from sont interdites dans les gé né rateurs dé finis de maniè re implicite.

Si une expression gé né ratrice contient une ou des expressions async for ou await, elle est appelé e expression
génératrice asynchrone. Une expression gé né ratrice asynchrone produit un nouvel objet gé né rateur asynchrone qui
est un ité rateur asynchrone (voir Itérateurs asynchrones).
Ajouté dans la version 3.6 : les expressions gé né ratrices asynchrones ont é té introduites.
Modifié dans la version 3.7 : Avant Python 3.7, les expressions gé né ratrices asynchrones ne pouvaient apparaître que
dans les coroutines async def . À partir de la version 3.7, toute fonction peut utiliser des expressions gé né ratrices
asynchrones.
Modifié dans la version 3.8 : yield et yield from sont interdites dans la porté e implicite imbriqué e.

6.2.9 Expressions yield

yield_atom ::= "(" yield_expression ")"

yield_from ::= "yield" "from" expression
yield_expression ::= "yield" yield_list | yield_from
Une expression yield est utilisé e pour dé finir une fonction génératrice ou une fonction génératrice asynchrone et ne
peut donc ê tre utilisé e que dans le corps de la dé finition d’une fonction. L’utilisation d’une expression yield dans
le corps d’une fonction entraîne que cette fonction devient une fonction gé né ratrice et son utilisation dans le corps
d’une fonction async def entraine que cette fonction coroutine devient une fonction gé né ratrice asynchrone. Par
exemple :

def gen(): # defines a generator function

yield 123

async def agen(): # defines an asynchronous generator function

yield 123

En raison des effets de bords sur la porté e contenant, les expressions yield ne sont pas autorisé es dans la porté e
implicite utilisé e dans l’implé mentation des compré hensions et des expressions gé né ratrices.
Modifié dans la version 3.8 : Les expressions yield sont interdites dans la porté e implicite imbriqué e utilisé e dans
l’implé mentation des compré hensions et des expressions gé né ratrices.
Les fonctions gé né ratrices sont dé crites plus loin alors que les fonctions gé né rateurs asynchrones sont dé crites sé pa-
ré ment dans la section Fonctions génératrices asynchrones.
When a generator function is called, it returns an iterator known as a generator. That generator then controls the
execution of the generator function. The execution starts when one of the generator’s methods is called. At that time,
the execution proceeds to the first yield expression, where it is suspended again, returning the value of yield_list
to the generator’s caller, or None if yield_list is omitted. By suspended, we mean that all local state is retained,
including the current bindings of local variables, the instruction pointer, the internal evaluation stack, and the state
of any exception handling. When the execution is resumed by calling one of the generator’s methods, the function
can proceed exactly as if the yield expression were just another external call. The value of the yield expression after
resuming depends on the method which resumed the execution. If __next__() is used (typically via either a for
or the next() builtin) then the result is None. Otherwise, if send() is used, then the result will be the value passed
in to that method.
Tout ceci rend les fonctions gé né ratrices trè s similaires aux coroutines : elles produisent plusieurs objets via des
expressions yield, elles possè dent plus qu’un seul point d’entré e et leur exé cution peut ê tre suspendue. La seule

6.2. Atomes 81
The Python Language Reference, Version 3.13.7

diffé rence est qu’une fonction gé né ratrice ne peut pas contrô ler où l’exé cution doit se poursuivre aprè s une instruction
yield ; ce contrô le est toujours du ressort de l’appelant au gé né rateur.

Les expressions yield sont autorisé es partout dans un bloc try . Si l’exé cution du gé né rateur ne reprend pas avant
qu’il ne soit finalisé (parce que son compteur de ré fé rence est tombé à zé ro ou parce qu’il est nettoyé par le ramasse-
miettes), la mé thode close() du gé né rateur-ité rateur est appelé e, ce qui permet l’exé cution de toutes les clauses
finally en attente.

L’expression passé e à yield from <expr> doit ê tre un ité rateur. Toutes les valeurs produites par cet ité rateur
sont directement passé es à l’appelant des mé thodes du gé né rateur courant. Toute valeur passé e par send() ou toute
exception passé e par throw() est transmise à l’ité rateur sous-jacent s’il possè de les mé thodes approprié es. Si ce n’est
pas le cas, alors send() lè ve une AttributeError ou une TypeError, alors que throw() ne fait que propager
l’exception immé diatement.
Quand l’ité rateur sous-jacent a terminé , l’attribut value de l’instance StopIteration qui a é té levé e devient la
valeur produite par l’expression yield. Elle peut ê tre dé finie explicitement quand vous levez StopIteration ou
automatiquement que le sous-ité rateur est un gé né rateur (en renvoyant une valeur par le sous-gé né rateur).
Modifié dans la version 3.3 : yield from <expr> a é té ajouté e pour dé lé guer le contrô le du flot d’exé cution à un
sous-ité rateur.
Les parenthè ses peuvent ê tre omises quand l’expression yield est la seule expression à droite de l’instruction de
l’instruction d’affectation.

µ Voir aussi

PEP 255 : générateurs simples

La proposition d’ajouter à Python des gé né rateurs et l’instruction yield.
PEP 342 -- Coroutines via des générateurs améliorés
Proposition d’amé liorer l’API et la syntaxe des gé né rateurs, de maniè re à pouvoir les utiliser comme de
simples coroutines.
PEP 380 -- Syntaxe pour déléguer à un sous-générateur
Proposition d’introduire la syntaxe yield_from, de maniè re à dé lé guer facilement l’exé cution à un sous-
gé né rateur.
PEP 525 : Générateurs asynchrones
La proposition qui a amé lioré la PEP 492 en ajoutant des capacité s de gé né rateur pour les coroutines.

Méthodes des générateurs-itérateurs

Cette sous-section dé crit les mé thodes des gé né rateurs-ité rateurs. Elles peuvent ê tre utilisé es pour contrô ler l’exé cu-
tion des fonctions gé né ratrices.
Notez que l’appel à une mé thode ci-dessous d’un gé né rateur alors que le gé né rateur est dé jà en cours d’exé cution lè ve
une exception ValueError.
generator.__next__()
Starts the execution of a generator function or resumes it at the last executed yield expression. When a generator
function is resumed with a __next__() method, the current yield expression always evaluates to None. The
execution then continues to the next yield expression, where the generator is suspended again, and the value of
the yield_list is returned to __next__()’s caller. If the generator exits without yielding another value, a
StopIteration exception is raised.
Cette mé thode est normalement appelé e implicitement, par exemple par une boucle for ou par la fonction
native next().
[Link](value)
Reprend l’exé cution et « envoie » une valeur à la fonction gé né ratrice. L’argument value devient le ré sultat de
l’expression yield courante. La mé thode send() renvoie la valeur suivante produite par le gé né rateur ou lè ve
StopIteration si le gé né rateur termine sans produire de nouvelle valeur. Quand send() est utilisé e pour

82 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

dé marrer le gé né rateur, elle doit avoir None comme argument, car il n’y a aucune expression yield qui peut
recevoir la valeur.
[Link](value)
[ [
[Link](type , value , traceback ]])
Lè ve une exception à l’endroit où le gé né rateur est en pause et renvoie la valeur suivante produite par la fonction
gé né ratrice. Si le gé né rateur termine sans produire de nouvelle valeur, une exception StopIteration est
levé e. Si la fonction gé né ratrice ne gè re pas l’exception passé e ou lè ve une autre exception, alors cette exception
est propagé e vers l’appelant.
Dans son utilisation typique, elle est appelé e avec une seule instance d’exception, de façon similaire à l’utilisation
du mot-clé raise.
Cependant, pour assurer la ré trocompatibilité , la deuxiè me signature est prise en charge, suivant une convention
des anciennes versions de Python. L’argument type doit ê tre une classe d’exception et value doit ê tre une instance
d’exception. Si value n’est pas fournie, le constructeur de type est appelé pour obtenir une instance. Si traceback
est fournie, elle est lié e sur l’exception, sinon tout attribut __traceback__ existant stocké dans value est
possiblement effacé .
Modifié dans la version 3.12 : The second signature (type[, value[, traceback]]) is deprecated and may be
removed in a future version of Python.
[Link]()
Raises a GeneratorExit exception at the point where the generator function was paused (equivalent to calling
throw(GeneratorExit)). The exception is raised by the yield expression where the generator was paused.
If the generator function catches the exception and returns a value, this value is returned from close(). If
the generator function is already closed, or raises GeneratorExit (by not catching the exception), close()
returns None. If the generator yields a value, a RuntimeError is raised. If the generator raises any other
exception, it is propagated to the caller. If the generator has already exited due to an exception or normal exit,
close() returns None and has no other effect.

Modifié dans la version 3.13 : If a generator returns a value upon being closed, the value is returned by
close().

Exemples
Voici un exemple simple qui montre le comportement des gé né rateurs et des fonctions gé né ratrices :

>>> def echo(value=None):

... print("Execution starts when 'next()' is called for the first time.")
... try:
... while True:
... try:
... value = (yield value)
... except Exception as e:
... value = e
... finally:
... print("Don't forget to clean up when 'close()' is called.")
...
>>> generator = echo(1)
>>> print(next(generator))
Execution starts when 'next()' is called for the first time.
1
>>> print(next(generator))
None
>>> print([Link](2))
2
>>> [Link](TypeError, "spam")
TypeError('spam',)
(suite sur la page suivante)

6.2. Atomes 83
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

>>> [Link]()
Don't forget to clean up when 'close()' is called.

Pour des exemples d’utilisation de yield from, lisez la pep-380 dans « Les nouveauté s de Python ».

Fonctions génératrices asynchrones

La pré sence d’une expression yield dans une fonction ou une mé thode dé finie en utilisant async def transforme
cette fonction en fonction générateur asynchrone.
Quand une fonction gé né ratrice asynchrone est appelé e, elle renvoie un ité rateur asynchrone, autrement appelé objet
gé né rateur asynchrone. Cet objet contrô le l’exé cution de la fonction gé né ratrice. Un objet gé né rateur asynchrone est
typiquement utilisé dans une instruction async for à l’inté rieur d’une fonction coroutine de la mê me maniè re qu’un
objet gé né rateur serait utilisé dans une instruction for.
Calling one of the asynchronous generator’s methods returns an awaitable object, and the execution starts when this
object is awaited on. At that time, the execution proceeds to the first yield expression, where it is suspended again,
returning the value of yield_list to the awaiting coroutine. As with a generator, suspension means that all local
state is retained, including the current bindings of local variables, the instruction pointer, the internal evaluation stack,
and the state of any exception handling. When the execution is resumed by awaiting on the next object returned by
the asynchronous generator’s methods, the function can proceed exactly as if the yield expression were just another
external call. The value of the yield expression after resuming depends on the method which resumed the execution.
If __anext__() is used then the result is None. Otherwise, if asend() is used, then the result will be the value
passed in to that method.
Si un gé né rateur asynchrone se termine pré cipitamment en raison d’un break, de l’annulation de la tâ che de l’appelant
ou d’une exception, le code de nettoyage du gé né rateur asynchrone est exé cuté et lè ve possiblement des exceptions,
accè de à des variables de contexte dans un contexte inattendu — peut-ê tre parce que la tâ che de laquelle il dé pend
est finie, ou pendant la fermeture de la boucle d’é vé nements quand le point d’entré e du ramasse-miettes a dé jà é té
appelé . Afin d’é viter cette situation, l’appelant doit explicitement fermer le gé né rateur asynchrone en appelant la
mé thode aclose() pour « finaliser » le gé né rateur et le dé tacher de la boucle d’é vé nements.
Dans une fonction gé né ratrice asynchrone, les expressions yield sont autorisé es n’importe où dans une construction
try . Cependant, si l’exé cution d’un gé né rateur asynchrone n’a pas repris avant que le gé né rateur ne soit finalisé
(parce que son compteur de ré fé rence a atteint zé ro ou parce qu’il est nettoyé par le ramasse-miettes), alors une
expression yield dans une construction try pourrait ne pas atteindre la clause finally en attente. Dans ce cas,
c’est la responsabilité de la boucle d’é vé nements ou du programmateur exé cutant le gé né rateur asynchrone d’appeler
la mé thode aclose() du gé né rateur asynchrone et d’exé cuter l’objet coroutine ré sultant, permettant ainsi à toute
clause finally en attente d’ê tre exé cuté e.
Pour effectuer correctement la finalisation, une boucle d’é vé nements doit dé finir une fonction finalizer qui prend un
gé né rateur-ité rateur asynchrone, appelle sans doute aclose() et exé cute la coroutine. Ce finalizer peut s’enregis-
trer en appelant sys.set_asyncgen_hooks(). Lors de la premiè re ité ration, un gé né rateur-ité rateur asynchrone
stocke le finalizer enregistré à appeler lors de la finalisation. Pour un exemple de ré fé rence relatif à une mé thode de
finalizer, regardez l’implé mentation de [Link].shutdown_asyncgens dans Lib/asyncio/base_events.py.
L’expression yield from <expr> produit une erreur de syntaxe quand elle est utilisé e dans une fonction gé né ratrice
asynchrone.

Méthodes des générateurs-itérateurs asynchrones

Cette sous-section dé crit les mé thodes des gé né rateurs-ité rateurs asynchrones. Elles sont utilisé es pour contrô ler
l’exé cution des fonctions gé né ratrices.
async agen.__anext__()
Returns an awaitable which when run starts to execute the asynchronous generator or resumes it at the last
executed yield expression. When an asynchronous generator function is resumed with an __anext__() me-
thod, the current yield expression always evaluates to None in the returned awaitable, which when run will
continue to the next yield expression. The value of the yield_list of the yield expression is the value of the
StopIteration exception raised by the completing coroutine. If the asynchronous generator exits without

84 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

yielding another value, the awaitable instead raises a StopAsyncIteration exception, signalling that the
asynchronous iteration has completed.
Cette mé thode est normalement appelé e implicitement par une boucle async for.
async [Link](value)
Returns an awaitable which when run resumes the execution of the asynchronous generator. As with the
send() method for a generator, this ”sends” a value into the asynchronous generator function, and the value
argument becomes the result of the current yield expression. The awaitable returned by the asend() me-
thod will return the next value yielded by the generator as the value of the raised StopIteration, or raises
StopAsyncIteration if the asynchronous generator exits without yielding another value. When asend()
is called to start the asynchronous generator, it must be called with None as the argument, because there is no
yield expression that could receive the value.
async [Link](value)
[ [
async [Link](type , value , traceback ]])
Renvoie un awaitable qui lè ve une exception du type type à l’endroit où le gé né rateur asynchrone a é té
mis en pause et renvoie la valeur suivante produite par la fonction gé né ratrice comme valeur de l’exception
StopIteration qui a é té levé e. Si le gé né rateur asynchrone termine sans produire de nouvelle valeur, une
exception StopAsyncIteration est levé e par le awaitable. Si la fonction gé né ratrice ne traite pas l’excep-
tion reçue ou lè ve une autre exception alors, quand le awaitable est lancé , cette exception est propagé e vers
l’appelant du awaitable.
Modifié dans la version 3.12 : The second signature (type[, value[, traceback]]) is deprecated and may be
removed in a future version of Python.
async [Link]()
Renvoie un awaitable qui, quand il s’exé cute, lè ve une exception GeneratorExit dans la fonction gé né ratrice
asynchrone à l’endroit où le gé né rateur é tait en pause. Si la fonction gé né ratrice asynchrone termine norma-
lement, est dé jà fermé e ou lè ve GeneratorExit (parce qu’elle ne gè re pas l’exception), alors le awaitable
renvoyé lè ve une exception StopIteration. Tout nouveau awaitable produit par un appel posté rieur au
gé né rateur asynchrone lè ve une exception StopAsyncIteration. Si le gé né rateur asynchrone produit une
valeur, une RuntimeError est levé e par le awaitable. Si le gé né rateur asynchrone lè ve une autre exception,
elle est propagé e à l’appelant du awaitable. Si le gé né rateur asynchrone a dé jà terminé (soit par une exception,
soit normalement), alors tout nouvel appel à aclose() renvoie un awaitable qui ne fait rien.

6.3 Primaires
Les primaires (primary dans la grammaire formelle ci-dessous) repré sentent les opé rations qui se lient au plus proche
dans le langage. Leur syntaxe est :

primary ::= atom | attributeref | subscription | slicing | call

6.3.1 Références à des attributs

Une ré fé rence à un attribut (attributeref dans la grammaire formelle ci-dessous) est une primaire suivie par un point
et un nom :

attributeref ::= primary "." identifier

The primary must evaluate to an object of a type that supports attribute references, which most objects do. This object
is then asked to produce the attribute whose name is the identifier. The type and value produced is determined by the
object. Multiple evaluations of the same attribute reference may yield different objects.
This production can be customized by overriding the __getattribute__() method or the __getattr__() me-
thod. The __getattribute__() method is called first and either returns a value or raises AttributeError if
the attribute is not available.
If an AttributeError is raised and the object has a __getattr__() method, that method is called as a fallback.

6.3. Primaires 85
The Python Language Reference, Version 3.13.7

6.3.2 sélection (ou indiçage)

L’indiçage d’une instance de classe conteneur sé lectionne gé né ralement un é lé ment du conteneur. L’indiçage d’une
classe générique renvoie gé né ralement un objet GenericAlias.

subscription ::= primary "[" flexible_expression_list "]"

Lorsqu’on accè de à l’indice d’un objet, l’interpré teur é value la primaire et la liste d’expressions.
L’é valuation de la primaire doit produire un objet qui gè re l’indiçage. Un objet est susceptible de gé rer l’indiçage
s’il dé finit la ou les deux mé thodes __getitem__() et __class_getitem__(). Quand on spé cifie un indice du
primaire, le ré sultat de l’é valuation de la liste d’expression est passé à l’une de ces mé thodes. Pour plus de dé tails sur
le choix de __class_getitem__ ou __getitem__ pour l’appel, lisez __class_getitem__ contre __getitem__.
If the expression list contains at least one comma, or if any of the expressions are starred, the expression list will
evaluate to a tuple containing the items of the expression list. Otherwise, the expression list will evaluate to the
value of the list’s sole member.
Modifié dans la version 3.11 : Expressions in an expression list may be starred. See PEP 646.
Pour les objets natifs, deux types d’objets gè rent la sé lection via __getitem__() :
1. Si la primaire est un tableau de correspondances, la liste d’expressions (expression_list dans la grammaire
formelle ci-dessous) doit pouvoir ê tre é valué e comme un objet dont la valeur est une des clé s du tableau de
correspondances et la sé lection dé signe la valeur qui correspond à cette clé . Un exemple de classe implé men-
tant le concept de tableau de correspondances est la classe dict.
2. Si la primaire est une séquence, la liste d’expressions (expression_list dans la grammaire) doit pouvoir ê tre
é valué e comme un entier ou une tranche (comme expliqué dans la section suivante). Des exemples de
classes natives implé mentant le concept de sé quence sont les chaînes, listes et les n-uplets.
The formal syntax makes no special provision for negative indices in sequences. However, built-in sequences all
provide a __getitem__() method that interprets negative indices by adding the length of the sequence to the index
so that, for example, x[-1] selects the last item of x. The resulting value must be a nonnegative integer less than
the number of items in the sequence, and the subscription selects the item whose index is that value (counting from
zero). Since the support for negative indices and slicing occurs in the object’s __getitem__() method, subclasses
overriding this method will need to explicitly add that support.
Une chaîne est une espè ce particuliè re de sé quence dont les é lé ments sont des caractères. Un caractè re n’est pas un
type en tant que tel, c’est une chaîne de longueur un.

6.3.3 Tranches
Une tranche (slicing dans la grammaire formelle ci-dessous) sé lectionne un intervalle d’é lé ments d’un objet sé quence
(par exemple une chaîne, un n-uplet ou une liste, respectivement les types string, tuple et list). Les tranches peuvent
ê tre utilisé es comme des expressions ou des cibles dans les affectations ou les instructions del. La syntaxe est la
suivante :

slicing ::= primary "[" slice_list "]"

slice_list ::= slice_item ("," slice_item)* [","]
slice_item ::= expression | proper_slice
proper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound ::= expression
upper_bound ::= expression
stride ::= expression

Il existe une ambigü ité dans la syntaxe formelle ci-dessus : tout ce qui ressemble à une liste d’expressions (expres-
sion_list vue avant) ressemble aussi à une liste de tranches (slice_list dans la grammaire ci-dessus). En consé quence,
toute sé lection (subscription dans la grammaire) peut ê tre interpré té e comme une tranche. Plutô t que de compliquer
encore la syntaxe, l’ambigü ité est levé e en disant que, dans ce cas, l’interpré tation en tant que sé lection (subscription)
est prioritaire sur l’interpré tation en tant que tranche (c’est le cas si la liste de tranches (slice_list) ne contient aucune
tranche en tant que telle).
The semantics for a slicing are as follows. The primary is indexed (using the same __getitem__() method as
normal subscription) with a key that is constructed from the slice list, as follows. If the slice list contains at least one

86 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

comma, the key is a tuple containing the conversion of the slice items ; otherwise, the conversion of the lone slice
item is the key. The conversion of a slice item that is an expression is that expression. The conversion of a proper
slice is a slice object (see section Hiérarchie des types standards) whose start, stop and step attributes are the
values of the expressions given as lower bound, upper bound and stride, respectively, substituting None for missing
expressions.

6.3.4 Appels
Un appel (call dans la grammaire ci-dessous) appelle un objet appelable (par exemple, une fonction) avec, possible-
ment, une liste d’arguments :

call ::= primary "(" [argument_list [","] | comprehension] ")"

argument_list ::= positional_arguments ["," starred_and_keywords]
["," keywords_arguments]
| starred_and_keywords ["," keywords_arguments]
| keywords_arguments
positional_arguments ::= positional_item ("," positional_item)*
positional_item ::= assignment_expression | "*" expression
starred_and_keywords ::= ("*" expression | keyword_item)
("," "*" expression | "," keyword_item)*
keywords_arguments ::= (keyword_item | "**" expression)
("," keyword_item | "," "**" expression)*
keyword_item ::= identifier "=" expression
Une virgule finale (optionnelle) peut ê tre pré sente, aprè s les arguments positionnels et nommé s, mais elle n’affecte
pas la sé mantique.
The primary must evaluate to a callable object (user-defined functions, built-in functions, methods of built-in objects,
class objects, methods of class instances, and all objects having a __call__() method are callable). All argument
expressions are evaluated before the call is attempted. Please refer to section Définition de fonctions for the syntax of
formal parameter lists.
Si des arguments par mots-clé s sont pré sents, ils sont d’abord convertis en arguments positionnels, comme suit. Pour
commencer, une liste de slots vides est cré ée pour les paramè tres formels. S’il y a N arguments positionnels, ils sont
placé s dans les N premiers slots. Ensuite, pour chaque argument nommé , l’identifiant est utilisé pour dé terminer le
slot correspondant (si l’identifiant est le mê me que le nom du premier paramè tre formel, le premier slot est utilisé ,
et ainsi de suite). Si le slot est dé jà rempli, une exception TypeError est levé e. Sinon, l’argument est placé dans le
slot, ce qui le remplit (mê me si l’expression est None, cela remplit le slot). Quand tous les arguments ont é té traité s,
les slots qui sont toujours vides sont remplis avec la valeur par dé faut correspondante dans la dé finition de la fonction
(les valeurs par dé faut sont calculé es, une seule fois, lorsque la fonction est dé finie ; ainsi, un objet mutable tel qu’une
liste ou un dictionnaire utilisé en tant valeur par dé faut sera partagé entre tous les appels qui ne spé cifient pas de
valeur d argument pour ce slot ; on é vite gé né ralement de faire ça). S’il reste des slots pour lesquels aucune valeur par
dé faut n’est dé finie, une exception TypeError est levé e. Sinon, la liste des slots remplie est utilisé e en tant que liste
des arguments pour l’appel.
Une implé mentation peut fournir des fonctions natives dont les paramè tres positionnels n’ont pas de nom, mê me
s’ils sont « nommé s » pour les besoins de la documentation. Ils ne peuvent donc pas ê tre fournis comme arguments
nommé s. En CPython, les fonctions implé menté es en C qui utilisent PyArg_ParseTuple() pour analyser leurs
arguments en font partie.
S’il y a plus d’arguments positionnels que de slots de paramè tres formels, une exception TypeError est levé e, à
moins qu’un paramè tre formel n’utilise la syntaxe *identifier ; dans ce cas, le paramè tre formel reçoit un n-uplet
contenant les arguments positionnels en supplé ment (ou un n-uplet vide s’il n’y avait pas d’argument positionnel en
trop).
Si un argument nommé ne correspond à aucun nom de paramè tre formel, une exception TypeError est levé e, à moins
qu’un paramè tre formel n’utilise la syntaxe **identifier ; dans ce cas, le paramè tre formel reçoit un dictionnaire
contenant les arguments nommé s en trop (en utilisant les mots-clé s comme clé s et les arguments comme valeurs pour
ce dictionnaire), ou un (nouveau) dictionnaire vide s’il n’y a pas d’argument nommé en trop.
Si la syntaxe *expression apparaît dans l’appel de la fonction, expression doit pouvoir s’é valuer à un itérable.
Les é lé ments de ces ité rables sont traité s comme s’ils é taient des arguments positionnels supplé mentaires. Pour l’appel

6.3. Primaires 87
The Python Language Reference, Version 3.13.7

f(x1, x2, *y, x3, x4), si y s’é value comme une sé quence y1 … yM, c’est é quivalent à un appel avec M+4
arguments positionnels x1, x2, y1 … yM, x3, x4.
Une consé quence est que bien que la syntaxe *expression puisse apparaître après les arguments par nommé s
explicites, ils sont traité s avant les arguments nommé s (et avant tout argument **expression -- voir ci-dessous).
Ainsi :

>>> def f(a, b):

... print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

Il est inhabituel que les syntaxes d’arguments par mots-clé s et *expression soient utilisé s simultané ment dans un
mê me appel, ce qui fait que la confusion reste rare.
Si la syntaxe **expression apparaît dans un appel de fonction, expression doit pouvoir s’é valuer comme un
tableau de correspondances, dont le contenu est traité comme des arguments par mots-clé s supplé mentaires. Si un
paramè tre correspondant à une clé a dé jà é té fourni (en tant qu’argument nommé explicite, en provenance d’un autre
dé paquetage), une exception TypeError est levé e.
Lorsque **expression est utilisé e, chaque clé de ce tableau de correspondances doit ê tre une chaîne. Chaque
valeur du tableau est affecté e au premier paramè tre formel é ligible à l’affectation par mot-clé dont le nom est é gal à la
clé . Une clé n’a pas besoin d’ê tre un identifiant Python (par exemple, "max-temp °F" est acceptable, bien qu’elle ne
corresponde à aucun paramè tre formel qui pourrait ê tre dé claré ). S’il n’y a pas de correspondance avec un paramè tre
formel, la paire clé -valeur est collecté e par le paramè tre **, s’il y en a un. S’il n’y a pas de paramè tre **, une exception
TypeError est levé e.

Les paramè tres formels qui utilisent la syntaxe *identifier ou **identifier ne peuvent pas ê tre utilisé s comme
arguments positionnels ou comme noms d’arguments par mots-clé s.
Modifié dans la version 3.5 : Les appels de fonction acceptent n’importe quel nombre de dé paquetages par * ou **.
Des arguments positionnels peuvent suivre les dé paquetages d’ité rables (*) et les arguments par mots-clé s peuvent
suivre les dé paquetages de dictionnaires (**). Proposé pour la premiè re fois par la PEP 448.
Un appel renvoie toujours une valeur, possiblement None, à moins qu’il ne lè ve une exception. La façon dont celle
valeur est calculé e dé pend du type de l’objet appelable.
Si c’est
une fonction définie par l’utilisateur :
The code block for the function is executed, passing it the argument list. The first thing the code block will
do is bind the formal parameters to the arguments ; this is described in section Définition de fonctions. When
the code block executes a return statement, this specifies the return value of the function call. If execution
reaches the end of the code block without executing a return statement, the return value is None.
une fonction ou une méthode native :
le ré sultat dé pend de l’interpré teur ; lisez built-in-funcs pour une description des fonctions et mé thodes natives.
un objet classe :
une nouvelle instance de cette classe est renvoyé e.
une méthode d’instance de classe :
la fonction correspondante dé finie par l’utilisateur est appelé e, avec la liste d’arguments qui est plus grande
d’un é lé ment que la liste des arguments de l’appel : l’instance est placé e en tê te des arguments.
une instance de classe :
The class must define a __call__() method ; the effect is then the same as if that method was called.

88 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

6.4 Expression await

Suspend l’exé cution de la coroutine sur un objet awaitable. Ne peut ê tre utilisé e qu’à l’inté rieur d’une coroutine func-
tion.

await_expr ::= "await" primary

Ajouté dans la version 3.5.

6.5 L’opérateur puissance

L’opé rateur puissance est plus prioritaire que les opé rateurs unaires sur sa gauche ; il est moins prioritaire que les
opé rateurs unaires sur sa droite. La syntaxe est :

power ::= (await_expr | primary) ["**" u_expr]

Ainsi, dans une sé quence sans parenthè se de puissance et d’opé rateurs unaires, les opé rateurs sont é valué s de droite
à gauche (ceci ne contraint pas l’ordre d’é valuation des opé randes) : -1**2 donne -1.
L’opé rateur puissance possè de la mê me sé mantique que la fonction native pow() lorsqu’elle est appelé e avec deux
arguments : il produit son argument de gauche é levé à la puissance de son argument de droite. Les arguments numé -
riques sont d’abord convertis vers un type commun et le ré sultat est de ce type.
Pour les opé randes entiers, le ré sultat est du mê me type à moins que le deuxiè me argument ne soit né gatif ; dans ce
cas, tous les arguments sont convertis en nombres à virgule flottante et le ré sultat est un nombre à virgule flottante.
Par exemple, 10**2 renvoie 100 mais 10**-2 renvoie 0.01.
Élever 0.0 à une puissance né gative entraîne une ZeroDivisionError. Élever un nombre né gatif à une puissance
fractionnaire renvoie un nombre complexe (dans les versions anté rieures, cela levait une ValueError).
This operation can be customized using the special __pow__() and __rpow__() methods.

6.6 Arithmétique unaire et opérations sur les bits

Toute l’arithmé tique unaire et les opé rations sur les bits ont la mê me priorité :

u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr

The unary - (minus) operator yields the negation of its numeric argument ; the operation can be overridden with the
__neg__() special method.
The unary + (plus) operator yields its numeric argument unchanged ; the operation can be overridden with the
__pos__() special method.
The unary ~ (invert) operator yields the bitwise inversion of its integer argument. The bitwise inversion of x is defined
as -(x+1). It only applies to integral numbers or to custom objects that override the __invert__() special method.
Dans ces trois cas, si l’argument n’est pas du bon type, une exception TypeError est levé e.

6.7 Opérations arithmétiques binaires

Les opé rations arithmé tiques binaires suivent les conventions pour les priorité s. Notez que certaines de ces opé rations
s’appliquent aussi à des types non numé riques. À part l’opé rateur puissance, il n’y a que deux niveaux, le premier pour
les opé rateurs multiplicatifs et le second pour les opé rateurs additifs :

m_expr ::= u_expr | m_expr "*" u_expr | m_expr "@" m_expr |

m_expr "//" u_expr | m_expr "/" u_expr |
m_expr "%" u_expr
a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr

L’opé rateur * (multiplication) produit le produit de ses arguments. Les deux arguments doivent ê tre des nombres
ou alors le premier argument doit ê tre un entier et l’autre doit ê tre une sé quence. Dans le premier cas, les nombres

6.4. Expression await 89

The Python Language Reference, Version 3.13.7

sont convertis dans un type commun puis sont multiplié s entre eux. Dans le dernier cas, la sé quence est ré pé té e ; une
ré pé tition né gative produit une sé quence vide.
This operation can be customized using the special __mul__() and __rmul__() methods.
L’opé rateur @ (prononcé at en anglais) a vocation à multiplier des matrices. Aucun type Python natif n’implé mente
cet opé rateur.
This operation can be customized using the special __matmul__() and __rmatmul__() methods.
Ajouté dans la version 3.5.
Les opé rateurs / (division) et // (division entiè re ou floor division en anglais) produisent le quotient de leurs ar-
guments. Les arguments numé riques sont d’abord convertis vers un type commun. La division d’entiers produit un
nombre à virgule flottante alors que la division entiè re d’entiers produit un entier ; le ré sultat est celui de la divi-
sion mathé matique suivie de la fonction floor appliqué e au ré sultat. Une division par zé ro lè ve une exception
ZeroDivisionError.

The division operation can be customized using the special __truediv__() and __rtruediv__() methods. The
floor division operation can be customized using the special __floordiv__() and __rfloordiv__() methods.
The % (modulo) operator yields the remainder from the division of the first argument by the second. The numeric
arguments are first converted to a common type. A zero right argument raises the ZeroDivisionError exception.
The arguments may be floating-point numbers, e.g., 3.14%0.7 equals 0.34 (since 3.14 equals 4*0.7 + 0.34.)
The modulo operator always yields a result with the same sign as its second operand (or zero) ; the absolute value of
the result is strictly smaller than the absolute value of the second operand 1 .
Les opé rateurs division entiè re et modulo sont lié s par la relation suivante : x == (x//y)*y + (x%y). La division
entiè re et le module sont aussi lié s à la fonction native divmod() : divmod(x, y) == (x//y, x%y) 2 .
En plus de calculer le modulo sur les nombres, l’opé rateur % est aussi surchargé par les objets chaînes de caractè res
pour effectuer le formatage de chaîne « à l’ancienne ». La syntaxe pour le formatage de chaînes est dé crit dans la
ré fé rence de la bibliothè que Python, dans la section old-string-formatting.
The modulo operation can be customized using the special __mod__() and __rmod__() methods.
The floor division operator, the modulo operator, and the divmod() function are not defined for complex numbers.
Instead, convert to a floating-point number using the abs() function if appropriate.
L’opé rateur + (addition) produit la somme de ses arguments. Les arguments doivent ê tre tous les deux des nombres
ou des sé quences du mê me type. Dans le premier cas, les nombres sont convertis vers un type commun puis sont
additionné s entre eux. Dans le dernier cas, les sé quences sont concaté né es.
This operation can be customized using the special __add__() and __radd__() methods.
L’opé rateur - (soustraction) produit la diffé rence entre ses arguments. Les arguments numé riques sont d’abord conver-
tis vers un type commun.
This operation can be customized using the special __sub__() and __rsub__() methods.

6.8 Opérations de décalage

Les opé rations de dé calage sont moins prioritaires que les opé rations arithmé tiques :

shift_expr ::= a_expr | shift_expr ("<<" | ">>") a_expr

Ces opé rateurs prennent des entiers comme arguments. Ils dé calent le premier argument vers la gauche ou vers la
droite du nombre de bits donné par le deuxiè me argument.
1. Bien que abs(x%y) < abs(y) soit vrai mathé matiquement, ce n’est pas toujours vrai pour les nombres à virgule flottante en raison des
arrondis. Par exemple, en supposant que Python tourne sur une plateforme où les float sont des nombres à double pré cision IEEE 754, afin que
-1e-100 % 1e100 soit du mê me signe que 1e100, le ré sultat calculé est -1e-100 + 1e100, qui vaut exactement 1e100 dans ce standard.
Or, la fonction [Link]() renvoie un ré sultat dont le signe est le signe du premier argument, c’est-à -dire -1e-100 dans ce cas. La meilleure
approche dé pend de l’application.
2. Si x est trè s proche d’un multiple entier de y, il est possible que x/y soit supé rieur de un par rapport à (x-x%y)//y en raison des arrondis.
Dans de tels cas, Python renvoie le second ré sultat afin d’avoir divmod(x,y)[0] * y + x % y le plus proche de x.

90 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

The left shift operation can be customized using the special __lshift__() and __rlshift__() methods. The
right shift operation can be customized using the special __rshift__() and __rrshift__() methods.
Un dé calage à droite de n bits est dé fini comme la division entiè re par pow(2,n). Un dé calage à gauche de n bits est
dé fini comme la multiplication par pow(2,n).

6.9 Opérations binaires bit à bit

Chacune des trois opé rations binaires bit à bit possè de une priorité diffé rente :

and_expr ::= shift_expr | and_expr "&" shift_expr

xor_expr ::= and_expr | xor_expr "^" and_expr
or_expr ::= xor_expr | or_expr "|" xor_expr

The & operator yields the bitwise AND of its arguments, which must be integers or one of them must be a custom
object overriding __and__() or __rand__() special methods.
The ^ operator yields the bitwise XOR (exclusive OR) of its arguments, which must be integers or one of them must
be a custom object overriding __xor__() or __rxor__() special methods.
The | operator yields the bitwise (inclusive) OR of its arguments, which must be integers or one of them must be a
custom object overriding __or__() or __ror__() special methods.

6.10 Comparaisons
Au contraire du C, toutes les opé rations de comparaison en Python possè dent la mê me priorité , qui est plus faible
que celle des opé rations arithmé tiques, dé calages ou binaires bit à bit. Toujours contrairement au C, les expressions
telles que a < b < c sont interpré té es comme elles le seraient conventionnellement en mathé matiques :

comparison ::= or_expr (comp_operator or_expr)*

comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="
| "is" ["not"] | ["not"] "in"

Les comparaisons donnent des valeurs boolé ennes (True ou False). Cependant, les méthodes de comparaison riche
dé finies par l’utilisateur peuvent renvoyer des non-boolé ens. Dans ce cas, le ré sultat de la comparaison est converti
en boolé en avec bool() dans les contextes qui attendent un boolé en.
Les comparaisons peuvent ê tre enchaîné es arbitrairement, par exemple x < y <= z est é quivalent à x < y and
y <= z, sauf que y est é valué seulement une fois (mais dans les deux cas, z n’est pas é valué du tout si x < y s’avè re
ê tre faux).
Formellement, si a, b, c … y, z sont des expressions et op1, op2 … opN sont des opé rateurs de comparaison, alors
a op1 b op2 c … y opN z est é quivalent à a op1 b and b op2 c and … y opN z, sauf que chaque ex-
pression est é valué e au maximum une fois.
Notez que a op1 b op2 c n’implique aucune comparaison entre a et c. Ainsi, par exemple, x < y > z est par-
faitement lé gal (mais peut-ê tre pas trè s é lé gant).

6.10.1 Comparaisons de valeurs

Les opé rateurs <, >, ==, >=, <= et != comparent les valeurs de deux objets. Les objets n’ont pas besoin d’ê tre du
mê me type.
Le chapitre Objets, valeurs et types indique que les objets ont une valeur (en plus d’un type et d’un identifiant). La
valeur d’un objet est une notion plutô t abstraite en Python : par exemple, il n’existe pas de mé thode canonique pour
accé der à la valeur d’un objet. De la mê me maniè re, il n’y a aucune obligation concernant la construction de la valeur
d’un objet, par exemple qu’elle prenne en compte toutes les donné es de ses attributs. Les opé rateurs de comparaison
implé mentent une notion particuliè re de ce qu’est la valeur d’un objet. Vous pouvez vous le repré senter comme une
dé finition indirecte de la valeur d’un objet, via l’implé mentation de leur comparaison.

6.9. Opérations binaires bit à bit 91

The Python Language Reference, Version 3.13.7

Because all types are (direct or indirect) subtypes of object, they inherit the default comparison behavior from
object. Types can customize their comparison behavior by implementing rich comparison methods like __lt__(),
described in Personnalisation de base.
Le comportement par dé faut pour le test d’é galité (== et !=) se base sur les identifiants des objets. Ainsi, un test
d’é galité entre deux instances qui ont le mê me identifiant est vrai, un test d’é galité entre deux instances qui ont des
identifiants diffé rents est faux. La raison de ce choix est que Python souhaite que tous les objets soient ré flexifs,
c’est-à -dire que x is y implique x == y.
La relation d’ordre (<, >, <= et >=) n’est pas fournie par dé faut ; une tentative se solde par une TypeError. La raison
de ce choix est qu’il n’existe pas d’invariant similaire à celui de l’é galité .
Le comportement du test d’é galité par dé faut, à savoir que les instances avec des identité s diffé rentes ne sont jamais
é gales, peut ê tre en contradiction avec les types qui dé finissent la « valeur » d’un objet et se basent sur cette « valeur »
pour l’é galité . De tels types doivent personnaliser leurs tests de comparaison et, en fait, c’est ce qu’ont fait un certain
nombre de types natifs.
La liste suivante dé crit le comportement des tests d’é galité pour les types natifs les plus importants.
— Beaucoup de types numé riques natifs (typesnumeric) et de types de la bibliothè que standard fractions.
Fraction ainsi que [Link] peuvent ê tre comparé s, au sein de leur propre classe ou avec d’autres
objets de classes diffé rentes. Une exception notable concerne les nombres complexes qui ne gè rent pas la
relation d’ordre. Dans les limites des types concerné s, la comparaison mathé matique é quivaut à la comparaison
algorithmique, sans perte de pré cision.
Les valeurs non numé riques float('NaN') et [Link]('NaN') sont spé ciales : toute compa-
raison entre un nombre et une valeur non numé rique est fausse. Une implication contre-intuitive à cela est
que les valeurs non numé riques ne sont pas é gales à elles-mê mes. Par exemple, avec x = float('NaN'),
les expressions 3 < x, x < 3 et x == x sont toutes fausses, mais l’expression x != x est vraie. Ce com-
portement est en accord avec IEEE 754.
— None and NotImplemented are singletons. PEP 8 advises that comparisons for singletons should always be
done with is or is not, never the equality operators.
— Les sé quences binaires (instances du type bytes ou bytearray) peuvent ê tre comparé es au sein de la classe
et entre classes. La comparaison est lexicographique, en utilisant la valeur numé rique des é lé ments.
— Les chaînes de caractè res (instances de str) respectent l’ordre lexicographique en utilisant la valeur Unicode
(le ré sultat de la fonction native ord()) des caractè res 3 .
Les chaînes de caractè res et les sé quences binaires ne peuvent pas ê tre comparé es directement.
— Les sé quences (instances de tuple, list ou range) peuvent ê tre comparé es uniquement entre instances de
mê me type, en sachant que les intervalles (range) ne gè rent pas la relation d’ordre. Le test d’é galité entre ces
types renvoie faux et une comparaison entre instances de types diffé rents lè ve une TypeError.
Les sé quences se comparent lexicographiquement en comparant les é lé ments correspondants. Les conteneurs
natifs supposent gé né ralement que les objets identiques sont é gaux à eux-mê mes. Cela leur permet d’é cono-
miser les tests d’é galité pour des objets identiques afin d’amé liorer les performances et de conserver leurs
invariants internes.
L’ordre lexicographique pour les collections natives fonctionne comme suit :
— Deux collections sont é gales si elles sont du mê me type, ont la mê me longueur et si les é lé ments cor-
respondants de chaque paire sont é gaux. Par exemple, [1,2] == (1,2) est faux car les types sont
diffé rents.
— Les collections qui gè rent la relation d’ordre sont ordonné es comme leur premier é lé ment diffé rent (par
exemple, [1,2,x] <= [1,2,y] a la mê me valeur que x <= y). Si un é lé ment n’a pas de correspondant,
la collection la plus courte est la plus petite (par exemple, [1,2] < [1,2,3] est vrai).
3. Le standard Unicode distingue les points codes (code points en anglais, par exemple U+0041) et les caractères abstraits (abstract characters
en anglais, par exemple « LATIN CAPITAL LETTER A »). Bien que la plupart des caractè res abstraits de l’Unicode ne sont repré senté s que par
un seul point code, il y a un certain nombre de caractè res abstraits qui peuvent ê tre repré senté s par une sé quence de plus qu’un point code. Par
exemple, le caractè re abstrait « LATIN CAPITAL LETTER C WITH CEDILLA » peut ê tre repré senté comme un unique caractère précomposé
au point code U+00C7, ou en tant que sé quence d’un caractère de base à la position U+0043 (LATIN CAPITAL LETTER C) du code, suivi par
un caractère combiné à la position U+0327 (COMBINING CEDILLA) du code.
Les opé rateurs de comparaison des chaînes opè rent au niveau des points codes Unicode. Cela peut ê tre dé routant pour des humains. Par
exemple, "\u00C7" == "\u0043\u0327" renvoie False, bien que les deux chaînes repré sentent le mê me caractè re abstrait ”LATIN CAPI-
TAL LETTER C WITH CEDILLA”.
Pour comparer des chaînes au niveau des caractè res abstraits (afin d’avoir quelque chose d’intuitif pour les humains), utilisez unicodedata.
normalize().

92 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

— Les tableaux de correspondances (instances de dict) sont é gales si et seulement si toutes leurs paires (clé,
valeur) sont é gales. L’é galité des clé s et des valeurs met en œuvre la ré flexivité .

Les comparaisons (<, >, <= et >=) lè vent TypeError.

— Les ensembles (instances de set ou frozenset) peuvent ê tre comparé s au sein de leur propre type et entre
types diffé rents.
Les opé rateurs d’inclusion et de sur-ensemble sont dé finis. Ces relations ne sont pas des relations d’ordre total
(par exemple, les deux ensembles {1,2} et {2,3} ne sont pas é gaux, l’un n’est pas inclus dans l’autre, l’un
n’est pas un sur-ensemble de l’autre). Ainsi, les ensembles ne sont pas des arguments approprié s pour les
fonctions qui dé pendent d’un ordre total (par exemple, les fonctions min(), max() et sorted() produisent
des ré sultats indé finis si on leur donne des listes d’ensembles en entré e).
La comparaison des ensembles met en œuvre la ré flexivité des é lé ments.
— La plupart des autres types natifs n’implé mentent pas de mé thodes de comparaisons, ils hé ritent donc du
comportement par dé faut.
Les classes dé finies par l’utilisateur qui particularisent les opé rations de comparaison doivent, si possible, respecter
quelques rè gles pour la cohé rence :
— Le test d’é galité doit ê tre ré flexif. En d’autres termes, des objets identiques doivent ê tre é gaux :
x is y implique x == y
— La comparaison doit ê tre symé trique. En d’autres termes, les expressions suivantes doivent donner le mê me
ré sultat :
x == y et y == x

x != y et y != x

x < y et y > x

x <= y et y >= x
— La comparaison doit ê tre transitive. Les exemples suivants (liste non exhaustive) illustrent ce concept :
x > y and y > z implique x > z

x < y and y <= z implique x < z

— Si vous inversez la comparaison, cela doit en produire la né gation boolé enne. En d’autres termes, les expres-
sions suivantes doivent produire le mê me ré sultat :
x == y et not x != y

x < y et not x >= y (pour une relation d’ordre total)

x > y et not x <= y (pour une relation d’ordre total)
Ces deux derniè res expressions s’appliquent pour les collections totalement ordonné es (par exemple, les
sé quences mais pas les ensembles ou les tableaux de correspondances). Regardez aussi le dé corateur
total_ordering().
— Le ré sultat de hash() doit ê tre cohé rent avec l’é galité . Les objets qui sont é gaux doivent avoir la mê me
empreinte ou ê tre marqué s comme non-hachables.
Python ne vé rifie pas ces rè gles de cohé rence. En fait, l’utilisation de valeurs non numé riques est un exemple de
non-respect de ces rè gles.

6.10.2 Opérations de tests d’appartenance à un ensemble

Les opé rateurs in et not in testent l’appartenance. x in s s’é value à True si x appartient à s et à False sinon. x
not in s renvoie la né gation de x in s. Tous les types sé quences et ensembles natifs gè rent ces opé rateurs, ainsi
que les dictionnaires pour lesquels in teste si dictionnaire possè de une clé donné e. Pour les types conteneurs tels
que les listes, n-uplets (tuple), ensembles (set), ensembles figé s (frozen set), dictionnaires (dict) ou [Link],
l’expression x in y est é quivalente à any(x is e or x == e for e in y).
Pour les chaînes de caractè res et chaînes d’octets, x in y vaut True si et seulement si x est une sous-chaîne de y.
Un test é quivalent est [Link](x) != -1. Une chaîne vide est considé ré e comme une sous-chaîne de toute autre
chaîne, ainsi "" in "abc" renvoie True.
For user-defined classes which define the __contains__() method, x in y returns True if y.
__contains__(x) returns a true value, and False otherwise.

6.10. Comparaisons 93
The Python Language Reference, Version 3.13.7

For user-defined classes which do not define __contains__() but do define __iter__(), x in y is True if some
value z, for which the expression x is z or x == z is true, is produced while iterating over y. If an exception is
raised during the iteration, it is as if in raised that exception.
Lastly, the old-style iteration protocol is tried : if a class defines __getitem__(), x in y is True if and only if
there is a non-negative integer index i such that x is y[i] or x == y[i], and no lower integer index raises the
IndexError exception. (If any other exception is raised, it is as if in raised that exception).

L’opé rateur not in est dé fini comme produisant le contraire de in.

6.10.3 Comparaisons d’identifiants

Les opé rateurs is et is not testent l’é galité des identifiants des objets : x is y est vrai si et seulement si x et y sont
le mê me objet. L’identifiant d’un objet est dé terminé en utilisant la fonction id(). x is not y renvoie le ré sultat
contraire de l’é galité des identifiants 4 .

6.11 Opérations booléennes

or_test ::= and_test | or_test "or" and_test
and_test ::= not_test | and_test "and" not_test
not_test ::= comparison | "not" not_test

In the context of Boolean operations, and also when expressions are used by control flow statements, the following
values are interpreted as false : False, None, numeric zero of all types, and empty strings and containers (including
strings, tuples, lists, dictionaries, sets and frozensets). All other values are interpreted as true. User-defined objects
can customize their truth value by providing a __bool__() method.
L’opé rateur not produit True si son argument est faux, False sinon.
L’expression x and y commence par é valuer x ; si x est faux, sa valeur est renvoyé e ; sinon, y est é valué et la valeur
ré sultante est renvoyé e.
L’expression x or y commence par é valuer x ; si x est vrai, sa valeur est renvoyé e ; sinon, y est é valué et la valeur
ré sultante est renvoyé e.
Notez que ni and ni or ne restreignent la valeur et le type qu’ils renvoient à False et True : ils renvoient le dernier
argument é valué . Ceci peut ê tre utile, par exemple : si une chaîne s doit ê tre remplacé e par une valeur par dé faut
si elle est vide, l’expression s or 'truc' produit la valeur voulue. Comme not doit cré er une nouvelle valeur, il
renvoie une valeur boolé enne quel que soit le type de son argument (par exemple, not 'truc' produit False plutô t
que ''.

6.12 Expressions d’affectation

assignment_expression ::= [identifier ":="] expression

Une expression d’affectation (parfois aussi appelé e « expression nommé e » ou « expression morse ») affecte
l’expression à un identifiant et renvoie la valeur de l’expression.
Une utilisation classique concerne les correspondances d’expressions rationnelles :

if matching := [Link](data):
do_something(matching)

Ou lorsqu’on traite le contenu d’un fichier par morceaux :

while chunk := [Link](9000):

process(chunk)

4. En raison du ramasse-miettes automatique et de la nature dynamique des descripteurs, vous pouvez ê tre confronté à un comportement
semblant bizarre lors de certaines utilisations de l’opé rateur is, par exemple si cela implique des comparaisons entre des mé thodes d’instances ou
des constantes. Allez vé rifier dans la documentation pour plus d’informations.

94 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

Assignment expressions must be surrounded by parentheses when used as expression statements and when used as sub-
expressions in slicing, conditional, lambda, keyword-argument, and comprehension-if expressions and in assert,
with, and assignment statements. In all other places where they can be used, parentheses are not required, including
in if and while statements.
Ajouté dans la version 3.8 : Voir la PEP 572 pour plus de dé tails sur les expressions d’affectation.

6.13 Expressions conditionnelles

conditional_expression ::= or_test ["if" or_test "else" expression]
expression ::= conditional_expression | lambda_expr

Les expressions conditionnelles (parfois appelé es « opé rateur ternaire ») sont les moins prioritaires de toutes les
opé rations Python.
L’expression x if C else y commence par é valuer la condition C. Si C est vrai, alors x est é valué et sa valeur est
renvoyé e ; sinon, y est é valué et sa valeur est renvoyé e.
Voir la PEP 308 pour plus de dé tails sur les expressions conditionnelles.

6.14 Expressions lambda

lambda_expr ::= "lambda" [parameter_list] ":" expression
Les expressions lambda sont utilisé es pour cré er des fonctions anonymes. L’expression lambda parameters:
expression produit un objet fonction. Cet objet anonyme se comporte comme un objet fonction dé fini par :

def <lambda>(parameters):
return expression

Voir la section Définition de fonctions pour la syntaxe des listes de paramè tres. Notez que les fonctions cré ées par des
expressions lambda ne peuvent pas contenir d’instructions ou d’annotations.

6.15 Listes d’expressions

starred_expression ::= ["*"] or_expr
flexible_expression ::= assignment_expression | starred_expression
flexible_expression_list ::= flexible_expression ("," flexible_expression)* [","]
starred_expression_list ::= starred_expression ("," starred_expression)* [","]
expression_list ::= expression ("," expression)* [","]
yield_list ::= expression_list | starred_expression "," [starred_expression_list]
Sauf lorsqu’elle fait partie d’un agencement de liste ou d’ensemble, une liste d’expressions qui contient au moins une
virgule produit un n-uplet. La longueur du n-uplet est le nombre d’expressions dans la liste. Les expressions sont
é valué es de la gauche vers la droite.
Un asté risque * indique dépaquetage d’itérable (iterable unpacking en anglais). Son opé rande doit ê tre un iterable.
L’ité rable est dé veloppé en une sé quence d’é lé ments qui sont inclus dans un nouvel objet n-uplet, liste ou ensemble à
l’emplacement du dé paquetage.
Ajouté dans la version 3.5 : dé paquetage d’ité rables dans les listes d’expressions, proposé à l’origine par la PEP 448.
Ajouté dans la version 3.11 : Any item in an expression list may be starred. See PEP 646.
A trailing comma is required only to create a one-item tuple, such as 1, ; it is optional in all other cases. A single
expression without a trailing comma doesn’t create a tuple, but rather yields the value of that expression. (To create
an empty tuple, use an empty pair of parentheses : ().)

6.13. Expressions conditionnelles 95

The Python Language Reference, Version 3.13.7

6.16 Ordre d’évaluation

Python é value les expressions de la gauche vers la droite. Remarquez que lors de l’é valuation d’une affectation, la
partie droite de l’affectation est é valué e avant la partie gauche.
Dans les lignes qui suivent, les expressions sont é valué es suivant l’ordre arithmé tique de leurs suffixes :

expr1, expr2, expr3, expr4

(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2

6.17 Priorités des opérateurs

Le tableau suivant ré sume les priorité s des opé rateurs en Python, du plus prioritaire (porté e la plus courte) au moins
prioritaire (porté e la plus grande). Les opé rateurs qui sont dans la mê me case ont la mê me priorité . À moins que la
syntaxe ne soit explicitement indiqué e, les opé rateurs sont binaires. Les opé rateurs dans la mê me case regroupent de
la gauche vers la droite (sauf pour la puissance et les expressions conditionnelles qui regroupent de la droite vers la
gauche).
Notez que les comparaisons, les tests d’appartenance et les tests d’identifiants possè dent tous la mê me priorité et
s’enchaînent de la gauche vers la droite comme dé crit dans la section Comparaisons.

Opérateur Description
(expressions…), Expression de liaison ou parenthè se, affichage de liste, affi-
[expressions…], {key: value…}, chage de dictionnaire, affichage de set
{expressions…}
x[indice], x[indice:indice], indiçage, tranches, appel, ré fé rence à un attribut
x(arguments…), [Link]
await x Expression await
** Puissance 5
+x, -x, ~x NOT (positif, né gatif, bit à bit)
*, @, /, //, % Multiplication, multiplication de matrices, division, division
entiè re, reste 6
+, - Addition et soustraction
<<, >> dé calages
& AND (bit à bit)
^ XOR (bit à bit)
| OR (bit à bit)
in, not in, is, is not, <, <=, >, >=, !=, == Comparaisons, y compris les tests d’appartenance et les tests
d’identifiants
not x NOT (boolé en)
and AND (boolé en)
or OR (boolé en)
if -- else Expressions conditionnelles
lambda Expression lambda
:= Expression d’affectation

5. L’opé rateur puissance ** est moins prioritaire qu’un opé rateur unaire arithmé tique ou bit à bit sur sa droite. Ainsi, 2**-1 vaut 0.5.
6. L’opé rateur % est aussi utilisé pour formater les chaînes de caractè res ; il y possè de la mê me priorité .

96 Chapitre 6. Expressions
 The Python Language Reference, Version 3.13.7

Notes

6.17. Priorités des opérateurs 97

The Python Language Reference, Version 3.13.7

98 Chapitre 6. Expressions
 CHAPITRE 7

Les instructions simples

Une instruction simple est contenue dans une seule ligne logique. Plusieurs instructions simples peuvent ê tre é crites
sur une seule ligne, sé paré es par des points-virgules. La syntaxe d’une instruction simple est :

simple_stmt ::= expression_stmt

| assert_stmt
| assignment_stmt
| augmented_assignment_stmt
| annotated_assignment_stmt
| pass_stmt
| del_stmt
| return_stmt
| yield_stmt
| raise_stmt
| break_stmt
| continue_stmt
| import_stmt
| future_stmt
| global_stmt
| nonlocal_stmt
| type_stmt

7.1 Les expressions

Les expressions sont utilisé es (gé né ralement de maniè re interactive) comme instructions pour calculer et é crire des
valeurs, appeler une procé dure (une fonction dont le ré sultat renvoyé n’a pas d’importance ; en Python, les procé dures
renvoient la valeur None). D’autres utilisations des expressions sont autorisé es et parfois utiles. La syntaxe pour une
expression en tant qu’instruction est :

expression_stmt ::= starred_expression

Ce genre d’instruction é value la liste d’expressions (qui peut se limiter à une seule expression).
En mode interactif, si la valeur n’est pas None, elle est convertie en chaîne en utilisant la fonction native repr() et
la chaîne ré sultante est é crite sur la sortie standard sur sa propre ligne. Si le ré sultat est None, rien n’est é crit ce qui
est usuel pour les appels de procé dures.

99
The Python Language Reference, Version 3.13.7

7.2 Les assignations

Les assignations sont utilisé es pour lier ou relier des noms à des valeurs et modifier des attributs ou des é lé ments
d’objets mutables :

assignment_stmt ::= (target_list "=")+ (starred_expression | yield_expression)

target_list ::= target ("," target)* [","]
target ::= identifier
| "(" [target_list] ")"
| "[" [target_list] "]"
| attributeref
| subscription
| slicing
| "*" target
Voir la section Primaires pour la dé finition des syntaxes de attributeref, subscription et slicing.
Une assignation é value la liste d’expressions (gardez en mé moire que ce peut ê tre une simple expression ou une liste
dont les é lé ments sont sé paré s par des virgules, cette derniè re produisant un n-uplet) et assigne l’unique objet ré sultant
à chaque liste cible, de la gauche vers la droite.
Une assignation est dé finie ré cursivement en fonction de la forme de la cible (une liste). Quand la cible est une
partie d’un objet mutable (une ré fé rence à un attribut, une sé lection ou une tranche), l’objet mutable doit effectuer
l’assignation au final et dé cider de sa validité , voire lever une exception si l’assignation n’est pas acceptable. Les rè gles
suivies par les diffé rents types et les exceptions levé es sont donné es dans les dé finitions des types d’objets (voir la
section Hiérarchie des types standards).
L’assignation d’un objet à une liste cible, optionnellement entouré e par des parenthè ses ou des crochets, est dé finie
ré cursivement comme suit.
— Si la liste cible est une cible unique sans virgule de fin, optionnellement entre parenthè ses, l’objet est assigné
à cette cible.
— Sinon :
— Si la liste cible contient une cible pré fixé e par un asté risque, appelé e cible étoilée (starred target en anglais) :
l’objet doit ê tre un ité rable avec au moins autant d’é lé ments qu’il y a de cibles dans la liste cible, moins
un. Les premiers é lé ments de l’ité rable sont assigné s, de la gauche vers la droite, aux cibles avant la cible
é toilé e. Les é lé ments de queue de l’ité rable sont assigné s aux cibles aprè s la cible é toilé e. Une liste des
é lé ments restants dans l’ité rable est alors assigné e à la cible é toilé e (cette liste peut ê tre vide).
— Sinon : l’objet doit ê tre un ité rable avec le mê me nombre d’é lé ments qu’il y a de cibles dans la liste cible ;
les é lé ments sont assigné s, de la gauche vers la droite, vers les cibles correspondantes.
L’assignation d’un objet vers une cible unique est dé finie ré cursivement comme suit.
— Si la cible est une variable (un nom) :
— si le nom n’apparaît pas dans une instruction global ou nonlocal (respectivement) du bloc de code
courant, le nom est lié à l’objet dans l’espace courant des noms locaux ;
— sinon le nom est lié à l’objet dans l’espace des noms globaux ou dans un espace de nommage plus large
dé terminé par nonlocal, respectivement.
Le lien du nom est modifié si le nom é tait dé jà lié . Ceci peut faire que le compteur de ré fé rences de l’objet
auquel le nom é tait pré cé demment lié tombe à zé ro, entrainant la dé -allocation de l’objet et l’appel de son
destructeur (s’il existe).
— Si la cible est une ré fé rence à un attribut : l’expression primaire de la ré fé rence est é valué e. Elle doit produire un
objet avec des attributs que l’on peut assigner : si ce n’est pas le cas, une TypeError est levé e. Python demande
alors à cet objet d’assigner l’attribut donné ; si ce n’est pas possible, une exception est levé e (habituellement,
mais pas né cessairement, AttributeError).
Note : si l’objet est une instance de classe et que la ré fé rence à l’attribut apparaît des deux cô té s de l’opé rateur
d’assignation, l’expression « à droite », a.x peut accé der soit à l’attribut d’instance ou (si cet attribut d’instance
n’existe pas) à l’attribut de classe. L’expression cible « à gauche » a.x est toujours dé finie comme un attribut
d’instance, en le cré ant si né cessaire. Ainsi, les deux occurrences de a.x ne font pas né cessairement ré fé rence
au mê me attribut : si l’expression « à droite » fait ré fé rence à un attribut de classe, l’expression « à gauche »
cré e un nouvel attribut d’instance comme cible de l’assignation :

100 Chapitre 7. Les instructions simples

 The Python Language Reference, Version 3.13.7

class Cls:
x = 3 # class variable
inst = Cls()
inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3

Cette description ne s’applique pas né cessairement aux attributs des descripteurs, telles que les proprié té s
cré ées avec property().
— Si la cible est une sé lection : l’expression primaire de la ré fé rence est é valué e. Elle doit produire soit un objet
sé quence mutable (telle qu’une liste) ou un objet tableau de correspondances (tel qu’un dictionnaire). Ensuite,
l’expression de la sé lection est é valué e.
Si la primaire est un objet sé quence mutable (telle qu’une liste), la sé lection doit produire un entier. S’il est
né gatif, la longueur de la sé quence lui est ajouté e. La valeur ré sultante doit ê tre un entier positif ou nul, plus
petit que la longueur de la sé quence, et Python demande à la sé quence d’assigner l’objet à l’é lé ment se trouvant
à cet indice. Si l’indice est hors limites, une IndexError est levé e (une assignation à une sé lection dans une
sé quence ne peut pas ajouter de nouveaux é lé ments à une liste).
Si la primaire est un objet tableau de correspondances (tel qu’un dictionnaire), la sé lection doit ê tre d’un type
compatible avec le type des clé s ; Python demande alors au tableau de correspondances de cré er un couple
clé -valeur qui associe la sé lection à l’objet assigné . Ceci peut remplacer une correspondance dé jà existante
pour une clé donné e ou insé rer un nouveau couple clé -valeur.
For user-defined objects, the __setitem__() method is called with appropriate arguments.
— Si la cible est une tranche : l’expression primaire de la ré fé rence est é valué e. Elle doit produire un objet
sé quence mutable (telle qu’une liste). L’objet assigné doit ê tre un objet sé quence du mê me type. Ensuite,
les expressions de la borne infé rieure et de la borne supé rieure sont é valué es, dans la mesure où elles sont
spé cifié es (les valeurs par dé faut sont zé ro et la longueur de la sé quence). Les bornes doivent ê tre des entiers.
Si une borne est né gative, la longueur de la sé quence lui est ajouté e. Les bornes ré sultantes sont coupé es pour
ê tre dans l’intervalle zé ro -- longueur de la sé quence, inclus. Finalement, Python demande à l’objet sé quence
de remplacer la tranche avec les é lé ments de la sé quence à assigner. La longueur de la tranche peut ê tre
diffé rente de la longueur de la sé quence à assigner, ce qui modifie alors la longueur de la sé quence cible, si
celle-ci le permet.
Dans l’implé mentation actuelle, la syntaxe pour les cibles est similaire à celle des expressions. Toute syntaxe invalide
est rejeté e pendant la phase de gé né ration de code, ce qui produit des messages d’erreurs moins dé taillé s.
Bien que la dé finition de l’assignation implique que le passage entre le cô té gauche et le cô té droit soient « simultané s »
(par exemple, a, b = b, a permute les deux variables), le passage à l’intérieur des collections de variables que l’on
assigne intervient de la gauche vers la droite, ce qui peut entraîner quelques confusions. Par exemple, le programme
suivant affiche [0, 2] :

x = [0, 1]
i = 0
i, x[i] = 1, 2 # i is updated, then x[i] is updated
print(x)

µ Voir aussi

PEP 3132 -- dépaquetage étendu d’itérable

Spé cification de la fonctionnalité *cible.

7.2.1 Les assignations augmentées

Une assignation augmenté e est la combinaison, dans une seule instruction, d’une opé ration binaire et d’une assigna-
tion :

augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)

augtarget ::= identifier | attributeref | subscription | slicing
augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="

7.2. Les assignations 101

The Python Language Reference, Version 3.13.7

| ">>=" | "<<=" | "&=" | "^=" | "|="

Voir la section Primaires pour la dé finition des syntaxes des trois derniers symboles.
Une assignation augmenté e é value la cible (qui, au contraire des assignations normales, ne peut pas ê tre un dé paque-
tage) et la liste d’expressions, effectue l’opé ration binaire (spé cifique au type d’assignation) sur les deux opé randes et
assigne le ré sultat à la cible originale. La cible n’est é valué e qu’une seule fois.
An augmented assignment statement like x += 1 can be rewritten as x = x + 1 to achieve a similar, but not exactly
equal effect. In the augmented version, x is only evaluated once. Also, when possible, the actual operation is performed
in-place, meaning that rather than creating a new object and assigning that to the target, the old object is modified
instead.
Au contraire des assignations normales, les assignations augmenté es é valuent la partie gauche avant d’é valuer la partie
droite. Par exemple, a[i] += f(x) commence par s’inté resser à a[i], puis Python é value f(x), effectue l’addition
et, enfin, é crit le ré sultat dans a[i].
À l’exception de l’assignation de n-uplets et de cibles multiples dans une seule instruction, l’assignation effectué e
par une assignation augmenté e est traité e de la mê me maniè re qu’une assignation normale. De mê me, à l’exception
du comportement possible sur place, l’opé ration binaire effectué e par assignation augmenté e est la mê me que les
opé rations binaires normales.
Pour les cibles qui sont des ré fé rences à des attributs, la mê me mise en garde sur les attributs de classe et d’instances
s’applique que pour les assignations normales.

7.2.2 Les assignations annotées

Une assignation annotée est la combinaison, dans une seule instruction, d’une annotation de variable ou d’attribut et
d’une assignation optionnelle :

annotated_assignment_stmt ::= augtarget ":" expression

["=" (starred_expression | yield_expression)]
La diffé rence avec une assignation normale (voir ci-dessus) est qu’une seule cible est autorisé e.
The assignment target is considered ”simple” if it consists of a single name that is not enclosed in parentheses. For
simple assignment targets, if in class or module scope, the annotations are evaluated and stored in a special class
or module attribute __annotations__ that is a dictionary mapping from variable names (mangled if private) to
evaluated annotations. This attribute is writable and is automatically created at the start of class or module body
execution, if annotations are found statically.
If the assignment target is not simple (an attribute, subscript node, or parenthesized name), the annotation is evaluated
if in class or module scope, but not stored.
Si le nom est annoté dans la porté e d’une fonction, alors ce nom est local à cette porté e. Les annotations ne sont
jamais é valué es et stocké es dans les porté es des fonctions.
If the right hand side is present, an annotated assignment performs the actual assignment before evaluating annotations
(where applicable). If the right hand side is not present for an expression target, then the interpreter evaluates the
target except for the last __setitem__() or __setattr__() call.

µ Voir aussi

PEP 526 -- Syntaxe pour les annotations de variables

La proposition qui a ajouté la syntaxe pour annoter les types de variables (y compris les variables de classe
et les variables d’instance), au lieu de les exprimer par le biais de commentaires.
PEP 484 -- Indices de type
La proposition qui a ajouté le module typing pour fournir une syntaxe standard pour les annotations de
type qui peuvent ê tre utilisé es dans les outils d’analyse statique et les environnements de dé veloppement
inté gré s (EDI).

102 Chapitre 7. Les instructions simples

 The Python Language Reference, Version 3.13.7

Modifié dans la version 3.8 : Doré navant, cô té droit des assignations annoté es, peuvent figurer les mê mes expres-
sions que pour les assignations normales. Auparavant, certaines expressions (comme des n-uplets sans parenthè se
englobante) gé né raient des erreurs de syntaxe.

7.3 L’instruction assert

Les instructions assert sont une maniè re pratique d’insé rer des tests de dé bogage au sein d’un programme :

assert_stmt ::= "assert" expression ["," expression]

La forme la plus simple, assert expression, est é quivalente à :

if __debug__:
if not expression: raise AssertionError

La forme é tendue, assert expression1, expression2, est é quivalente à :

if __debug__:
if not expression1: raise AssertionError(expression2)

These equivalences assume that __debug__ and AssertionError refer to the built-in variables with those names.
In the current implementation, the built-in variable __debug__ is True under normal circumstances, False when
optimization is requested (command line option -O). The current code generator emits no code for an assert
statement when optimization is requested at compile time. Note that it is unnecessary to include the source code for
the expression that failed in the error message ; it will be displayed as part of the stack trace.
Assigner vers __debug__ est illé gal. La valeur de cette variable native est dé terminé e au moment où l’interpré teur
dé marre.

7.4 L’instruction pass

pass_stmt ::= "pass"
pass est une opé ration vide --- quand elle est exé cuté e, rien ne se passe. Elle est utile comme bouche-trou lorsqu’une
instruction est syntaxiquement requise mais qu’aucun code ne doit ê tre exé cuté . Par exemple :

def f(arg): pass # a function that does nothing (yet)

class C: pass # a class with no methods (yet)

7.5 L’instruction del

del_stmt ::= "del" target_list

La suppression est ré cursivement dé finie de la mê me maniè re que l’assignation. Plutô t que de dé tailler cela de maniè re
approfondie, voici quelques indices.
La suppression d’une liste cible (target_list dans la grammaire ci-dessus) supprime ré cursivement chaque cible, de la
gauche vers la droite.
Deletion of a name removes the binding of that name from the local or global namespace, depending on whether the
name occurs in a global statement in the same code block. Trying to delete an unbound name raises a NameError
exception.
La suppression d’une ré fé rence à un attribut, une sé lection ou une tranche est passé e à l’objet primaire concerné : la
suppression d’une tranche est en gé né ral é quivalente à l’assignation d’une tranche vide du type adé quat (mais ceci est
au final dé terminé par l’objet que l’on tranche).
Modifié dans la version 3.2 : Auparavant, il é tait illé gal de supprimer un nom dans l’espace des noms locaux si celui-ci
apparaissait comme variable libre dans un bloc imbriqué .

7.3. L’instruction assert 103

The Python Language Reference, Version 3.13.7

7.6 L’instruction return

return_stmt ::= "return" [expression_list]

return ne peut ê tre placé e qu’à l’inté rieur d’une dé finition de fonction, pas à l’inté rieur d’une dé finition de classe.
Si une liste d’expressions (expression_list dans la grammaire ci-dessus) est pré sente, elle est é valué e, sinon None est
utilisé e comme valeur par dé faut.
return quitte l’appel à la fonction courante avec la liste d’expressions (ou None) comme valeur de retour.

Quand return fait sortir d’une instruction try avec une clause finally , cette clause finally est exé cuté e avant
de ré ellement quitter la fonction.
Dans une fonction gé né ratrice, l’instruction return indique que le gé né rateur est terminé et provoque la levé e d’une
StopIteration. La valeur de retour (s’il y en a une) est utilisé e comme argument pour construire l’exception
StopIteration et devient l’attribut [Link].

Dans une fonction gé né ratrice asynchrone, une instruction return vide indique que le gé né rateur asynchrone est
terminé et provoque la levé e d’une StopAsyncIteration. Une instruction return non vide est une erreur de
syntaxe dans une fonction gé né ratrice asynchrone.

7.7 L’instruction yield

yield_stmt ::= yield_expression

A yield statement is semantically equivalent to a yield expression. The yield statement can be used to omit the
parentheses that would otherwise be required in the equivalent yield expression statement. For example, the yield
statements

yield <expr>
yield from <expr>

sont é quivalentes aux instructions expressions yield :

(yield <expr>)
(yield from <expr>)

Yield expressions and statements are only used when defining a generator function, and are only used in the body of
the generator function. Using yield in a function definition is sufficient to cause that definition to create a generator
function instead of a normal function.
Pour tous les dé tails sur la sé mantique de yield, reportez-vous à la section Expressions yield.

7.8 L’instruction raise

raise_stmt ::= "raise" [expression ["from" expression]]

Si aucune expression n’est pré sente, raise propage l’exception en cours de traitement, aussi dé nommé e exception
active. Si aucune exception n’est active, une exception RuntimeError est levé e, indiquant que c’est une erreur.
Sinon, raise é value la premiè re expression en tant qu’objet exception. Ce doit ê tre une sous-classe ou une instance
de BaseException. Si c’est une classe, l’instance de l’exception est obtenue en instanciant la classe sans argument
(au moment voulu).
Le type de l’exception est la classe de l’instance de l’exception, la value est l’instance elle-mê me.
A traceback object is normally created automatically when an exception is raised and attached to it as the
__traceback__ attribute. You can create an exception and set your own traceback in one step using the
with_traceback() exception method (which returns the same exception instance, with its traceback set to its
argument), like so :

104 Chapitre 7. Les instructions simples

 The Python Language Reference, Version 3.13.7

raise Exception("foo occurred").with_traceback(tracebackobj)

The from clause is used for exception chaining : if given, the second expression must be another exception class or ins-
tance. If the second expression is an exception instance, it will be attached to the raised exception as the __cause__
attribute (which is writable). If the expression is an exception class, the class will be instantiated and the resulting
exception instance will be attached to the raised exception as the __cause__ attribute. If the raised exception is not
handled, both exceptions will be printed :

>>> try:
... print(1 / 0)
... except Exception as exc:
... raise RuntimeError("Something bad happened") from exc
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
print(1 / 0)
~~^~~
ZeroDivisionError: division by zero

The above exception was the direct cause of the following exception:

Traceback (most recent call last):

File "<stdin>", line 4, in <module>
raise RuntimeError("Something bad happened") from exc
RuntimeError: Something bad happened

A similar mechanism works implicitly if a new exception is raised when an exception is already being handled. An
exception may be handled when an except or finally clause, or a with statement, is used. The previous exception
is then attached as the new exception’s __context__ attribute :

>>> try:
... print(1 / 0)
... except:
... raise RuntimeError("Something bad happened")
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
print(1 / 0)
~~^~~
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):

File "<stdin>", line 4, in <module>
raise RuntimeError("Something bad happened")
RuntimeError: Something bad happened

Exception chaining can be explicitly suppressed by specifying None in the from clause :

>>> try:
... print(1 / 0)
... except:
... raise RuntimeError("Something bad happened") from None
...
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened

7.8. L’instruction raise 105

The Python Language Reference, Version 3.13.7

Des informations complé mentaires sur les exceptions sont disponibles dans la section Exceptions et sur la gestion des
exceptions dans la section L’instruction try.
Modifié dans la version 3.3 : None est doré navant autorisé e en tant que Y dans raise X from Y.
Added the __suppress_context__ attribute to suppress automatic display of the exception context.
Modifié dans la version 3.11 : si la trace d’appels de l’exception active est modifié e dans une clause except, une
instruction raise posté rieure lè ve à nouveau l’exception avec la trace modifié e. Auparavant, l’exception é tait levé e à
nouveau avec la trace qu’elle avait au moment de son interception.

7.9 L’instruction break

break_stmt ::= "break"

Une instruction break ne peut apparaître qu’à l’inté rieur d’une boucle for ou while, mais pas dans une dé finition
de fonction ou de classe à l’inté rieur de cette boucle.
Elle termine la boucle la plus imbriqué e, shuntant l’é ventuelle clause else de la boucle.
Si une boucle for est terminé e par un break, la cible qui contrô le la boucle garde sa valeur.
Quand break passe le contrô le en dehors d’une instruction try qui comporte une clause finally , cette clause
finally est exé cuté e avant de quitter la boucle.

7.10 L’instruction continue

continue_stmt ::= "continue"
L’instruction continue ne peut apparaître qu’à l’inté rieur d’une boucle for ou while, mais pas dans une dé finition
de fonction ou de classe à l’inté rieur de cette boucle. Elle fait continuer le flot d’exé cution au prochain cycle de la
boucle la plus imbriqué e.
Quand continue passe le contrô le en dehors d’une instruction try qui comporte une clause finally , cette clause
finally est exé cuté e avant de commencer le cycle suivant de la boucle.

7.11 L’instruction import

import_stmt ::= "import" module ["as" identifier] ("," module ["as" identifier])*
| "from" relative_module "import" identifier ["as" identifier]
("," identifier ["as" identifier])*
| "from" relative_module "import" "(" identifier ["as" identifier]
("," identifier ["as" identifier])* [","] ")"
| "from" relative_module "import" "*"
module ::= (identifier ".")* identifier
relative_module ::= "."* module | "."+

L’instruction de base import (sans clause from) est exé cuté e en deux é tapes :
1. trouve un module, le charge et l’initialise si né cessaire
2. dé finit un ou des noms (name dans la grammaire ci-dessus) dans l’espace des noms locaux de la porté e où
l’instruction import apparaît.
Quand l’instruction contient plusieurs clauses (sé paré es par des virgules), les deux é tapes sont mené es sé paré ment
pour chaque clause, comme si les clauses é taient sé paré es dans des instructions d’importations individuelles.
Les dé tails de la premiè re é tape, de recherche et de chargement des modules, sont dé crits largement dans la section
relative au système d’importation, qui dé crit é galement les diffé rents types de paquets et modules qui peuvent ê tre
importé s, de mê me que les points d’entré e pouvant ê tre utilisé s pour personnaliser le systè me d’importation. Notez
que des erreurs dans cette é tape peuvent indiquer soit que le module n’a pas é té trouvé , soit qu’une erreur s’est produite
lors de l’initialisation du module, ce qui comprend l’exé cution du code du module.

106 Chapitre 7. Les instructions simples

 The Python Language Reference, Version 3.13.7

Si le module requis est bien ré cupé ré , il est mis à disposition de l’espace de nommage local suivant l’une des trois
façons suivantes :
— Si le nom du module est suivi par as, alors le nom suivant as est directement lié au module importé .
— si aucun autre nom n’est spé cifié et que le module en cours d’importation est un module de niveau le plus haut,
le nom du module est lié dans l’espace des noms locaux au module importé ;
— si le module en cours d’importation n’est pas un module de plus haut niveau, alors le nom du paquet de plus
haut niveau qui contient ce module est lié dans l’espace des noms locaux au paquet de plus haut niveau. Vous
pouvez accé der au module importé en utilisant son nom pleinement qualifié et non directement.
La forme from utilise un processus un peu plus complexe :
1. trouve le module spé cifié dans la clause from, le charge et l’initialise si né cessaire ;
2. pour chaque nom spé cifié dans les clauses import :
1. vé rifie si le module importé possè de un attribut avec ce nom ;
2. si non, essaie d’importer un sous-module avec ce nom puis vé rifie si le module importé possè de lui-mê me
cet attribut ;
3. si l’attribut n’est pas trouvé , une ImportError est levé e.
4. sinon, une ré fé rence à cette valeur est stocké e dans l’espace des noms locaux, en utilisant le nom de la
clause as si elle est pré sente, sinon en utilisant le nom de l’attribut.
Exemples :

import foo # foo imported and bound locally

import [Link] # foo, [Link], and [Link] imported, foo bound␣
,→locally

import [Link] as fbb # foo, [Link], and [Link] imported, [Link]␣

,→bound as fbb

from [Link] import baz # foo, [Link], and [Link] imported, [Link]␣
,→bound as baz

from foo import attr # foo imported and [Link] bound as attr

Si la liste des noms est remplacé e par une é toile ('*'), tous les noms publics dé finis dans le module sont lié s dans
l’espace des noms locaux de la porté e où apparaît l’instruction import.
Les noms publics dé finis par un module sont dé terminé s en cherchant dans l’espace de nommage du module une
variable nommé e __all__ ; Si elle est dé finie, elle doit ê tre une sé quence de chaînes dé signant les noms dé finis ou
importé s par ce module. Les noms donné s dans __all__ sont tous considé ré s publics et doivent exister. Si __all__
n’est pas dé finie, l’ensemble des noms publics contient tous les noms trouvé s dans l’espace des noms du module qui
ne commencent pas par un caractè re souligné (_). __all__ doit contenir toute l’API publique. Elle est destiné e à
é viter l’exportation accidentelle d’é lé ments qui ne font pas partie de l’API (tels que des modules de bibliothè ques qui
ont é té importé s et utilisé s à l’inté rieur du module).
La forme d’import avec asté risque --- from module import * --- est autorisé e seulement au niveau du module.
Si vous essayez de l’utiliser dans une dé finition de classe ou de fonction, cela lè ve une SyntaxError.
Quand vous spé cifiez les modules à importer, vous n’avez pas besoin de spé cifier les noms absolus des modules. Quand
un module ou un paquet est contenu dans un autre paquet, il est possible d’effectuer une importation relative à l’inté -
rieur du mê me paquet de plus haut niveau sans avoir à mentionner le nom du paquet. En utilisant des points en entê te
du module ou du paquet spé cifié aprè s from, vous pouvez spé cifier combien de niveaux vous souhaitez remonter
dans la hié rarchie du paquet courant sans spé cifier de nom exact. Un seul point en tê te signifie le paquet courant où
se situe le module qui effectue l’importation. Deux points signifient de remonter d’un niveau. Trois points, remon-
ter de deux niveaux et ainsi de suite. Ainsi, si vous exé cutez from . import mod dans un module du paquet pkg,
vous importez finalement [Link]. Et si vous exé cutez from ..souspkg2 import mod depuis pkg.souspkg1,
vous importez finalement [Link]. La spé cification des importations relatives se situe dans la section
Importations relatives au paquet.
importlib.import_module() est fournie pour gé rer les applications qui dé terminent dynamiquement les mo-
dules à charger.
Lè ve un é vè nement d’audit avec les arguments module, filename, [Link], sys.meta_path, sys.
path_hooks.

7.11. L’instruction import 107

The Python Language Reference, Version 3.13.7

7.11.1 L’instruction future

Une instruction future est une directive à l’attention du compilateur afin qu’un module particulier soit compilé en
utilisant une syntaxe ou une sé mantique qui sera disponible dans une future version de Python où cette fonctionnalité
est devenue un standard.
L’instruction future a vocation à faciliter les migrations vers les futures versions de Python qui introduisent des chan-
gements incompatibles au langage. Cela permet l’utilisation de nouvelles fonctionnalité s module par module avant
qu’une version n’officialise cette fonctionnalité comme un standard.

future_stmt ::= "from" "__future__" "import" feature ["as" identifier]

("," feature ["as" identifier])*
| "from" "__future__" "import" "(" feature ["as" identifier]
("," feature ["as" identifier])* [","] ")"
feature ::= identifier

Une instruction future doit apparaître en haut du module. Les seules lignes autorisé es avant une instruction future
sont :
— la chaîne de documentation du module (si elle existe),
— des commentaires,
— des lignes vides et
— d’autres instructions future.
La seule fonctionnalité qui né cessite l’utilisation de l’instruction future est annotations (voir la PEP 563).
Toutes les fonctionnalité s (feature dans la grammaire ci-dessus) autorisé es par l’instruction future sont toujours
reconnues par Python 3. Cette liste comprend absolute_import, division, generators, generator_stop,
unicode_literals, print_function, nested_scopes et with_statement. Elles sont toutes redondantes
car elles sont de toute maniè re activé es ; elles ne sont conservé es que par souci de compatibilité descendante.
Une instruction future est reconnue et traité e spé cialement au moment de la compilation : les modifications à la sé -
mantique des constructions de base sont souvent implé menté es en gé né rant un code diffé rent. Il peut mê me arriver
qu’une nouvelle fonctionnalité ait une syntaxe incompatible (tel qu’un nouveau mot ré servé ) ; dans ce cas, le compila-
teur a besoin d’analyser le module de maniè re diffé rente. De telles dé cisions ne peuvent pas ê tre diffé ré es au moment
de l’exé cution.
Pour une version donné e, le compilateur sait quelles fonctionnalité s ont é té dé finies et lè ve une erreur à la compilation
si une instruction future contient une fonctionnalité qui lui est inconnue.
La sé mantique à l’exé cution est la mê me que pour toute autre instruction d’importation : il existe un module standard
__future__, dé crit plus loin, qui est importé comme les autres au moment où l’instruction future est exé cuté e.

La sé mantique particuliè re à l’exé cution dé pend des fonctionnalité s apporté es par l’instruction future.
Notez que l’instruction suivante est tout à fait normale :

import __future__ [as name]

Ce n’est pas une instruction future ; c’est une instruction d’importation ordinaire qui n’a aucune sé mantique particuliè re
ou restriction de syntaxe.
Code compiled by calls to the built-in functions exec() and compile() that occur in a module M containing a
future statement will, by default, use the new syntax or semantics associated with the future statement. This can be
controlled by optional arguments to compile() --- see the documentation of that function for details.
Une instruction future entré e à l’invite de l’interpré teur interactif est effective pour le reste de la session de l’interpré -
teur. Si l’interpré teur est dé marré avec l’option -i, qu’un nom de script est passé pour ê tre exé cuté et que ce script
contient une instruction future, elle est effective pour la session interactive qui dé marre aprè s l’exé cution du script.

µ Voir aussi

PEP 236 — retour vers le __future__

La proposition originale pour le mé canisme de __future__.

108 Chapitre 7. Les instructions simples

 The Python Language Reference, Version 3.13.7

7.12 L’instruction global

global_stmt ::= "global" identifier ("," identifier)*

The global statement causes the listed identifiers to be interpreted as globals. It would be impossible to assign to a
global variable without global, although free variables may refer to globals without being declared global.
The global statement applies to the entire current scope (module, function body or class definition). A
SyntaxError is raised if a variable is used or assigned to prior to its global declaration in the scope.

At the module level, all variables are global, so a global statement has no effect. However, variables must still not be
used or assigned to prior to their global declaration. This requirement is relaxed in the interactive prompt (REPL).
Note pour les programmeurs : global est une directive à l’attention de l’analyseur syntaxique. Elle s’applique uni-
quement au code analysé en mê me temps que l’instruction global. En particulier, une instruction global contenue
dans une chaîne ou un objet code fourni à la fonction native exec() n’affecte pas le code contenant cet appel et le
code contenu dans un telle chaîne n’est pas affecté par une instruction global placé e dans le code contenant l’appel.
Il en est de mê me pour les fonctions eval() et compile().

7.13 L’instruction nonlocal

nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*

When the definition of a function or class is nested (enclosed) within the definitions of other functions, its nonlocal
scopes are the local scopes of the enclosing functions. The nonlocal statement causes the listed identifiers to refer
to names previously bound in nonlocal scopes. It allows encapsulated code to rebind such nonlocal identifiers. If a
name is bound in more than one nonlocal scope, the nearest binding is used. If a name is not bound in any nonlocal
scope, or if there is no nonlocal scope, a SyntaxError is raised.
The nonlocal statement applies to the entire scope of a function or class body. A SyntaxError is raised if a
variable is used or assigned to prior to its nonlocal declaration in the scope.

µ Voir aussi

PEP 3104 -- Accès à des noms en dehors de la portée locale

Les spé cifications pour l’instruction nonlocal.

Programmer’s note : nonlocal is a directive to the parser and applies only to code parsed along with it. See the
note for the global statement.

7.14 The type statement

type_stmt ::= 'type' identifier [type_params] "=" expression
The type statement declares a type alias, which is an instance of [Link].
For example, the following statement creates a type alias :

type Point = tuple[float, float]

This code is roughly equivalent to :

annotation-def VALUE_OF_Point():
return tuple[float, float]
Point = [Link]("Point", VALUE_OF_Point())

annotation-def indicates an annotation scope, which behaves mostly like a function, but with several small dif-
ferences.

7.12. L’instruction global 109

The Python Language Reference, Version 3.13.7

The value of the type alias is evaluated in the annotation scope. It is not evaluated when the type alias is created, but
only when the value is accessed through the type alias’s __value__ attribute (see Lazy evaluation). This allows the
type alias to refer to names that are not yet defined.
Type aliases may be made generic by adding a type parameter list after the name. See Generic type aliases for more.
type is a soft keyword.

Ajouté dans la version 3.12.

µ Voir aussi

PEP 695 - Type Parameter Syntax

Introduced the type statement and syntax for generic classes and functions.

110 Chapitre 7. Les instructions simples

 CHAPITRE 8

Instructions composées

Les instructions composé es contiennent d’autres (groupes d’) instructions ; elles affectent ou contrô lent l’exé cution de
ces autres instructions d’une maniè re ou d’une autre. En gé né ral, une instruction composé e couvre plusieurs lignes
bien que, dans sa forme la plus simple, une instruction composé e peut tenir sur une seule ligne.
Les instructions if , while et for implé mentent les constructions classiques de contrô le de flux. try dé finit des
gestionnaires d’exception et du code de nettoyage pour un groupe d’instructions, tandis que l’instruction with permet
l’exé cution de code d’initialisation et de finalisation autour d’un bloc de code. Les dé finitions de fonctions et de classes
sont é galement, au sens syntaxique, des instructions composé es.
Une instruction composé e comporte une ou plusieurs « clauses ». Une clause se compose d’un en-tê te et d’une
« suite ». Les en-tê tes des clauses d’une instruction composé e particuliè re sont toutes placé es au mê me niveau d’in-
dentation. Chaque en-tê te de clause commence par un mot-clé spé cifique et se termine par le caractè re deux-points
(:) ; une suite est un groupe d’instructions contrô lé es par une clause ; une suite se compose, aprè s les deux points de
l’en-tê te, soit d’une ou plusieurs instructions simples sé paré es par des points-virgules si elles sont sur la mê me ligne
que l’en-tê te, soit d’une ou plusieurs instructions en retrait sur les lignes suivantes. Seule cette derniè re forme d’une
suite peut contenir des instructions composé es ; ce qui suit n’est pas licite, principalement parce qu’il ne serait pas
clair de savoir à quelle clause if se rapporterait une clause else placé e en fin de ligne :

if test1: if test2: print(x)

Notez é galement que le point-virgule se lie plus é troitement que le deux-points dans ce contexte, de sorte que dans
l’exemple suivant, soit tous les appels print() sont exé cuté s, soit aucun ne l’est :

if x < y < z: print(x); print(y); print(z)

En ré sumé :

compound_stmt ::= if_stmt

| while_stmt
| for_stmt
| try_stmt
| with_stmt
| match_stmt
| funcdef
| classdef
| async_with_stmt
| async_for_stmt
| async_funcdef

111
The Python Language Reference, Version 3.13.7

suite ::= stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT

statement ::= stmt_list NEWLINE | compound_stmt
stmt_list ::= simple_stmt (";" simple_stmt)* [";"]

Notez que ces instructions se terminent toujours par un lexè me NEWLINE suivi é ventuellement d’un DEDENT. Notez
é galement que les clauses facultatives qui suivent commencent toujours par un mot-clé qui ne peut pas commencer
une instruction. Ainsi, il n’y a pas d’ambiguïté (le problè me du else dont on ne sait pas à quel if il est relié est ré solu
en Python en exigeant que des instructions if imbriqué es soient indenté es les unes par rapport aux autres).
L’agencement des rè gles de grammaire dans les sections qui suivent place chaque clause sur une ligne sé paré e pour
plus de clarté .

8.1 L’instruction if
L’instruction if est utilisé e pour exé cuter des instructions en fonction d’une condition :

if_stmt ::= "if" assignment_expression ":" suite

("elif" assignment_expression ":" suite)*
["else" ":" suite]
Elle sé lectionne exactement une des suites en é valuant les expressions une par une jusqu’à ce qu’une soit vraie (voir
la section Opérations booléennes pour la dé finition de vrai et faux) ; ensuite cette suite est exé cuté e (et aucune autre
partie de l’instruction if n’est exé cuté e ou é valué e). Si toutes les expressions sont fausses, la suite de la clause else,
si elle existe, est exé cuté e.

8.2 L’instruction while

L’instruction while est utilisé e pour exé cuter des instructions de maniè re ré pé té e tant qu’une expression est vraie :

while_stmt ::= "while" assignment_expression ":" suite

["else" ":" suite]

Python é value l’expression de maniè re ré pé té e et, tant qu’elle est vraie, exé cute la premiè re suite ; si l’expression est
fausse (ce qui peut arriver mê me lors du premier test), la suite de la clause else, si elle existe, est exé cuté e et la
boucle se termine.
Une instruction break exé cuté e dans la premiè re suite termine la boucle sans exé cuter la suite de la clause else.
Une instruction continue exé cuté e dans la premiè re suite saute le reste de la suite et retourne au test de l’expression.

8.3 L’instruction for

L’instruction for est utilisé e pour ité rer sur les é lé ments d’une sé quence (par exemple une chaîne, un n-uplet ou une
liste) ou un autre objet ité rable :

for_stmt ::= "for" target_list "in" starred_list ":" suite

["else" ":" suite]

L’expression starred_list n’est é valué e qu’une seule fois ; elle doit produire un objet iterable. Un iterator est cré é
pour cet ité rable. Le premier é lé ment produit par l’ité rateur est assigné à la liste cible (target_list dans la grammaire
ci-dessus) en utilisant les rè gles des affectations (voir Les assignations), puis la « suite » est exé cuté e. Lorsque les
é lé ments de l’ité rateur sont é puisé s, la « suite » de la clause else, si elle existe, est exé cuté e et la boucle se termine.
Une instruction break exé cuté e dans la premiè re suite termine la boucle sans exé cuter la suite de la clause else.
Une instruction continue exé cuté e dans la premiè re suite saute le reste de la suite et continue avec l’é lé ment suivant,
ou avec la clause else s’il n’y a pas d’é lé ment suivant.
La boucle for effectue des affectations aux variables de la liste cible, ce qui é crase toutes les affectations anté rieures
de ces variables, y compris celles effectué es dans la suite de la boucle for :

112 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

for i in range(10):
print(i)
i = 5 # this will not affect the for-loop
# because i will be overwritten with the next
# index in the range

Les noms dans la liste cible ne sont pas supprimé s lorsque la boucle est terminé e mais, si la sé quence est vide, ils
n’auront pas du tout é té assigné s par la boucle. Petite astuce : le type natif range() repré sente des suites arithmé tiques
immuables de nombres entiers ; par exemple, ité rer sur range(3) renvoie successivement les entiers 0, 1 et 2.
Modifié dans la version 3.11 : les é lé ments é toilé s sont maintenant autorisé s dans l’expression liste.

8.4 L’instruction try

L’instruction try dé finit les gestionnaires d’exception ou le code de nettoyage pour un groupe d’instructions :

try_stmt ::= try1_stmt | try2_stmt | try3_stmt

try1_stmt ::= "try" ":" suite
("except" [expression ["as" identifier]] ":" suite)+
["else" ":" suite]
["finally" ":" suite]
try2_stmt ::= "try" ":" suite
("except" "*" expression ["as" identifier] ":" suite)+
["else" ":" suite]
["finally" ":" suite]
try3_stmt ::= "try" ":" suite
"finally" ":" suite

Vous trouvez des informations supplé mentaires relatives aux exceptions dans la section Exceptions et, dans la section
L’instruction raise, des informations relatives à l’utilisation de l’instruction raise pour produire des exceptions.

8.4.1 clause except

The except clause(s) specify one or more exception handlers. When no exception occurs in the try clause, no
exception handler is executed. When an exception occurs in the try suite, a search for an exception handler is started.
This search inspects the except clauses in turn until one is found that matches the exception. An expression-less
except clause, if present, must be last ; it matches any exception.
For an except clause with an expression, the expression must evaluate to an exception type or a tuple of exception
types. The raised exception matches an except clause whose expression evaluates to the class or a non-virtual base
class of the exception object, or to a tuple that contains such a class.
Si aucune clause except ne correspond à l’exception, la recherche d’un gestionnaire d’exception se poursuit dans le
code englobant et dans la pile d’appels. 1
Si l’é valuation d’une expression dans l’en-tê te d’une clause except lè ve une exception, la recherche initiale d’un
gestionnaire est annulé e et une recherche commence pour la nouvelle exception dans le code englobant et dans la pile
d’appels (c’est traité comme si l’instruction try avait levé l’exception).
Lorsqu’une clause except correspond, l’exception est affecté e à la cible pré cisé e aprè s le mot-clé as dans cette
clause except, si cette cible existe, et la suite de clause except est exé cuté e. Toutes les clauses except doivent
avoir un bloc exé cutable. Lorsque la fin de ce bloc est atteinte, l’exé cution continue normalement aprè s l’ensemble de
l’instruction try (cela signifie que si deux gestionnaires imbriqué s existent pour la mê me exception, et que l’exception
se produit dans la clause try du gestionnaire interne, le gestionnaire externe ne gè re pas l’exception).
Lorsqu’une exception a é té affecté e en utilisant as cible, elle est effacé e à la fin de la clause except. C’est comme
si :
1. L’exception est propagé e à la pile d’appels à moins qu’il n’y ait une clause finally qui lè ve une autre exception, ce qui entraîne la perte
de l’ancienne exception. Cette nouvelle exception entraîne la perte pure et simple de l’ancienne.

8.4. L’instruction try 113

The Python Language Reference, Version 3.13.7

except E as N:
foo

avait é té traduit en :

except E as N:
try:
foo
finally:
del N

Cela veut dire que l’exception doit ê tre assigné e à un nom diffé rent pour pouvoir s’y ré fé rer aprè s la clause except.
Les exceptions sont effacé es parce qu’avec la trace de la pile d’appels qui leur est attaché e, elles cré ent un cycle dans
les pointeurs de ré fé rences (avec le cadre de la pile), ce qui conduit à conserver tous les noms locaux de ce cadre en
mé moire jusqu’au passage du ramasse-miettes.
Avant qu’une suite de clauses except ne soit exé cuté e, l’exception est stocké e dans le module sys, où elle est
accessible depuis le corps de la clause except en appelant [Link](). Lorsque vous quittez un gestionnaire
d’exceptions, l’exception stocké e dans le module sys est ré initialisé e à sa valeur pré cé dente :

>>> print([Link]())
None
>>> try:
... raise TypeError
... except:
... print(repr([Link]()))
... try:
... raise ValueError
... except:
... print(repr([Link]()))
... print(repr([Link]()))
...
TypeError()
ValueError()
TypeError()
>>> print([Link]())
None

8.4.2 clause except*

The except* clause(s) specify one or more handlers for groups of exceptions (BaseExceptionGroup instances).
A try statement can have either except or except* clauses, but not both. The exception type for matching is
mandatory in the case of except*, so except*: is a syntax error. The type is interpreted as in the case of except,
but matching is performed on the exceptions contained in the group that is being handled. An TypeError is raised
if a matching type is a subclass of BaseExceptionGroup, because that would have ambiguous semantics.
When an exception group is raised in the try block, each except* clause splits (see split()) it into the subgroups
of matching and non-matching exceptions. If the matching subgroup is not empty, it becomes the handled exception
(the value returned from [Link]()) and assigned to the target of the except* clause (if there is one).
Then, the body of the except* clause executes. If the non-matching subgroup is not empty, it is processed by the
next except* in the same manner. This continues until all exceptions in the group have been matched, or the last
except* clause has run.

After all except* clauses execute, the group of unhandled exceptions is merged with any exceptions that were raised
or re-raised from within except* clauses. This merged exception group propagates on. :

>>> try:
... raise ExceptionGroup("eg",
(suite sur la page suivante)

114 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

... [ValueError(1), TypeError(2), OSError(3), OSError(4)])
... except* TypeError as e:
... print(f'caught {type(e)} with nested {[Link]}')
... except* OSError as e:
... print(f'caught {type(e)} with nested {[Link]}')
...
caught <class 'ExceptionGroup'> with nested (TypeError(2),)
caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))
+ Exception Group Traceback (most recent call last):
| File "<doctest default[0]>", line 2, in <module>
| raise ExceptionGroup("eg",
| [ValueError(1), TypeError(2), OSError(3), OSError(4)])
| ExceptionGroup: eg (1 sub-exception)
+-+---------------- 1 ----------------
| ValueError: 1
+------------------------------------

If the exception raised from the try block is not an exception group and its type matches one of the except* clauses,
it is caught and wrapped by an exception group with an empty message string. This ensures that the type of the target
e is consistently BaseExceptionGroup :

>>> try:
... raise BlockingIOError
... except* BlockingIOError as e:
... print(repr(e))
...
ExceptionGroup('', (BlockingIOError()))

break, continue and return cannot appear in an except* clause.

8.4.3 clause else

La clause optionnelle else n’est exé cuté e que si l’exé cution atteint la fin de la clause try , aucune exception n’a é té
levé e, et aucun return, continue, ou break ont é té s exé cuté s. Les exceptions dans la clause else ne sont pas
gé ré es par les clauses except pré cé dentes.

8.4.4 clause finally

If finally is present, it specifies a ’cleanup’ handler. The try clause is executed, including any except and else
clauses. If an exception occurs in any of the clauses and is not handled, the exception is temporarily saved. The
finally clause is executed. If there is a saved exception it is re-raised at the end of the finally clause. If the
finally clause raises another exception, the saved exception is set as the context of the new exception. If the
finally clause executes a return, break or continue statement, the saved exception is discarded :

>>> def f():

... try:
... 1/0
... finally:
... return 42
...
>>> f()
42

L’information relative à l’exception n’est pas disponible pour le programme pendant l’exé cution de la clause finally.
Lorsqu’une instruction return, break ou continue est exé cuté e dans la suite d’une instruction try d’une construc-
tion try…finally, la clause finally est aussi exé cuté e « à la sortie ».

8.4. L’instruction try 115

The Python Language Reference, Version 3.13.7

La valeur de retour d’une fonction est dé terminé e par la derniè re instruction return exé cuté e. Puisque la clause
finally s’exé cute toujours, une instruction return exé cuté e dans le finally sera toujours la derniè re clause
exé cuté e :

>>> def foo():

... try:
... return 'try'
... finally:
... return 'finally'
...
>>> foo()
'finally'

Modifié dans la version 3.8 : Avant Python 3.8, une instruction continue n’é tait pas licite dans une clause finally
en raison d’un problè me dans l’implé mentation.

8.5 L’instruction with

L’instruction with est utilisé e pour encapsuler l’exé cution d’un bloc avec des mé thodes dé finies par un gestionnaire
de contexte (voir la section Gestionnaire de contexte With). Cela permet d’utiliser de maniè re simple le patron de
conception classique try …except…finally .

with_stmt ::= "with" ( "(" with_stmt_contents ","? ")" | with_stmt_contents ) ":" suite
with_stmt_contents ::= with_item ("," with_item)*
with_item ::= expression ["as" target]

L’exé cution de l’instruction with avec un seul « é lé ment » (item dans la grammaire) se dé roule comme suit :
1. L’expression de contexte (l’expression donné e dans le with_item) est é valué e pour obtenir un gestionnaire
de contexte.
2. The context manager’s __enter__() is loaded for later use.
3. The context manager’s __exit__() is loaded for later use.
4. The context manager’s __enter__() method is invoked.
5. If a target was included in the with statement, the return value from __enter__() is assigned to it.

® Note

The with statement guarantees that if the __enter__() method returns without an error, then
__exit__() will always be called. Thus, if an error occurs during the assignment to the target list,
it will be treated the same as an error occurring within the suite would be. See step 7 below.

6. La suite est exé cuté e.

7. The context manager’s __exit__() method is invoked. If an exception caused the suite to be exited, its
type, value, and traceback are passed as arguments to __exit__(). Otherwise, three None arguments are
supplied.
If the suite was exited due to an exception, and the return value from the __exit__() method was false, the
exception is reraised. If the return value was true, the exception is suppressed, and execution continues with
the statement following the with statement.
If the suite was exited for any reason other than an exception, the return value from __exit__() is ignored,
and execution proceeds at the normal location for the kind of exit that was taken.
Le code suivant :

with EXPRESSION as TARGET:

SUITE

est sé mantiquement é quivalent à :

116 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

manager = (EXPRESSION)
enter = type(manager).__enter__
exit = type(manager).__exit__
value = enter(manager)
hit_except = False

try:
TARGET = value
SUITE
except:
hit_except = True
if not exit(manager, *sys.exc_info()):
raise
finally:
if not hit_except:
exit(manager, None, None, None)

Avec plus d’un é lé ment, les gestionnaires de contexte sont traité s comme si plusieurs instructions with é taient im-
briqué es :

with A() as a, B() as b:

SUITE

est sé mantiquement é quivalent à :

with A() as a:
with B() as b:
SUITE

Vous pouvez aussi é crire des gestionnaires de contexte sur plusieurs lignes pour plus d’un é lé ment si ceux-ci sont
placé s entre parenthè ses. Par exemple :

with (
A() as a,
B() as b,
):
SUITE

Modifié dans la version 3.1 : Prise en charge de multiples expressions de contexte.

Modifié dans la version 3.10 : prise en charge des parenthè ses pour pouvoir é crire l’instruction sur plusieurs lignes.

µ Voir aussi

PEP 343 — L’instruction « with »

La spé cification, les motivations et des exemples de l’instruction with en Python.

8.6 L’instruction match

Ajouté dans la version 3.10.
L’instruction match est utilisé e pour le filtrage par motif. Sa syntaxe est :

match_stmt ::= 'match' subject_expr ":" NEWLINE INDENT case_block+ DEDENT

subject_expr ::= star_named_expression "," star_named_expressions?
| named_expression
case_block ::= 'case' patterns [guard] ":" block

8.6. L’instruction match 117

The Python Language Reference, Version 3.13.7

® Note

cette section utilise les guillemets simples pour dé signer les mots-clés ad-hoc.

Le filtrage par motif prend un motif en entré e (pattern aprè s case) et un champ de recherche (subject_expr
aprè s match). Le motif du filtre (qui peut contenir des sous-motifs de filtrage) est confronté au contenu du champ
de recherche. La sortie est composé e de :
— un indicateur de ré ussite ou d’é chec pour le filtrage (on peut aussi dire que le motif a ré ussi ou é choué ) ;
— la possibilité de lier les valeurs filtré es à un nom. Les pré -requis sont indiqué s plus bas.
Les mots-clé s match et case sont des mots-clés ad-hoc.

µ Voir aussi

— PEP 634 — Spé cifications pour le filtrage par motif

— PEP 636 — Tutoriel pour le filtrage par motif

8.6.1 Aperçu
Voici un aperçu du dé roulement logique d’un filtrage par motif :
1. L’expression confronté e aux filtres, subject_expr, est é valué e pour obtenir la valeur ré sultante. Si l’expres-
sion contient une virgule, un n-uplet est construit en utilisant les rè gles classiques.
2. Chaque filtre des blocs case_block est confronté à la valeur ré sultante du champ de recherche. Les rè gles
particuliè res pour la ré ussite ou l’é chec sont dé crites plus bas. La confrontation du filtre peut aussi conduire à
lier un ou plusieurs noms pré sents dans le motif. Les rè gles pour lier les noms des motifs dé pendent du type
de filtre et sont dé crites plus bas. Le nommage effectué lors d’un filtrage par motif qui a réussi persiste
à l’extérieur du bloc et le nom peut être utilisé après l’instruction match.

® Note

en cas d’é chec de la recherche, certains sous-filtres peuvent avoir ré ussi. Ne vous fiez pas aux nommages
faits lors d’un filtrage qui a é choué . Inversement, ne vous fiez pas aux variables qui restent inchangé es
aprè s un filtrage infructueux. Le comportement exact dé pend de l’implé mentation et peut varier. Il s’agit
d’un choix intentionnel afin de permettre aux implé mentations d’ajouter des optimisations.

3. Si la recherche ré ussit, la garde correspondante (si elle existe) est é valué e. Dans ce cas, on est sû r que les
nommages ont bien eu lieu.
— Si la garde s’é value à vrai ou s’il n’y a pas de garde, le block à l’inté rieur du case_block est exé cuté .
— Sinon, le case_block est testé comme dé crit ci-dessus.
— S’il n’y a plus de bloc case_block, l’instruction est terminé e.

® Note

l’utilisateur ne doit jamais faire confiance à un filtre en cours d’é valuation. En fonction de l’implé mentation,
l’interpré teur peut mettre des valeurs en cache ou utiliser des optimisations qui é vitent des ré évaluations.

Voici un exemple d’instruction de filtrage par motif :

>>> flag = False

>>> match (100, 200):
... case (100, 300): # Mismatch: 200 != 300
... print('Case 1')
... case (100, 200) if flag: # Successful match, but guard fails
... print('Case 2')
... case (100, y): # Matches and binds y to 200
(suite sur la page suivante)

118 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

... print(f'Case 3, y: {y}')
... case _: # Pattern not attempted
... print('Case 4, I match anything!')
...
Case 3, y: 200

Dans cet exemple, if flag est une garde. Plus de dé tails sont fournis dans la prochaine section.

8.6.2 Gardes
guard ::= "if" named_expression
Une garde (guard qui fait partie du case) doit s’é valuer à vrai pour que le code à l’inté rieur du bloc case soit
exé cuté . Elle s’é crit sous la forme du mot-clé if suivi d’une expression.
Le dé roulement logique d’un bloc case qui comprend une garde est le suivant :
1. Vé rification que le filtrage dans le bloc case est fructueux. Si le filtrage é choue, la garde n’est pas é valué e et
on passe au bloc case suivant.
2. Si le filtrage est fructueux, é valuation de la garde.
— Si la garde s’é value à vrai, le bloc est sé lectionné .
— Si la garde s’é value à faux, le bloc n’est pas sé lectionné .
— Si une exception est levé e lors de l’é valuation de la garde, cette exception est propagé e.
Les gardes é tant des expressions, il est possible qu’elles aient des effets secondaires. L’ordre d’é valuation des gardes
est du premier au dernier bloc case, un à la fois, en sautant les blocs case dont la recherche de motif é chouent.
L’é valuation des gardes s’arrê te dè s qu’un bloc case est sé lectionné .

8.6.3 Bloc case attrape-tout

Un bloc case attrape-tout est un bloc qui ré ussit toujours. Une instruction match ne peut avoir qu’un seul bloc
attrape-tout, et ce doit ê tre le dernier.
Un bloc case est considé ré attrape-tout s’il n’y a pas de garde et que le motif est attrape-tout. Un motif est attrape-
tout si l’on peut dé terminer, simplement à partir de sa syntaxe, qu’il correspond toujours. Seuls les motifs suivants
sont attrape-tout :
— Les Filtres AS pour lesquels la partie gauche est attrape-tout
— Les Filtres OU contenant au moins un filtre attrape-tout
— Les Filtres de capture
— Les Filtres attrape-tout
— les filtres attrape-tout entre parenthè ses

8.6.4 Filtres

® Note

Cette section utilise des notations grammaticales qui ne font pas partie du standard EBNF :
— la notation [Link]+ dé signe REGLE (SEP REGLE)*
— la notation !REGLE dé signe la né gation logique de l’assertion REGLE

La syntaxe gé né rale pour les filtres patterns est :

patterns ::= open_sequence_pattern | pattern

pattern ::= as_pattern | or_pattern
closed_pattern ::= | literal_pattern
| capture_pattern
| wildcard_pattern
| value_pattern

8.6. L’instruction match 119

The Python Language Reference, Version 3.13.7

| group_pattern
| sequence_pattern
| mapping_pattern
| class_pattern

Les explications ci-dessous dé crivent « en termes simples » ce qu’un modè le fait (merci à Raymond Hettinger pour
son document qui a inspiré la plupart des descriptions). Notez que ces descriptions sont purement à fin d’illustration
et peuvent ne pas ê tre strictement conformes à l’implé mentation sous-jacente. De plus, nous ne couvrons pas toutes
les formes valides.

Filtres OU
Un filtre OU est composé de deux filtres ou plus sé paré s par des barres verticales |. La syntaxe est :

or_pattern ::= "|".closed_pattern+

Seul le dernier sous-filtre peut ê tre attrape-tout et chaque sous-filtre doit ê tre lié au mê me ensemble de noms pour
é viter toute ambigü ité .
Un filtre OU confronte chacun des sous-filtres à tour de rô le à la valeur du champ de recherche, jusqu’à ce que l’un
d’eux ré ussisse. Le filtre OU ré ussit si l’un des sous-filtres a ré ussi, sinon il é choue.
En termes plus simples, M1 | M2 | ... teste le filtre par motif M1, s’il é choue il teste le filtre par motif M2, ré ussit
immé diatement si l’un d’eux ré ussit, é choue dans le cas contraire.

Filtres AS
Un filtre AS confronte un filtre OU sur la gauche du mot-clé as au champ de recherche. La syntaxe est la suivante :

as_pattern ::= or_pattern "as" capture_pattern

Si le filtre OU é choue, le filtre AS é choue. Sinon, le filtre AS lie le champ de recherche au nom sur la droite du
mot-clé as et ré ussit. capture_pattern ne peut pas ê tre un _.
En termes simples, M as NOM filtre avec le motif M et, s’il ré ussit, dé finit NOM = <subject>.

Filtres littéraux
Un filtre litté ral effectue une correspondance avec la plupart des littéraux en Python. La syntaxe est la suivante :

literal_pattern ::= signed_number

| signed_number "+" NUMBER
| signed_number "-" NUMBER
| strings
| "None"
| "True"
| "False"
signed_number ::= ["-"] NUMBER

La rè gle strings et le lexè me NUMBER sont dé finis dans la grammaire de Python standard. Les chaînes avec triples
guillemets sont gé ré es. Les chaînes brutes et les chaînes d’octets sont gé ré es. Les f-strings ne sont pas gé ré es.
Les formes signed_number '+' NUMBER et signed_number '-' NUMBER permettent d’exprimer des nombres
complexes ; vous devez indiquer un nombre ré el sur la gauche et un nombre imaginaire sur la droite. Par exemple, 3
+ 4j.

En termes simples, LITERAL ré ussit seulement si <subject> == LITERAL. Pour les singletons None, True et
False, l’opé rateur is est utilisé .

Filtres de capture
Un filtre de capture lie la valeur du champ de recherche à un nom. La syntaxe est la suivante :

capture_pattern ::= !'_' NAME

120 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

Un simple caractè re souligné _ n’est pas un filtre de capture (c’est ce que !'_' veut dire). C’est le motif pour dé signer
un filtre attrape-tout (lexè me wilcard_pattern, voir plus bas).
Dans un filtre donné , un nom ne peut ê tre lié qu’une seule fois. Par exemple, case x, x: ... est invalide mais
case [x] | x: ... est autorisé .
Les filtres de capture ré ussissent toujours. La porté e du lien est conforme aux rè gles dé finies pour l’opé rateur d’af-
fectation indiqué es dans la PEP 572 ; le nom devient une variable locale dans la fonction la plus inté rieure à moins
qu’il n’y ait une instruction global ou nonlocal qui s’applique.
En termes simples, NAME ré ussit toujours et dé finit NAME = <subject>.

Filtres attrape-tout
Un filtre attrape-tout ré ussit toujours (quel que soit le champ de recherche) et ne lie aucun nom. La syntaxe est la
suivante :

wildcard_pattern ::= '_'

_ est un mot-clé ad-hoc dans un filtre par motif, mais seulement dans un filtre. Ailleurs, c’est un identifiant, comme
d’habitude, mê me à l’inté rieur d’une expression champ de recherche de match, d’une garde ou d’un bloc case.
En termes simples, _ ré ussit toujours.

Filtres par valeurs

Un filtre par valeur repré sente une valeur nommé e de Python. Sa syntaxe est la suivante :

value_pattern ::= attr

attr ::= name_or_attr "." NAME
name_or_attr ::= attr | NAME

Le nom qualifié dans le filtre est recherché en utilisant la méthode de résolution des noms standard de Python. Le
filtrage ré ussit si la valeur trouvé e vé rifie l’é galité avec la valeur du champ de recherche (en utilisant l’opé rateur
d’é galité ==).
En termes plus simples, NOM1.NOM2 ré ussit seulement si <subject> == NOM1.NOM2

® Note

si la mê me valeur apparaît plusieurs fois dans la mê me instruction match, l’interpré teur peut mettre en cache
la premiè re valeur trouvé e et la ré utiliser plutô t que de refaire une recherche. Ce cache est strictement limité à
l’exé cution de l’instruction match donné e.

Filtres de groupes
Un filtre de groupe permet au programmeur de souligner l’intention de regrouper des motifs en plaçant ceux-ci entre
parenthè ses. À part ça, il n’introduit aucune syntaxe supplé mentaire. Sa syntaxe est la suivante :

group_pattern ::= "(" pattern ")"

En termes plus simples, (P) é quivaut à P.

Filtres de séquences
Un filtre de sé quence contient des sous-filtres par motif dont chacun doit correspondre à un é lé ment d’une sé quence.
La syntaxe est similaire au dé ballage d’une liste ou d’un n-uplet.

sequence_pattern ::= "[" [maybe_sequence_pattern] "]"

| "(" [open_sequence_pattern] ")"
open_sequence_pattern ::= maybe_star_pattern "," [maybe_sequence_pattern]
maybe_sequence_pattern ::= ",".maybe_star_pattern+ ","?

8.6. L’instruction match 121

The Python Language Reference, Version 3.13.7

maybe_star_pattern ::= star_pattern | pattern

star_pattern ::= "*" (capture_pattern | wildcard_pattern)

Vous pouvez utiliser indiffé remment des parenthè ses (...) ou des crochets [...] pour encadrer les filtres à re-
grouper.

® Note

un filtre seul entre parenthè ses qui ne se termine pas par une virgule (par exemple (3 | 4)) est un filtre de
groupe. En revanche, un filtre seul entre crochets (par exemple [3 | 4]) reste un filtre de sé quence.

Il peut y avoir au plus un sous-filtre é toilé (lexè me star_pattern) dans un filtre de sé quence. Le filtre é toilé peut
se trouver à n’importe quelle position. S’il n’y en a pas, le filtre de sé quence est un filtre de sé quence à longueur fixe,
sinon c’est un filtre de sé quence à longueur variable.
Voici le dé roulement logique d’un filtrage par motif de sé quence sur une valeur du champ de recherche :
1. Si la valeur du champ de recherche n’est pas une sé quence 2 , le filtre de sé quence é choue.
2. Si la valeur du champ de recherche est une instance de str, bytes ou bytearray, le filtre de sé quence
é choue.
3. Les é tapes suivantes dé pendent de la longueur fixe ou non du filtre de sé quence.
Si le filtre de sé quence est de longueur fixe :
1. Si la longueur de la sé quence champ de recherche n’est pas é gale au nombre de sous-filtres, le filtre de
sé quence é choue.
2. Les sous-filtres de la sé quence sont confronté s aux é lé ments correspondants dans la sé quence champ de re-
cherche, de la gauche vers la droite. La recherche de correspondance s’arrê te dè s qu’un sous-filtre é choue.
Si tous les sous-filtres ré ussissent la confrontation à l’é lé ment du champ de recherche correspondant, le
filtre de sé quence ré ussit.
Sinon, si le filtre de sé quence est de longueur variable :
1. Si la longueur de la sé quence champ de recherche est plus petite que le nombre de sous-filtres sans é toile,
le filtre de sé quence é choue.
2. Les sous-filtres sans é toile du dé but sont confronté s aux é lé ments correspondants comme pour un filtre
de sé quences de longueur fixe.
3. Si les é tapes pré cé dentes ont ré ussi, le sous-filtre é toilé correspond à une liste formé e des é lé ments restants
du champ de recherche, en excluant les é lé ments restants qui correspondent à des sous-filtres sans é toile
qui suivent le sous-filtre é toilé .
4. Les sous-filtres sans é toile qui restent sont confronté s aux é lé ments restants du champ de recherche,
comme pour un filtre de sé quences de longueur fixe.

2. Dans le filtrage par motif, une sé quence est dé finie comme suit :
— une classe qui hé rite de [Link]
— une classe Python qui a é té enregistré e en tant que [Link]
— une classe native dont le bit (CPython) Py_TPFLAGS_SEQUENCE est à 1
— une classe qui hé rite d’une classe cité e ci-dessus
Les classes suivantes de la bibliothè que standard sont des sé quences :
— [Link]
— [Link]
— list
— memoryview
— range
— tuple

® Note

Les champs de recherche du type str, bytes et bytearray ne correspondent pas avec des filtres de sé quence.

122 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

® Note

la longueur de la sé quence champ de recherche est obtenue par len() (c.-à -d. avec le protocole
__len__()). Cette longueur peut ê tre mise en cache par l’interpré teur de la mê me maniè re que pour
les filtres par valeur.

En termes plus simples, [M1, M2, M3, … , M<N>] ré ussit seulement si tout ce qui suit a lieu :
— vé rification que <subject> est une sé quence,
— len(subject) == <N>,
— M1 correspond à <subject>[0] (notez que cette correspondance peut lier des noms),
— M2 correspond à <subject>[1] (notez que cette correspondance peut lier des noms),
— et ainsi de suite pour chaque filtre par motif / é lé ment.

Filtres associatifs
Un filtre associatif contient un ou plusieurs motifs clé -valeur. La syntaxe est similaire à la construction d’un diction-
naire :

mapping_pattern ::= "{" [items_pattern] "}"

items_pattern ::= ",".key_value_pattern+ ","?
key_value_pattern ::= (literal_pattern | value_pattern) ":" pattern
| double_star_pattern
double_star_pattern ::= "**" capture_pattern

Un seul sous-filtre doublement é toilé peut ê tre pré sent dans le filtre associatif. Le filtre doublement é toilé doit ê tre le
dernier sous-filtre du filtre associatif.
Il est interdit d’avoir des clé s en double dans les filtres associatifs. Une clé en double sous forme litté rale lè ve une
Syntax Error. Deux clé s qui ont la mê me valeur lè vent une ValueError à l’exé cution.

Voici le dé roulement d’un filtrage associatif sur la valeur du champ de recherche :
1. Si la valeur du champ de recherche n’est pas un tableau associatif 3 , le filtre associatif é choue.
2. Si chaque clé donné e dans le filtre associatif est pré sente dans le tableau associatif du champ de recherche,
et que le filtre pour chaque clé correspond aux é lé ments du tableau associatif champ de recherche, le filtre
associatif ré ussit.
3. Si des clé s identiques sont dé tecté es dans le filtre par motif, le filtre est dé claré invalide. Une SyntaxError
est levé e pour les valeurs litté rales dupliqué es ou une ValueError pour des clé s s’é valuant à la mê me valeur.

® Note

Key-value pairs are matched using the two-argument form of the mapping subject’s get() method. Matched
key-value pairs must already be present in the mapping, and not created on-the-fly via __missing__() or
__getitem__().

En termes simples, {CLÉ1: M1, CLÉ2: M2, ... } ré ussit seulement si tout ce qui suit a lieu :
— vé rification que <subject> est un tableau associatif,
— CLÉ1 in <subject>,
— M1 correspond à <subject>[CLÉ1],
— et ainsi de suite pour chaque paire CLÉ/Motif.
3. Dans le filtrage par motif, un tableau associatif est dé fini comme suit :
— une classe qui hé rite de [Link]
— une classe Python qui a é té enregistré e en tant que [Link]
— une classe native dont le bit (CPython) Py_TPFLAGS_MAPPING est à 1
— une classe qui hé rite d’une classe cité e ci-dessus
Les classes dict et [Link] de la bibliothè que standard sont des tableaux associatifs.

8.6. L’instruction match 123

The Python Language Reference, Version 3.13.7

Filtres de classes
Un filtre de classe repré sente une classe et ses arguments positionnels et par mots-clé s (s’il y en a). La syntaxe est la
suivante :

class_pattern ::= name_or_attr "(" [pattern_arguments ","?] ")"

pattern_arguments ::= positional_patterns ["," keyword_patterns]
| keyword_patterns
positional_patterns ::= ",".pattern+
keyword_patterns ::= ",".keyword_pattern+
keyword_pattern ::= NAME "=" pattern

Le mê me mot-clé ne doit pas ê tre ré pé té dans les filtres de classes.
Voici le dé roulement d’un filtrage de classe sur la valeur du champ de recherche :
1. Si name_or_attr n’est pas une instance de la classe native type, lè ve une TypeError.
2. Si la valeur du champ de recherche n’est pas une instance de name_or_attr (testé via isinstance()), le
filtre de classe é choue.
3. S’il n’y a pas d’argument au filtre, le filtre ré ussit. Sinon, les é tapes suivantes dé pendent de la pré sence ou non
de motifs pour les arguments positionnels ou par mot-clé .
Pour un certain nombre de types natifs (indiqué s ci-dessous), un motif positionnel seul est accepté , qui est
confronté au champ de recherche en entier ; pour ces types, les motifs par mots-clé s fonctionnent comme les
autres types.
S’il n’y a que des motifs par mot-clé (NdT : dans le sens « argument par mot-clé »), ils sont é valué s comme
ceci, un par un :
I. Le mot-clé est recherché en tant qu’attribut du champ de recherche.
— Si cela lè ve une exception autre que AttributeError, l’exception est propagé e vers le haut.
— Si cela lè ve l’exception AttributeError, le filtre é choue.
— Sinon, le motif associé au mot-clé est confronté à la valeur de l’attribut du champ de recherche. Si cela
é choue, le filtre de classe é choue ; si cela ré ussit, le filtre passe au mot-clé suivant.
II. Si tous les motifs par mot-clé ont ré ussi, le filtre de classe ré ussit.
Si des motifs positionnels sont pré sents, ils sont convertis en motifs par mot-clé en utilisant l’attribut
__match_args__ de la classe name_or_attr avant le filtrage :

I. L’é quivalent de getattr(cls, "__match_args__", ()) est appelé .

— Si cela lè ve une exception, elle est propagé e vers le haut.
— Si la valeur de retour n’est pas un n-uplet, la conversion é choue et une TypeError est levé e.
— S’il y a plus de motifs positionnels que len(cls.__match_args__), une TypeError est levé e.
— Sinon, le motif positionnel i est converti en motif par mot-clé (le mot-clé sera
__match_args__[i]). __match_args__[i] doit ê tre une chaîne, sinon une TypeError est
levé e.
— Si un mot-clé est dupliqué , une TypeError est levé e.

µ Voir aussi

Arguments positionnels dans le filtrage par motif sur les classes

II. Une fois que tous les motifs positionnels ont été convertis en motifs par mot-clé,
le filtre se dé roule comme si tous les motifs é taient des motifs par mots-clé s.

Pour les types natifs suivants, le traitement des motifs positionnels est diffé rent :
— bool
— bytearray
— bytes
— dict
— float
— frozenset

124 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

— int
— list
— set
— str
— tuple
Ces classes acceptent un argument positionnel seul et le filtre s’applique alors sur l’ensemble de l’objet plutô t
que sur un simple attribut. Par exemple, int(0|1) ré ussit lorsqu’il est confronté à la valeur 0, mais pas
lorsque c’est la valeur 0.0.
En termes simples, CLS(P1, attr=P2) ré ussit seulement si la sé quence suivante est dé roulé e :
— isinstance(<subject>, CLS)
— convertit P1 vers un motif par mot-clé en utilisant CLS.__match_args__
— Pour chaque argument par mot-clé attr=P2 :
— hasattr(<subject>, "attr")
— P2 correspond à <subject>.attr
— … et ainsi de suite pour les paires motif/argument par mot-clé .

µ Voir aussi

— PEP 634 — Spé cifications pour le filtrage par motif

— PEP 636 — Tutoriel pour le filtrage par motif

8.7 Définition de fonctions

Une dé finition de fonction dé finit un objet fonction dé fini par l’utilisateur (voir la section Hiérarchie des types stan-
dards) :

funcdef ::= [decorators] "def" funcname [type_params] "(" [parameter_list] ")"

["->" expression] ":" suite
decorators ::= decorator+
decorator ::= "@" assignment_expression NEWLINE
parameter_list ::= defparameter ("," defparameter)* "," "/" ["," [parameter_list_no_p
| parameter_list_no_posonly
parameter_list_no_posonly ::= defparameter ("," defparameter)* ["," [parameter_list_starargs]]
| parameter_list_starargs
parameter_list_starargs ::= "*" [star_parameter] ("," defparameter)* ["," [parameter_star_kwar
| "*" ("," defparameter)+ ["," [parameter_star_kwargs]]
| parameter_star_kwargs
parameter_star_kwargs ::= "**" parameter [","]
parameter ::= identifier [":" expression]
star_parameter ::= identifier [":" ["*"] expression]
defparameter ::= parameter ["=" expression]
funcname ::= identifier

Une dé finition de fonction est une instruction qui est exé cuté e. Son exé cution lie le nom de la fonction, dans l’espace
de nommage local courant, à un objet fonction (un objet qui encapsule le code exé cutable de la fonction). Cet objet
fonction contient une ré fé rence à l’espace des noms globaux courant comme espace des noms globaux à utiliser lorsque
la fonction est appelé e.
La dé finition de la fonction n’exé cute pas le corps de la fonction ; elle n’est exé cuté e que lorsque la fonction est
appelé e. 4
Une dé finition de fonction peut ê tre encapsulé e dans une ou plusieurs expressions decorator ; les dé corateurs sont
é valué s lorsque la fonction est dé finie, dans la porté e qui contient la dé finition de fonction ; le ré sultat doit ê tre un
appelable, qui est invoqué avec l’objet fonction comme seul argument ; la valeur renvoyé e est lié e au nom de la fonction
en lieu et place de l’objet fonction. Lorsqu’il y a plusieurs dé corateurs, ils sont appliqué s par imbrication ; par exemple,
le code suivant :
4. A string literal appearing as the first statement in the function body is transformed into the function’s __doc__ attribute and therefore the
function’s docstring.

8.7. Définition de fonctions 125

The Python Language Reference, Version 3.13.7

@f1(arg)
@f2
def func(): pass

est à peu prè s é quivalent à :

def func(): pass

func = f1(arg)(f2(func))

sauf que la fonction originale n’est pas temporairement lié e au nom func.
Modifié dans la version 3.9 : les fonctions peuvent ê tre dé coré es par toute expression d'affectation valide.
Auparavant, la grammaire é tait beaucoup plus restrictive ; voir la PEP 614 pour obtenir les dé tails.
A list of type parameters may be given in square brackets between the function’s name and the opening parenthesis for
its parameter list. This indicates to static type checkers that the function is generic. At runtime, the type parameters
can be retrieved from the function’s __type_params__ attribute. See Generic functions for more.
Modifié dans la version 3.12 : Type parameter lists are new in Python 3.12.
Lorsqu’un ou plusieurs paramètres sont de la forme parameter = expression, on dit que la fonction a des « valeurs
de paramè tres par dé faut ». Pour un paramè tre avec une valeur par dé faut, l’argument correspondant peut ê tre omis
lors de l’appel, la valeur par dé faut du paramè tre est alors utilisé e. Si un paramè tre a une valeur par dé faut, tous les
paramè tres suivants jusqu’à ”*” doivent aussi avoir une valeur par dé faut — ceci est une restriction syntaxique qui
n’est pas exprimé e dans la grammaire.
Les valeurs par défaut des paramètres sont évaluées de la gauche vers la droite quand la définition de la
fonction est exécutée. Cela signifie que l’expression est é valué e une fois, lorsque la fonction est dé finie, et que c’est la
mê me valeur « pré -calculé e » qui est utilisé e à chaque appel. C’est particuliè rement important à comprendre lorsque
la valeur d’un paramè tre par dé faut est un objet mutable (cas d’une liste ou un dictionnaire par exemple) : si la fonction
modifie l’objet (par exemple en ajoutant un é lé ment à une liste), la valeur par dé faut est modifié e. En gé né ral, ce n’est
pas l’effet voulu. Une façon d’é viter cet é cueil est d’utiliser None par dé faut et de tester explicitement la valeur dans
le corps de la fonction. Par exemple :

def whats_on_the_telly(penguin=None):
if penguin is None:
penguin = []
[Link]("property of the zoo")
return penguin

La sé mantique de l’appel de fonction est dé crite plus en dé tail dans la section Appels. Un appel de fonction assigne
toujours des valeurs à tous les paramè tres mentionné s dans la liste des paramè tres, soit à partir d’arguments posi-
tionnels, d’arguments par mots-clé s ou de valeurs par dé faut. S’il y a un paramè tre de la forme *identifier, il est
initialisé à un n-uplet recevant les paramè tres positionnels en surplus, la valeur par dé faut é tant le n-uplet vide. S’il y a
un paramè tre de la forme **identifier, il est initialisé à un nouveau tableau associatif ordonné qui ré cupè re tous
les arguments par mot-clé en surplus, la valeur par dé faut é tant un tableau associatif vide du mê me type. Les para-
mè tres aprè s * ou *identifier sont forcé ment des paramè tres par mot-clé et ne peuvent ê tre passé s qu’en utilisant
des arguments par mot-clé . Au contraire, ceux avant / ne peuvent ê tre passé s qu’avec des arguments positionnels.
Modifié dans la version 3.8 : ajout de la syntaxe avec / pour indiquer les paramè tre exclusivement positionnels (voir
la PEP 570).
Parameters may have an annotation of the form ”: expression” following the parameter name. Any parameter
may have an annotation, even those of the form *identifier or **identifier. (As a special case, parameters
of the form *identifier may have an annotation ”: *expression”.) Functions may have ”return” annotation
of the form ”-> expression” after the parameter list. These annotations can be any valid Python expression. The
presence of annotations does not change the semantics of a function. The annotation values are available as values
of a dictionary keyed by the parameters’ names in the __annotations__ attribute of the function object. If the
annotations import from __future__ is used, annotations are preserved as strings at runtime which enables
postponed evaluation. Otherwise, they are evaluated when the function definition is executed. In this case annotations
may be evaluated in a different order than they appear in the source code.

126 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

Modifié dans la version 3.11 : Parameters of the form ”*identifier” may have an annotation ”: *expression”.
See PEP 646.
Il est aussi possible de cré er des fonctions anonymes (fonctions non lié es à un nom), pour une utilisation immé diate
dans des expressions. Utilisez alors des expressions lambda, dé crites dans la section Expressions lambda. Notez qu’une
expression lambda est simplement un raccourci pour dé finir une fonction simple ; une fonction dé finie par une ins-
truction ”def ” peut ê tre passé e (en argument) ou assigné e à un autre nom, tout comme une fonction dé finie par une
expression lambda. La forme ”def” est en fait plus puissante puisqu’elle permet l’exé cution de plusieurs instructions
et les annotations.
Note pour les programmeurs : les fonctions sont des objets de premiè re classe. Une instruction ”def” exé cuté e à
l’inté rieur d’une dé finition de fonction dé finit une fonction locale qui peut ê tre renvoyé e ou passé e en tant qu’argument.
Les variables libres utilisé es dans la fonction imbriqué e ont accè s aux variables locales de la fonction contenant le
”def”. Voir la section Noms et liaisons pour plus de dé tails.

µ Voir aussi

PEP 3107 — Annotations de fonctions

La spé cification originale pour les annotations de fonctions.
PEP 484 — Indications de types
Dé finition de la signification standard pour les annotations : indications de types.
PEP 526 — Syntaxe pour les annotations de variables
Ability to type hint variable declarations, including class variables and instance variables.
PEP 563 — Évaluation différée des annotations
Gestion des ré fé rences posté rieures à l’inté rieur des annotations en pré servant les annotations sous forme
de chaînes à l’exé cution au lieu d’une é valuation directe.
PEP 318 - Decorators for Functions and Methods
Function and method decorators were introduced. Class decorators were introduced in PEP 3129.

8.8 Définition de classes

Une dé finition de classe dé finit un objet classe (voir la section Hiérarchie des types standards) :

classdef ::= [decorators] "class" classname [type_params] [inheritance] ":" suite

inheritance ::= "(" [argument_list] ")"
classname ::= identifier

Une dé finition de classe est une instruction qui est exé cuté e. La liste d’hé ritage (inheritance entre crochets dans la
grammaire ci-dessus) donne habituellement une liste de classes mè res (voir Métaclasses pour des utilisations plus
avancé es). Donc chaque é lé ment de la liste doit pouvoir ê tre é valué comme un objet classe qui autorise les sous-
classes. Les classes sans liste d’hé ritage hé ritent, par dé faut, de la classe mè re object ; d’où :

class Foo:
pass

est é quivalente à :

class Foo(object):
pass

La suite de la classe est ensuite exé cuté e dans un nouveau cadre d’exé cution (voir Noms et liaisons), en utilisant un
espace de nommage local nouvellement cré é et l’espace de nommage global d’origine (habituellement, la suite contient
principalement des dé finitions de fonctions). Lorsque la suite de la classe termine son exé cution, son cadre d’exé cution
est abandonné mais son espace des noms locaux est sauvegardé 5 . Un objet classe est alors cré é en utilisant la liste
5. A string literal appearing as the first statement in the class body is transformed into the namespace’s __doc__ item and therefore the class’s
docstring.

8.8. Définition de classes 127

The Python Language Reference, Version 3.13.7

d’hé ritage pour les classes mè res et l’espace de nommage sauvegardé comme dictionnaire des attributs. Le nom de
classe est lié à l’objet classe dans l’espace de nommage local original.
The order in which attributes are defined in the class body is preserved in the new class’s __dict__. Note that this
is reliable only right after the class is created and only for classes that were defined using the definition syntax.
La cré ation de classes peut ê tre fortement personnalisé e en utilisant les métaclasses.
Les classes peuvent aussi ê tre dé coré es. Comme pour les dé corateurs de fonctions :

@f1(arg)
@f2
class Foo: pass

est à peu prè s é quivalent à :

class Foo: pass

Foo = f1(arg)(f2(Foo))

Les rè gles d’é valuation pour les expressions de dé corateurs sont les mê mes que pour les dé corateurs de fonctions. Le
ré sultat est alors lié au nom de la classe.
Modifié dans la version 3.9 : les classes peuvent ê tre dé coré es par toute expression d'affectation valide.
Auparavant, la grammaire é tait beaucoup plus restrictive ; voir la PEP 614 pour obtenir les dé tails.
A list of type parameters may be given in square brackets immediately after the class’s name. This indicates to
static type checkers that the class is generic. At runtime, the type parameters can be retrieved from the class’s
__type_params__ attribute. See Generic classes for more.
Modifié dans la version 3.12 : Type parameter lists are new in Python 3.12.
Note pour les programmeurs : les variables dé finies dans la dé finition de classe sont des attributs de classe ; elles sont
partagé es par les instances. Les attributs d’instance peuvent ê tre dé finis dans une mé thode en utilisant [Link] =
value. Les attributs de classe et d’instance sont accessibles par la notation ”[Link]”, et un attribut d’instance
masque un attribut de classe de mê me nom lorsqu’on y accè de de cette façon. Les attributs de classe peuvent ê tre
utilisé s comme valeurs par dé faut pour les attributs d’instances, mais l’utilisation de valeurs mutables peut conduire
à des ré sultats inattendus. Les descripteurs peuvent ê tre utilisé s pour cré er des variables d’instances avec des dé tails
d’implé mentation diffé rents.

µ Voir aussi

PEP 3115 — Métaclasses dans Python 3000

La proposition qui a modifié la dé claration de mé taclasses à la syntaxe actuelle, et la sé mantique pour la
façon dont les classes avec mé taclasses sont construites.
PEP 3129 — Décorateurs de classes
La proposition qui a ajouté des dé corateurs de classe. Les dé corateurs de fonction et de mé thode ont é té
introduits dans PEP 318.

8.9 Coroutines
Ajouté dans la version 3.5.

8.9.1 Définition de fonctions coroutines

async_funcdef ::= [decorators] "async" "def" funcname "(" [parameter_list] ")"

["->" expression] ":" suite

L’exé cution de coroutines Python peut ê tre suspendue et reprise à plusieurs endroits (voir coroutine). Les expressions
await, async for et async with ne peuvent ê tre utilisé es que dans les corps de coroutines.

128 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

Les fonctions dé finies avec la syntaxe async def sont toujours des fonctions coroutines, mê me si elles ne contiennent
aucun mot-clé await ou async.
C’est une SyntaxError d’utiliser une expression yield from dans une coroutine.
Un exemple de fonction coroutine :

async def func(param1, param2):

do_stuff()
await some_coroutine()

Modifié dans la version 3.7 : await et async sont doré navant des mots-clé s ; auparavant, ils n’é taient traité s comme
tels que dans le corps d’une fonction coroutine.

8.9.2 L’instruction async for

async_for_stmt ::= "async" for_stmt

Un itérable asynchrone fournit une mé thode __aiter__ qui renvoie directement un itérateur asynchrone, celui-ci
pouvant appeler du code asynchrone dans sa mé thode __anext__.
L’instruction async for permet d’ité rer facilement sur des ité rables asynchrones.
Le code suivant :

async for TARGET in ITER:

SUITE
else:
SUITE2

est sé mantiquement é quivalent à :

iter = (ITER)
iter = type(iter).__aiter__(iter)
running = True

while running:
try:
TARGET = await type(iter).__anext__(iter)
except StopAsyncIteration:
running = False
else:
SUITE
else:
SUITE2

Voir aussi __aiter__() et __anext__() pour plus de dé tails.

C’est une SyntaxError d’utiliser une instruction async for en dehors d’une fonction coroutine.

8.9.3 L’instruction async with

async_with_stmt ::= "async" with_stmt

Un gestionnaire de contexte asynchrone est un gestionnaire de contexte qui est capable de suspendre l’exé cution dans
ses mé thodes enter et exit.
Le code suivant :

async with EXPRESSION as TARGET:

SUITE

8.9. Coroutines 129

The Python Language Reference, Version 3.13.7

est sé mantiquement é quivalent à :

manager = (EXPRESSION)
aenter = type(manager).__aenter__
aexit = type(manager).__aexit__
value = await aenter(manager)
hit_except = False

try:
TARGET = value
SUITE
except:
hit_except = True
if not await aexit(manager, *sys.exc_info()):
raise
finally:
if not hit_except:
await aexit(manager, None, None, None)

Voir aussi __aenter__() et __aexit__() pour plus de dé tails.

C’est une SyntaxError d’utiliser l’instruction async with en dehors d’une fonction coroutine.

µ Voir aussi

PEP 492 — Coroutines avec les syntaxes async et await

La proposition qui a fait que les coroutines soient un concept propre en Python, et a ajouté la syntaxe de
prise en charge de celles-ci.

8.10 Type parameter lists

Ajouté dans la version 3.12.
Modifié dans la version 3.13 : Support for default values was added (see PEP 696).

type_params ::= "[" type_param ("," type_param)* "]"

type_param ::= typevar | typevartuple | paramspec
typevar ::= identifier (":" expression)? ("=" expression)?
typevartuple ::= "*" identifier ("=" expression)?
paramspec ::= "**" identifier ("=" expression)?
Functions (including coroutines), classes and type aliases may contain a type parameter list :

def max[T](args: list[T]) -> T:

...

async def amax[T](args: list[T]) -> T:

...

class Bag[T]:
def __iter__(self) -> Iterator[T]:
...

def add(self, arg: T) -> None:

...

type ListOrSet[T] = list[T] | set[T]

130 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

Semantically, this indicates that the function, class, or type alias is generic over a type variable. This information is
primarily used by static type checkers, and at runtime, generic objects behave much like their non-generic counter-
parts.
Type parameters are declared in square brackets ([]) immediately after the name of the function, class, or type alias.
The type parameters are accessible within the scope of the generic object, but not elsewhere. Thus, after a declaration
def func[T](): pass, the name T is not available in the module scope. Below, the semantics of generic objects
are described with more precision. The scope of type parameters is modeled with a special function (technically, an
annotation scope) that wraps the creation of the generic object.
Generic functions, classes, and type aliases have a __type_params__ attribute listing their type parameters.
Type parameters come in three kinds :
— [Link], introduced by a plain name (e.g., T). Semantically, this represents a single type to a type
checker.
— [Link], introduced by a name prefixed with a single asterisk (e.g., *Ts). Semantically, this
stands for a tuple of any number of types.
— [Link], introduced by a name prefixed with two asterisks (e.g., **P). Semantically, this stands
for the parameters of a callable.
[Link] declarations can define bounds and constraints with a colon (:) followed by an expression. A single
expression after the colon indicates a bound (e.g. T: int). Semantically, this means that the [Link] can
only represent types that are a subtype of this bound. A parenthesized tuple of expressions after the colon indicates a
set of constraints (e.g. T: (str, bytes)). Each member of the tuple should be a type (again, this is not enforced
at runtime). Constrained type variables can only take on one of the types in the list of constraints.
For [Link] declared using the type parameter list syntax, the bound and constraints are not evaluated
when the generic object is created, but only when the value is explicitly accessed through the attributes __bound__
and __constraints__. To accomplish this, the bounds or constraints are evaluated in a separate annotation scope.
[Link] and [Link] cannot have bounds or constraints.
All three flavors of type parameters can also have a default value, which is used when the type parameter is not
explicitly provided. This is added by appending a single equals sign (=) followed by an expression. Like the bounds
and constraints of type variables, the default value is not evaluated when the object is created, but only when the type
parameter’s __default__ attribute is accessed. To this end, the default value is evaluated in a separate annotation
scope. If no default value is specified for a type parameter, the __default__ attribute is set to the special sentinel
object [Link].
The following example indicates the full set of allowed type parameter declarations :

def overly_generic[
SimpleTypeVar,
TypeVarWithDefault = int,
TypeVarWithBound: int,
TypeVarWithConstraints: (str, bytes),
*SimpleTypeVarTuple = (int, float),
**SimpleParamSpec = (str, bytearray),
](
a: SimpleTypeVar,
b: TypeVarWithDefault,
c: TypeVarWithBound,
d: Callable[SimpleParamSpec, TypeVarWithConstraints],
*e: SimpleTypeVarTuple,
): ...

8.10.1 Generic functions

Generic functions are declared as follows :

def func[T](arg: T): ...

This syntax is equivalent to :

8.10. Type parameter lists 131

The Python Language Reference, Version 3.13.7

annotation-def TYPE_PARAMS_OF_func():
T = [Link]("T")
def func(arg: T): ...
func.__type_params__ = (T,)
return func
func = TYPE_PARAMS_OF_func()

Here annotation-def indicates an annotation scope, which is not actually bound to any name at runtime. (One
other liberty is taken in the translation : the syntax does not go through attribute access on the typing module, but
creates an instance of [Link] directly.)
The annotations of generic functions are evaluated within the annotation scope used for declaring the type parameters,
but the function’s defaults and decorators are not.
The following example illustrates the scoping rules for these cases, as well as for additional flavors of type parameters :

@decorator
def func[T: int, *Ts, **P](*args: *Ts, arg: Callable[P, T] = some_default):
...

Except for the lazy evaluation of the TypeVar bound, this is equivalent to :

DEFAULT_OF_arg = some_default

annotation-def TYPE_PARAMS_OF_func():

annotation-def BOUND_OF_T():
return int
# In reality, BOUND_OF_T() is evaluated only on demand.
T = [Link]("T", bound=BOUND_OF_T())

Ts = [Link]("Ts")
P = [Link]("P")

def func(*args: *Ts, arg: Callable[P, T] = DEFAULT_OF_arg):

...

func.__type_params__ = (T, Ts, P)

return func
func = decorator(TYPE_PARAMS_OF_func())

The capitalized names like DEFAULT_OF_arg are not actually bound at runtime.

8.10.2 Generic classes

Generic classes are declared as follows :

class Bag[T]: ...

This syntax is equivalent to :

annotation-def TYPE_PARAMS_OF_Bag():
T = [Link]("T")
class Bag([Link][T]):
__type_params__ = (T,)
...
return Bag
Bag = TYPE_PARAMS_OF_Bag()

132 Chapitre 8. Instructions composées

 The Python Language Reference, Version 3.13.7

Here again annotation-def (not a real keyword) indicates an annotation scope, and the name
TYPE_PARAMS_OF_Bag is not actually bound at runtime.

Generic classes implicitly inherit from [Link]. The base classes and keyword arguments of generic
classes are evaluated within the type scope for the type parameters, and decorators are evaluated outside that scope.
This is illustrated by this example :

@decorator
class Bag(Base[T], arg=T): ...

This is equivalent to :

annotation-def TYPE_PARAMS_OF_Bag():
T = [Link]("T")
class Bag(Base[T], [Link][T], arg=T):
__type_params__ = (T,)
...
return Bag
Bag = decorator(TYPE_PARAMS_OF_Bag())

8.10.3 Generic type aliases

The type statement can also be used to create a generic type alias :

type ListOrSet[T] = list[T] | set[T]

Except for the lazy evaluation of the value, this is equivalent to :

annotation-def TYPE_PARAMS_OF_ListOrSet():
T = [Link]("T")

annotation-def VALUE_OF_ListOrSet():
return list[T] | set[T]
# In reality, the value is lazily evaluated
return [Link]("ListOrSet", VALUE_OF_ListOrSet(), type_params=(T,
,→))

ListOrSet = TYPE_PARAMS_OF_ListOrSet()

Here, annotation-def (not a real keyword) indicates an annotation scope. The capitalized names like
TYPE_PARAMS_OF_ListOrSet are not actually bound at runtime.

Notes

8.10. Type parameter lists 133

The Python Language Reference, Version 3.13.7

134 Chapitre 8. Instructions composées

 CHAPITRE 9

Composants de plus haut niveau

L’entré e de l’interpré teur Python peut provenir d’un certain nombre de sources : d’un script passé en entré e standard
ou en argument de programme, tapé e de maniè re interactive, à partir d’un fichier source de module, etc. Ce chapitre
donne la syntaxe utilisé e dans ces diffé rents cas.

9.1 Programmes Python complets

Bien que les spé cifications d’un langage n’ont pas à pré ciser comment l’interpré teur du langage est invoqué , il est
utile d’avoir des notions sur ce qu’est un programme Python complet. Un programme Python complet est exé cuté
dans un environnement dont l’initialisation est minimale : tous les modules inté gré s et standard sont disponibles mais
aucun n’a é té initialisé , à l’exception de sys (divers services systè me), builtins (fonctions natives, exceptions et
None) et __main__. Ce dernier est utilisé pour avoir des espaces de nommage locaux et globaux pour l’exé cution du
programme complet.
La syntaxe d’un programme Python complet est celle d’un fichier d’entré e, dont la description est donné e dans la
section suivante.
L’interpré teur peut é galement ê tre invoqué en mode interactif ; dans ce cas, il ne lit et n’exé cute pas un programme
complet mais lit et exé cute une seule instruction (é ventuellement composé e) à la fois. L’environnement initial est
identique à celui d’un programme complet ; chaque instruction est exé cuté e dans l’espace de nommage de __main__.
Un programme complet peut ê tre transmis à l’interpré teur sous trois formes : avec l’option -c chaîne en ligne de
commande, avec un fichier passé comme premier argument de ligne de commande ou comme entré e standard. Si le
fichier ou l’entré e standard est un pé riphé rique tty, l’interpré teur entre en mode interactif ; sinon, il exé cute le fichier
comme un programme complet.

9.2 Fichier d’entrée

Toutes les entré es lues à partir de fichiers non interactifs sont de la mê me forme :

file_input ::= (NEWLINE | statement)*

Cette syntaxe est utilisé e dans les situations suivantes :

— lors de l’analyse d’un programme Python complet (à partir d’un fichier ou d’une chaîne de caractè res) ;
— lors de l’analyse d’un module ;
— lors de l’analyse d’une chaîne de caractè res passé e à la fonction exec().

135
The Python Language Reference, Version 3.13.7

9.3 Entrée interactive

L’entré e en mode interactif est analysé e à l’aide de la grammaire suivante :

interactive_input ::= [stmt_list] NEWLINE | compound_stmt NEWLINE

Notez qu’une instruction composé e (de niveau supé rieur) doit ê tre suivie d’une ligne blanche en mode interactif ; c’est
né cessaire pour aider l’analyseur à dé tecter la fin de l’entré e.

9.4 Entrée d’expression

eval() est utilisé e pour é valuer les expressions entré es. Elle ignore les espaces en tê te. L’argument de eval(), de
type chaîne de caractè res, doit ê tre de la forme suivante :

eval_input ::= expression_list NEWLINE*

136 Chapitre 9. Composants de plus haut niveau

 CHAPITRE 10

Spécification complète de la grammaire

Ceci est la grammaire complè te de Python, issue directement de la grammaire utilisé e pour gé né rer l’analyseur
syntaxique CPython (voir Grammar/[Link]). La version ci-dessous ne comprend pas les dé tails relatifs à la
gé né ration de code et la reprise sur erreur.
The notation is a mixture of EBNF and PEG. In particular, & followed by a symbol, token or parenthesized group
indicates a positive lookahead (i.e., is required to match but not consumed), while ! indicates a negative lookahead
(i.e., is required not to match). We use the | separator to mean PEG’s ”ordered choice” (written as / in traditional
PEG grammars). See PEP 617 for more details on the grammar’s syntax.

# PEG grammar for Python

# ========================= START OF THE GRAMMAR =========================

# General grammatical elements and rules:

#
# * Strings with double quotes (") denote SOFT KEYWORDS
# * Strings with single quotes (') denote KEYWORDS
# * Upper case names (NAME) denote tokens in the Grammar/Tokens file
# * Rule names starting with "invalid_" are used for specialized syntax errors
# - These rules are NOT used in the first pass of the parser.
# - Only if the first pass fails to parse, a second pass including the invalid
# rules will be executed.
# - If the parser fails in the second phase with a generic syntax error, the
# location of the generic failure of the first pass will be used (this avoids
# reporting incorrect locations due to the invalid rules).
# - The order of the alternatives involving invalid rules matter
# (like any rule in PEG).
#
# Grammar Syntax (see PEP 617 for more information):
#
# rule_name: expression
# Optionally, a type can be included right after the rule name, which
# specifies the return type of the C or Python function corresponding to the
# rule:
(suite sur la page suivante)

137
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

# rule_name[return_type]: expression
# If the return type is omitted, then a void * is returned in C and an Any in
# Python.
# e1 e2
# Match e1, then match e2.
# e1 | e2
# Match e1 or e2.
# The first alternative can also appear on the line after the rule name for
# formatting purposes. In that case, a | must be used before the first
# alternative, like so:
# rule_name[return_type]:
# | first_alt
# | second_alt
# ( e )
# Match e (allows also to use other operators in the group like '(e)*')
# [ e ] or e?
# Optionally match e.
# e*
# Match zero or more occurrences of e.
# e+
# Match one or more occurrences of e.
# s.e+
# Match one or more occurrences of e, separated by s. The generated parse tree
# does not include the separator. This is otherwise identical to (e (s e)*).
# &e
# Succeed if e can be parsed, without consuming any input.
# !e
# Fail if e can be parsed, without consuming any input.
# ~
# Commit to the current alternative, even if it fails to parse.
# &&e
# Eager parse e. The parser will not backtrack and will immediately
# fail with SyntaxError if e cannot be parsed.
#

# STARTING RULES
# ==============

file: [statements] ENDMARKER

interactive: statement_newline
eval: expressions NEWLINE* ENDMARKER
func_type: '(' [type_expressions] ')' '->' expression NEWLINE* ENDMARKER

# GENERAL STATEMENTS
# ==================

statements: statement+

statement: compound_stmt | simple_stmts

statement_newline:
| compound_stmt NEWLINE
| simple_stmts
| NEWLINE
| ENDMARKER

(suite sur la page suivante)

138 Chapitre 10. Spécification complète de la grammaire

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

simple_stmts:
| simple_stmt !';' NEWLINE # Not needed, there for speedup
| ';'.simple_stmt+ [';'] NEWLINE

# NOTE: assignment MUST precede expression, else parsing a simple assignment

# will throw a SyntaxError.
simple_stmt:
| assignment
| type_alias
| star_expressions
| return_stmt
| import_stmt
| raise_stmt
| 'pass'
| del_stmt
| yield_stmt
| assert_stmt
| 'break'
| 'continue'
| global_stmt
| nonlocal_stmt

compound_stmt:
| function_def
| if_stmt
| class_def
| with_stmt
| for_stmt
| try_stmt
| while_stmt
| match_stmt

# SIMPLE STATEMENTS
# =================

# NOTE: annotated_rhs may start with 'yield'; yield_expr must start with 'yield'
assignment:
| NAME ':' expression ['=' annotated_rhs ]
| ('(' single_target ')'
| single_subscript_attribute_target) ':' expression ['=' annotated_rhs ]
| (star_targets '=' )+ (yield_expr | star_expressions) !'=' [TYPE_COMMENT]
| single_target augassign ~ (yield_expr | star_expressions)

annotated_rhs: yield_expr | star_expressions

augassign:
| '+='
| '-='
| '*='
| '@='
| '/='
| '%='
| '&='
| '|='
| '^='
| '<<='
(suite sur la page suivante)

139
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

| '>>='
| '**='
| '//='

return_stmt:
| 'return' [star_expressions]

raise_stmt:
| 'raise' expression ['from' expression ]
| 'raise'

global_stmt: 'global' ','.NAME+

nonlocal_stmt: 'nonlocal' ','.NAME+

del_stmt:
| 'del' del_targets &(';' | NEWLINE)

yield_stmt: yield_expr

assert_stmt: 'assert' expression [',' expression ]

import_stmt:
| import_name
| import_from

# Import statements
# -----------------

import_name: 'import' dotted_as_names

# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS
import_from:
| 'from' ('.' | '...')* dotted_name 'import' import_from_targets
| 'from' ('.' | '...')+ 'import' import_from_targets
import_from_targets:
| '(' import_from_as_names [','] ')'
| import_from_as_names !','
| '*'
import_from_as_names:
| ','.import_from_as_name+
import_from_as_name:
| NAME ['as' NAME ]
dotted_as_names:
| ','.dotted_as_name+
dotted_as_name:
| dotted_name ['as' NAME ]
dotted_name:
| dotted_name '.' NAME
| NAME

# COMPOUND STATEMENTS
# ===================

# Common elements
# ---------------

(suite sur la page suivante)

140 Chapitre 10. Spécification complète de la grammaire

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

block:
| NEWLINE INDENT statements DEDENT
| simple_stmts

decorators: ('@' named_expression NEWLINE )+

# Class definitions
# -----------------

class_def:
| decorators class_def_raw
| class_def_raw

class_def_raw:
| 'class' NAME [type_params] ['(' [arguments] ')' ] ':' block

# Function definitions
# --------------------

function_def:
| decorators function_def_raw
| function_def_raw

function_def_raw:
| 'def' NAME [type_params] '(' [params] ')' ['->' expression ] ':' [func_type_
,→comment] block

| 'async' 'def' NAME [type_params] '(' [params] ')' ['->' expression ] ':'␣
,→[func_type_comment] block

# Function parameters
# -------------------

params:
| parameters

parameters:
| slash_no_default param_no_default* param_with_default* [star_etc]
| slash_with_default param_with_default* [star_etc]
| param_no_default+ param_with_default* [star_etc]
| param_with_default+ [star_etc]
| star_etc

# Some duplication here because we can't write (',' | &')'),

# which is because we don't support empty alternatives (yet).

slash_no_default:
| param_no_default+ '/' ','
| param_no_default+ '/' &')'
slash_with_default:
| param_no_default* param_with_default+ '/' ','
| param_no_default* param_with_default+ '/' &')'

star_etc:
| '*' param_no_default param_maybe_default* [kwds]
| '*' param_no_default_star_annotation param_maybe_default* [kwds]
| '*' ',' param_maybe_default+ [kwds]
(suite sur la page suivante)

141
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

| kwds

kwds:
| '**' param_no_default

# One parameter. This *includes* a following comma and type comment.

#
# There are three styles:
# - No default
# - With default
# - Maybe with default
#
# There are two alternative forms of each, to deal with type comments:
# - Ends in a comma followed by an optional type comment
# - No comma, optional type comment, must be followed by close paren
# The latter form is for a final parameter without trailing comma.
#

param_no_default:
| param ',' TYPE_COMMENT?
| param TYPE_COMMENT? &')'
param_no_default_star_annotation:
| param_star_annotation ',' TYPE_COMMENT?
| param_star_annotation TYPE_COMMENT? &')'
param_with_default:
| param default ',' TYPE_COMMENT?
| param default TYPE_COMMENT? &')'
param_maybe_default:
| param default? ',' TYPE_COMMENT?
| param default? TYPE_COMMENT? &')'
param: NAME annotation?
param_star_annotation: NAME star_annotation
annotation: ':' expression
star_annotation: ':' star_expression
default: '=' expression | invalid_default

# If statement
# ------------

if_stmt:
| 'if' named_expression ':' block elif_stmt
| 'if' named_expression ':' block [else_block]
elif_stmt:
| 'elif' named_expression ':' block elif_stmt
| 'elif' named_expression ':' block [else_block]
else_block:
| 'else' ':' block

# While statement
# ---------------

while_stmt:
| 'while' named_expression ':' block [else_block]

# For statement
# -------------
(suite sur la page suivante)

142 Chapitre 10. Spécification complète de la grammaire

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

for_stmt:
| 'for' star_targets 'in' ~ star_expressions ':' [TYPE_COMMENT] block [else_
,→block]

| 'async' 'for' star_targets 'in' ~ star_expressions ':' [TYPE_COMMENT] block␣

,→[else_block]

# With statement
# --------------

with_stmt:
| 'with' '(' ','.with_item+ ','? ')' ':' [TYPE_COMMENT] block
| 'with' ','.with_item+ ':' [TYPE_COMMENT] block
| 'async' 'with' '(' ','.with_item+ ','? ')' ':' block
| 'async' 'with' ','.with_item+ ':' [TYPE_COMMENT] block

with_item:
| expression 'as' star_target &(',' | ')' | ':')
| expression

# Try statement
# -------------

try_stmt:
| 'try' ':' block finally_block
| 'try' ':' block except_block+ [else_block] [finally_block]
| 'try' ':' block except_star_block+ [else_block] [finally_block]

# Except statement
# ----------------

except_block:
| 'except' expression ['as' NAME ] ':' block
| 'except' ':' block
except_star_block:
| 'except' '*' expression ['as' NAME ] ':' block
finally_block:
| 'finally' ':' block

# Match statement
# ---------------

match_stmt:
| "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT

subject_expr:
| star_named_expression ',' star_named_expressions?
| named_expression

case_block:
| "case" patterns guard? ':' block

guard: 'if' named_expression

patterns:
(suite sur la page suivante)

143
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

| open_sequence_pattern
| pattern

pattern:
| as_pattern
| or_pattern

as_pattern:
| or_pattern 'as' pattern_capture_target

or_pattern:
| '|'.closed_pattern+

closed_pattern:
| literal_pattern
| capture_pattern
| wildcard_pattern
| value_pattern
| group_pattern
| sequence_pattern
| mapping_pattern
| class_pattern

# Literal patterns are used for equality and identity constraints

literal_pattern:
| signed_number !('+' | '-')
| complex_number
| strings
| 'None'
| 'True'
| 'False'

# Literal expressions are used to restrict permitted mapping pattern keys

literal_expr:
| signed_number !('+' | '-')
| complex_number
| strings
| 'None'
| 'True'
| 'False'

complex_number:
| signed_real_number '+' imaginary_number
| signed_real_number '-' imaginary_number

signed_number:
| NUMBER
| '-' NUMBER

signed_real_number:
| real_number
| '-' real_number

real_number:
| NUMBER

(suite sur la page suivante)

144 Chapitre 10. Spécification complète de la grammaire

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

imaginary_number:
| NUMBER

capture_pattern:
| pattern_capture_target

pattern_capture_target:
| !"_" NAME !('.' | '(' | '=')

wildcard_pattern:
| "_"

value_pattern:
| attr !('.' | '(' | '=')

attr:
| name_or_attr '.' NAME

name_or_attr:
| attr
| NAME

group_pattern:
| '(' pattern ')'

sequence_pattern:
| '[' maybe_sequence_pattern? ']'
| '(' open_sequence_pattern? ')'

open_sequence_pattern:
| maybe_star_pattern ',' maybe_sequence_pattern?

maybe_sequence_pattern:
| ','.maybe_star_pattern+ ','?

maybe_star_pattern:
| star_pattern
| pattern

star_pattern:
| '*' pattern_capture_target
| '*' wildcard_pattern

mapping_pattern:
| '{' '}'
| '{' double_star_pattern ','? '}'
| '{' items_pattern ',' double_star_pattern ','? '}'
| '{' items_pattern ','? '}'

items_pattern:
| ','.key_value_pattern+

key_value_pattern:
| (literal_expr | attr) ':' pattern

double_star_pattern:
(suite sur la page suivante)

145
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

| '**' pattern_capture_target

class_pattern:
| name_or_attr '(' ')'
| name_or_attr '(' positional_patterns ','? ')'
| name_or_attr '(' keyword_patterns ','? ')'
| name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'

positional_patterns:
| ','.pattern+

keyword_patterns:
| ','.keyword_pattern+

keyword_pattern:
| NAME '=' pattern

# Type statement
# ---------------

type_alias:
| "type" NAME [type_params] '=' expression

# Type parameter declaration

# --------------------------

type_params:
| '[' type_param_seq ']'

type_param_seq: ','.type_param+ [',']

type_param:
| NAME [type_param_bound] [type_param_default]
| '*' NAME [type_param_starred_default]
| '**' NAME [type_param_default]

type_param_bound: ':' expression

type_param_default: '=' expression
type_param_starred_default: '=' star_expression

# EXPRESSIONS
# -----------

expressions:
| expression (',' expression )+ [',']
| expression ','
| expression

expression:
| disjunction 'if' disjunction 'else' expression
| disjunction
| lambdef

yield_expr:
| 'yield' 'from' expression
| 'yield' [star_expressions]
(suite sur la page suivante)

146 Chapitre 10. Spécification complète de la grammaire

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

star_expressions:
| star_expression (',' star_expression )+ [',']
| star_expression ','
| star_expression

star_expression:
| '*' bitwise_or
| expression

star_named_expressions: ','.star_named_expression+ [',']

star_named_expression:
| '*' bitwise_or
| named_expression

assignment_expression:
| NAME ':=' ~ expression

named_expression:
| assignment_expression
| expression !':='

disjunction:
| conjunction ('or' conjunction )+
| conjunction

conjunction:
| inversion ('and' inversion )+
| inversion

inversion:
| 'not' inversion
| comparison

# Comparison operators
# --------------------

comparison:
| bitwise_or compare_op_bitwise_or_pair+
| bitwise_or

compare_op_bitwise_or_pair:
| eq_bitwise_or
| noteq_bitwise_or
| lte_bitwise_or
| lt_bitwise_or
| gte_bitwise_or
| gt_bitwise_or
| notin_bitwise_or
| in_bitwise_or
| isnot_bitwise_or
| is_bitwise_or

eq_bitwise_or: '==' bitwise_or

noteq_bitwise_or:
(suite sur la page suivante)

147
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

| ('!=' ) bitwise_or
lte_bitwise_or: '<=' bitwise_or
lt_bitwise_or: '<' bitwise_or
gte_bitwise_or: '>=' bitwise_or
gt_bitwise_or: '>' bitwise_or
notin_bitwise_or: 'not' 'in' bitwise_or
in_bitwise_or: 'in' bitwise_or
isnot_bitwise_or: 'is' 'not' bitwise_or
is_bitwise_or: 'is' bitwise_or

# Bitwise operators
# -----------------

bitwise_or:
| bitwise_or '|' bitwise_xor
| bitwise_xor

bitwise_xor:
| bitwise_xor '^' bitwise_and
| bitwise_and

bitwise_and:
| bitwise_and '&' shift_expr
| shift_expr

shift_expr:
| shift_expr '<<' sum
| shift_expr '>>' sum
| sum

# Arithmetic operators
# --------------------

sum:
| sum '+' term
| sum '-' term
| term

term:
| term '*' factor
| term '/' factor
| term '//' factor
| term '%' factor
| term '@' factor
| factor

factor:
| '+' factor
| '-' factor
| '~' factor
| power

power:
| await_primary '**' factor
| await_primary

(suite sur la page suivante)

148 Chapitre 10. Spécification complète de la grammaire

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

# Primary elements
# ----------------

# Primary elements are things like "[Link]", "obj[something]",

,→"obj(something)", "obj" ...

await_primary:
| 'await' primary
| primary

primary:
| primary '.' NAME
| primary genexp
| primary '(' [arguments] ')'
| primary '[' slices ']'
| atom

slices:
| slice !','
| ','.(slice | starred_expression)+ [',']

slice:
| [expression] ':' [expression] [':' [expression] ]
| named_expression

atom:
| NAME
| 'True'
| 'False'
| 'None'
| strings
| NUMBER
| (tuple | group | genexp)
| (list | listcomp)
| (dict | set | dictcomp | setcomp)
| '...'

group:
| '(' (yield_expr | named_expression) ')'

# Lambda functions
# ----------------

lambdef:
| 'lambda' [lambda_params] ':' expression

lambda_params:
| lambda_parameters

# lambda_parameters etc. duplicates parameters but without annotations

# or type comments, and if there's no comma after a parameter, we expect
# a colon, not a close parenthesis. (For more, see parameters above.)
#
lambda_parameters:
| lambda_slash_no_default lambda_param_no_default* lambda_param_with_default*␣
,→[lambda_star_etc]

(suite sur la page suivante)

149
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

| lambda_slash_with_default lambda_param_with_default* [lambda_star_etc]
| lambda_param_no_default+ lambda_param_with_default* [lambda_star_etc]
| lambda_param_with_default+ [lambda_star_etc]
| lambda_star_etc

lambda_slash_no_default:
| lambda_param_no_default+ '/' ','
| lambda_param_no_default+ '/' &':'

lambda_slash_with_default:
| lambda_param_no_default* lambda_param_with_default+ '/' ','
| lambda_param_no_default* lambda_param_with_default+ '/' &':'

lambda_star_etc:
| '*' lambda_param_no_default lambda_param_maybe_default* [lambda_kwds]
| '*' ',' lambda_param_maybe_default+ [lambda_kwds]
| lambda_kwds

lambda_kwds:
| '**' lambda_param_no_default

lambda_param_no_default:
| lambda_param ','
| lambda_param &':'
lambda_param_with_default:
| lambda_param default ','
| lambda_param default &':'
lambda_param_maybe_default:
| lambda_param default? ','
| lambda_param default? &':'
lambda_param: NAME

# LITERALS
# ========

fstring_middle:
| fstring_replacement_field
| FSTRING_MIDDLE
fstring_replacement_field:
| '{' annotated_rhs '='? [fstring_conversion] [fstring_full_format_spec] '}'
fstring_conversion:
| "!" NAME
fstring_full_format_spec:
| ':' fstring_format_spec*
fstring_format_spec:
| FSTRING_MIDDLE
| fstring_replacement_field
fstring:
| FSTRING_START fstring_middle* FSTRING_END

string: STRING
strings: (fstring|string)+

list:
| '[' [star_named_expressions] ']'

(suite sur la page suivante)

150 Chapitre 10. Spécification complète de la grammaire

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

tuple:
| '(' [star_named_expression ',' [star_named_expressions] ] ')'

set: '{' star_named_expressions '}'

# Dicts
# -----

dict:
| '{' [double_starred_kvpairs] '}'

double_starred_kvpairs: ','.double_starred_kvpair+ [',']

double_starred_kvpair:
| '**' bitwise_or
| kvpair

kvpair: expression ':' expression

# Comprehensions & Generators

# ---------------------------

for_if_clauses:
| for_if_clause+

for_if_clause:
| 'async' 'for' star_targets 'in' ~ disjunction ('if' disjunction )*
| 'for' star_targets 'in' ~ disjunction ('if' disjunction )*

listcomp:
| '[' named_expression for_if_clauses ']'

setcomp:
| '{' named_expression for_if_clauses '}'

genexp:
| '(' ( assignment_expression | expression !':=') for_if_clauses ')'

dictcomp:
| '{' kvpair for_if_clauses '}'

# FUNCTION CALL ARGUMENTS

# =======================

arguments:
| args [','] &')'

args:
| ','.(starred_expression | ( assignment_expression | expression !':=') !'=')+␣
,→[',' kwargs ]

| kwargs

kwargs:
| ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
| ','.kwarg_or_starred+
| ','.kwarg_or_double_starred+
(suite sur la page suivante)

151
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

starred_expression:
| '*' expression

kwarg_or_starred:
| NAME '=' expression
| starred_expression

kwarg_or_double_starred:
| NAME '=' expression
| '**' expression

# ASSIGNMENT TARGETS
# ==================

# Generic targets
# ---------------

# NOTE: star_targets may contain *bitwise_or, targets may not.

star_targets:
| star_target !','
| star_target (',' star_target )* [',']

star_targets_list_seq: ','.star_target+ [',']

star_targets_tuple_seq:
| star_target (',' star_target )+ [',']
| star_target ','

star_target:
| '*' (!'*' star_target)
| target_with_star_atom

target_with_star_atom:
| t_primary '.' NAME !t_lookahead
| t_primary '[' slices ']' !t_lookahead
| star_atom

star_atom:
| NAME
| '(' target_with_star_atom ')'
| '(' [star_targets_tuple_seq] ')'
| '[' [star_targets_list_seq] ']'

single_target:
| single_subscript_attribute_target
| NAME
| '(' single_target ')'

single_subscript_attribute_target:
| t_primary '.' NAME !t_lookahead
| t_primary '[' slices ']' !t_lookahead

t_primary:
| t_primary '.' NAME &t_lookahead
| t_primary '[' slices ']' &t_lookahead
(suite sur la page suivante)

152 Chapitre 10. Spécification complète de la grammaire

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

| t_primary genexp &t_lookahead
| t_primary '(' [arguments] ')' &t_lookahead
| atom &t_lookahead

t_lookahead: '(' | '[' | '.'

# Targets for del statements

# --------------------------

del_targets: ','.del_target+ [',']

del_target:
| t_primary '.' NAME !t_lookahead
| t_primary '[' slices ']' !t_lookahead
| del_t_atom

del_t_atom:
| NAME
| '(' del_target ')'
| '(' [del_targets] ')'
| '[' [del_targets] ']'

# TYPING ELEMENTS
# ---------------

# type_expressions allow */** but ignore them

type_expressions:
| ','.expression+ ',' '*' expression ',' '**' expression
| ','.expression+ ',' '*' expression
| ','.expression+ ',' '**' expression
| '*' expression ',' '**' expression
| '*' expression
| '**' expression
| ','.expression+

func_type_comment:
| NEWLINE TYPE_COMMENT &(NEWLINE INDENT) # Must be followed by indented block
| TYPE_COMMENT

# ========================= END OF THE GRAMMAR ===========================

# ========================= START OF INVALID RULES =======================

153
The Python Language Reference, Version 3.13.7

154 Chapitre 10. Spécification complète de la grammaire

 ANNEXE A

Glossaire

>>>
The default Python prompt of the interactive shell. Often seen for code examples which can be executed
interactively in the interpreter.
...
Peut faire ré fé rence à :
— The default Python prompt of the interactive shell when entering the code for an indented code block,
when within a pair of matching left and right delimiters (parentheses, square brackets, curly braces or
triple quotes), or after specifying a decorator.
— The three dots form of the Ellipsis object.
classe mère abstraite
Les classes mè res abstraites (ABC, suivant l’abré viation anglaise Abstract Base Class) complè tent le duck-
typing en fournissant un moyen de dé finir des interfaces pour les cas où d’autres techniques comme
hasattr() seraient iné lé gantes ou subtilement fausses (par exemple avec les méthodes magiques). Les ABC
introduisent des sous-classes virtuelles qui n’hé ritent pas d’une classe mais qui sont quand mê me reconnues
par isinstance() ou issubclass() (voir la documentation du module abc). Python contient de nom-
breuses ABC pour les structures de donné es (dans le module [Link]), les nombres (dans le
module numbers), les flux (dans le module io) et les chercheurs-chargeurs du systè me d’importation (dans
le module [Link]). Vous pouvez cré er vos propres ABC avec le module abc.
annotation
Étiquette associé e à une variable, un attribut de classe, un paramè tre de fonction ou une valeur de retour. Elle
est utilisé e par convention comme type hint.
Les annotations de variables locales ne sont pas accessibles au moment de l’exé cution, mais les annotations de
variables globales, d’attributs de classe et de fonctions sont stocké es dans l’attribut spé cial __annotations__
des modules, classes et fonctions, respectivement.
Voir annotation de variable, annotation de fonction, les PEP 484 et PEP 526, qui dé crivent cette fonction-
nalité . Voir aussi annotations-howto sur les bonnes pratiques concernant les annotations.
argument
Valeur, donné e à une fonction ou à une méthode lors de son appel. Il existe deux types d’arguments :
— argument nommé : un argument pré cé dé d’un identifiant (comme name=) ou un dictionnaire pré cé dé de
**, lors d’un appel de fonction. Par exemple, 3 et 5 sont tous les deux des arguments nommé s dans l’appel
à complex() ici :

complex(real=3, imag=5)
complex(**{'real': 3, 'imag': 5})

155
The Python Language Reference, Version 3.13.7

— argument positionnel : un argument qui n’est pas nommé . Les arguments positionnels apparaissent au dé but
de la liste des arguments, ou donné s sous forme d’un itérable pré cé dé par *. Par exemple, 3 et 5 sont tous
les deux des arguments positionnels dans les appels suivants :

complex(3, 5)
complex(*(3, 5))

Les arguments se retrouvent dans le corps de la fonction appelé e parmi les variables locales. Voir la section
Appels à propos des rè gles dictant cette affectation. Syntaxiquement, toute expression est accepté e comme
argument, et c’est la valeur ré sultante de l’expression qui sera affecté e à la variable locale.
Voir aussi paramètre dans le glossaire, la question Diffé rence entre argument et paramè tre de la FAQ et la
PEP 362.
gestionnaire de contexte asynchrone
(asynchronous context manager en anglais) Objet contrô lant l’environnement à l’inté rieur d’une instruction
async with en dé finissant les mé thodes __aenter__() et __aexit__(). A é té Introduit par la PEP
492.
générateur asynchrone
Fonction qui renvoie un itérateur de générateur asynchrone. Cela ressemble à une coroutine dé finie par async
def , sauf qu’elle contient une ou des expressions yield produisant ainsi uns sé rie de valeurs utilisables dans
une boucle async for.
Gé né rateur asynchrone fait gé né ralement ré fé rence à une fonction, mais peut faire ré fé rence à un itérateur de
générateur asynchrone dans certains contextes. Dans les cas où le sens voulu n’est pas clair, utiliser l’ensemble
des termes lè ve l’ambiguïté .
Un gé né rateur asynchrone peut contenir des expressions await ainsi que des instructions async for, et
async with.
itérateur de générateur asynchrone
An object created by an asynchronous generator function.
C’est un asynchronous iterator qui, lorsqu’il est appelé via la mé thode __anext__() renvoie un objet awai-
table qui exé cute le corps de la fonction du gé né rateur asynchrone jusqu’au prochain yield.
Each yield temporarily suspends processing, remembering the execution state (including local variables and
pending try-statements). When the asynchronous generator iterator effectively resumes with another awaitable
returned by __anext__(), it picks up where it left off. See PEP 492 and PEP 525.
itérable asynchrone
Objet qui peut ê tre utilisé dans une instruction async for. Sa mé thode __aiter__() doit renvoyer un
asynchronous iterator. A é té introduit par la PEP 492.
itérateur asynchrone
Objet qui implé mente les mé thodes __aiter__() et __anext__(). __anext__() doit renvoyer un ob-
jet awaitable. Tant que la mé thode __anext__() produit des objets awaitable, le async for appelant
les consomme. L’ité rateur asynchrone lè ve une exception StopAsyncIteration pour signifier la fin de
l’ité ration. A é té introduit par la PEP 492.
attribut
Valeur associé e à un objet et habituellement dé signé e par son nom via une notation utilisant des points. Par
exemple, si un objet o possè de un attribut a, cet attribut est ré fé rencé par o.a.
Il est possible de donner à un objet un attribut dont le nom n’est pas un identifiant tel que dé fini pour les
Identifiants et mots-clés, par exemple en utilisant setattr(), si l’objet le permet. Un tel attribut ne sera pas
accessible à l’aide d’une expression pointé e et on devra y accé der avec getattr().
attendable (awaitable)
Objet pouvant ê tre utilisé dans une expression await. Ce peut ê tre une coroutine ou un objet avec une mé thode
__await__(). Voir aussi la PEP 492.
BDFL
Dictateur bienveillant à vie (Benevolent Dictator For Life en anglais). Pseudonyme de Guido van Rossum, le
cré ateur de Python.
fichier binaire
A file object able to read and write bytes-like objects. Examples of binary files are files opened in binary mode
('rb', 'wb' or 'rb+'), [Link], [Link], and instances of [Link] and

156 Annexe A. Glossaire

 The Python Language Reference, Version 3.13.7

[Link].
Consultez fichier texte, un objet fichier capable de lire et d’é crire des objets str.
référence empruntée
In Python’s C API, a borrowed reference is a reference to an object, where the code using the object does not
own the reference. It becomes a dangling pointer if the object is destroyed. For example, a garbage collection
can remove the last strong reference to the object and so destroy it.
Il est recommandé d’appeler Py_INCREF() sur la référence empruntée, ce qui la transforme in situ en une
référence forte. Vous pouvez faire une exception si vous ê tes certain que l’objet ne peut pas ê tre supprimé
avant la derniè re utilisation de la ré fé rence emprunté e. Voir aussi la fonction Py_NewRef(), qui cré e une
nouvelle référence forte.
objet octet-compatible
Un objet gé rant le protocole tampon et pouvant exporter un tampon (buffer en anglais) C-contigu. Cela inclut
les objets bytes, bytearray et [Link], ainsi que beaucoup d’objets memoryview. Les objets octets-
compatibles peuvent ê tre utilisé s pour diverses opé rations sur des donné es binaires, comme la compression,
la sauvegarde dans un fichier binaire ou l’envoi sur le ré seau.
Certaines opé rations né cessitent de travailler sur des donné es binaires variables. La documentation parle
de ceux-ci comme des read-write bytes-like objects. Par exemple, bytearray ou une memoryview d’un
bytearray en font partie. D’autres opé rations né cessitent de travailler sur des donné es binaires stocké es
dans des objets immuables (« objets octets-compatibles en lecture seule »), par exemple des bytes ou des
memoryview d’un objet bytes.
code intermédiaire (bytecode)
Le code source, en Python, est compilé en un code intermé diaire (bytecode en anglais), la repré sentation
interne à CPython d’un programme Python. Le code intermé diaire est mis en cache dans un fichier .pyc
de maniè re à ce qu’une seconde exé cution soit plus rapide (la compilation en code intermé diaire a dé jà é té
faite). On dit que ce langage intermédiaire est exé cuté sur une virtual machine qui exé cute des instructions
machine pour chaque instruction du code intermé diaire. Notez que le code intermé diaire n’a pas vocation à
fonctionner sur diffé rentes machines virtuelles Python ou à ê tre stable entre diffé rentes versions de Python.
La documentation du module dis fournit une liste des instructions du code intermé diaire.
appelable (callable)
Un appelable est un objet qui peut ê tre appelé , é ventuellement avec un ensemble d’arguments (voir argument),
avec la syntaxe suivante :

callable(argument1, argument2, argumentN)

Une fonction, et par extension une méthode, est un appelable. Une instance d’une classe qui implé mente la
mé thode __call__() est é galement un appelable.
fonction de rappel (callback)
Une fonction (classique, par opposition à une coroutine) passé e en argument pour ê tre exé cuté e plus tard.
classe
Modè le pour cré er des objets dé finis par l’utilisateur. Une dé finition de classe (class) contient normalement
des dé finitions de mé thodes qui agissent sur les instances de la classe.
variable de classe
Une variable dé finie dans une classe et destiné e à ê tre modifié e uniquement au niveau de la classe (c’est-à -dire,
pas dans une instance de la classe).
closure variable
A free variable referenced from a nested scope that is defined in an outer scope rather than being resolved at
runtime from the globals or builtin namespaces. May be explicitly defined with the nonlocal keyword to
allow write access, or implicitly defined if the variable is only being read.
For example, in the inner function in the following code, both x and print are free variables, but only x is
a closure variable :

def outer():
x = 0
def inner():
(suite sur la page suivante)

157
The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

nonlocal x
x += 1
print(x)
return inner

Due to the codeobject.co_freevars attribute (which, despite its name, only includes the names of clo-
sure variables rather than listing all referenced free variables), the more general free variable term is some-
times used even when the intended meaning is to refer specifically to closure variables.
nombre complexe
Extension des nombres ré els familiers, dans laquelle tous les nombres sont exprimé s sous la forme d’une
somme d’une partie ré elle et d’une partie imaginaire. Les nombres imaginaires sont les nombres ré els multi-
plié s par l’unité imaginaire (la racine carré e de -1, souvent é crite i en mathé matiques ou j par les ingé nieurs).
Python comprend nativement les nombres complexes, é crits avec cette derniè re notation : la partie imaginaire
est é crite avec un suffixe j, exemple, 3+1j. Pour utiliser les é quivalents complexes de math, utilisez cmath.
Les nombres complexes sont un concept assez avancé en mathé matiques. Si vous ne connaissez pas ce concept,
vous pouvez tranquillement les ignorer.
context
This term has different meanings depending on where and how it is used. Some common meanings :
— The temporary state or environment established by a context manager via a with statement.
— The collection of keyvalue bindings associated with a particular [Link] object and
accessed via ContextVar objects. Also see context variable.
— A [Link] object. Also see current context.
context management protocol
The __enter__() and __exit__() methods called by the with statement. See PEP 343.
gestionnaire de contexte
An object which implements the context management protocol and controls the environment seen in a with
statement. See PEP 343.
variable de contexte
A variable whose value depends on which context is the current context. Values are accessed via
[Link] objects. Context variables are primarily used to isolate state between concur-
rent asynchronous tasks.
contigu
Un tampon (buffer en anglais) est considé ré comme contigu s’il est soit C-contigu soit Fortran-contigu. Les
tampons de dimension zé ro sont C-contigus et Fortran-contigus. Pour un tableau à une dimension, ses é lé -
ments doivent ê tre placé s en mé moire l’un à cô té de l’autre, dans l’ordre croissant de leur indice, en commen-
çant à zé ro. Pour qu’un tableau multidimensionnel soit C-contigu, le dernier indice doit ê tre celui qui varie le
plus rapidement lors du parcours de ses é lé ments dans l’ordre de leur adresse mé moire. À l’inverse, dans les
tableaux Fortran-contigu, c’est le premier indice qui doit varier le plus rapidement.
coroutine
Les coroutines sont une forme gé né ralisé e des fonctions. On entre dans une fonction en un point et on en sort
en un autre point. On peut entrer, sortir et reprendre l’exé cution d’une coroutine en plusieurs points. Elles
peuvent ê tre implé menté es en utilisant l’instruction async def . Voir aussi la PEP 492.
fonction coroutine
Fonction qui renvoie un objet coroutine. Une fonction coroutine peut ê tre dé finie par l’instruction async def
et peut contenir les mots clé s await, async for ainsi que async with. A é té introduit par la PEP 492.
CPython
L’implé mentation canonique du langage de programmation Python, tel que distribué sur [Link]. Le terme
”CPython” est utilisé dans certains contextes lorsqu’il est né cessaire de distinguer cette implé mentation des
autres comme Jython ou IronPython.
current context
The context ([Link] object) that is currently used by ContextVar objects to access (get
or set) the values of context variables. Each thread has its own current context. Frameworks for executing
asynchronous tasks (see asyncio) associate each task with a context which becomes the current context
whenever the task starts or resumes execution.
décorateur
Fonction dont la valeur de retour est une autre fonction. Un dé corateur est habituellement utilisé pour

158 Annexe A. Glossaire

 The Python Language Reference, Version 3.13.7

transformer une fonction via la syntaxe @wrapper, dont les exemples typiques sont : classmethod() et
staticmethod().

La syntaxe des dé corateurs est simplement du sucre syntaxique, les dé finitions des deux fonctions suivantes
sont sé mantiquement é quivalentes :
def f(arg):
...
f = staticmethod(f)

@staticmethod
def f(arg):
...

Quoique moins fré quemment utilisé , le mê me concept existe pour les classes. Consultez la documentation
définitions de fonctions et définitions de classes pour en savoir plus sur les dé corateurs.
descripteur
Any object which defines the methods __get__(), __set__(), or __delete__(). When a class attribute
is a descriptor, its special binding behavior is triggered upon attribute lookup. Normally, using a.b to get,
set or delete an attribute looks up the object named b in the class dictionary for a, but if b is a descriptor,
the respective descriptor method gets called. Understanding descriptors is a key to a deep understanding of
Python because they are the basis for many features including functions, methods, properties, class methods,
static methods, and reference to super classes.
Pour plus d’informations sur les mé thodes des descripteurs, consultez Implémentation de descripteurs ou le
guide pour l’utilisation des descripteurs.
dictionnaire
An associative array, where arbitrary keys are mapped to values. The keys can be any object with __hash__()
and __eq__() methods. Called a hash in Perl.
dictionnaire en compréhension (ou dictionnaire en intension)
Écriture concise pour traiter tout ou partie des é lé ments d’un ité rable et renvoyer un dictionnaire contenant les
ré sultats. results = {n: n ** 2 for n in range(10)} gé nè re un dictionnaire contenant des clé s n
lié es à leurs valeurs n ** 2. Voir compréhensions.
vue de dictionnaire
Objets retourné s par les mé thodes [Link](), [Link]() et [Link](). Ils fournissent des
vues dynamiques des entré es du dictionnaire, ce qui signifie que lorsque le dictionnaire change, la vue change.
Pour transformer une vue en vraie liste, utilisez list(dictview). Voir dict-views.
chaîne de documentation (docstring)
A string literal which appears as the first expression in a class, function or module. While ignored when the
suite is executed, it is recognized by the compiler and put into the __doc__ attribute of the enclosing class,
function or module. Since it is available via introspection, it is the canonical place for documentation of the
object.
typage canard (duck-typing)
Style de programmation qui ne prend pas en compte le type d’un objet pour dé terminer s’il respecte une
interface, mais qui appelle simplement la mé thode ou l’attribut (Si ça a un bec et que ça cancane, ça doit être
un canard, duck signifie canard en anglais). En se concentrant sur les interfaces plutô t que les types, du code
bien construit amé liore sa flexibilité en autorisant des substitutions polymorphiques. Le duck-typing é vite de
vé rifier les types via type() ou isinstance(), Notez cependant que le duck-typing peut travailler de pair
avec les classes mère abstraites. À la place, le duck-typing utilise plutô t hasattr() ou la programmation
EAFP.
dunder
An informal short-hand for ”double underscore”, used when talking about a special method. For example,
__init__ is often pronounced ”dunder init”.
EAFP
Il est plus simple de demander pardon que demander la permission (Easier to Ask for Forgiveness than Per-
mission en anglais). Ce style de dé veloppement Python fait l’hypothè se que le code est valide et traite les
exceptions si cette hypothè se s’avè re fausse. Ce style, propre et efficace, est caracté risé par la pré sence de
beaucoup de mots clé s try et except. Cette technique de programmation contraste avec le style LBYL utilisé
couramment dans les langages tels que C.

159
The Python Language Reference, Version 3.13.7

expression
Suite logique de termes et chiffres conformes à la syntaxe Python dont l’é valuation fournit une valeur. En
d’autres termes, une expression est une suite d’é lé ments tels que des noms, opé rateurs, litté raux, accè s d’at-
tributs, mé thodes ou fonctions qui aboutissent à une valeur. Contrairement à beaucoup d’autres langages, les
diffé rentes constructions du langage ne sont pas toutes des expressions. On trouve é galement des instructions
qui ne peuvent pas ê tre utilisé es comme expressions, tel que while. Les affectations sont é galement des
instructions et non des expressions.
module d’extension
Module é crit en C ou C++, utilisant l’API C de Python pour interagir avec Python et le code de l’utilisateur.
f-string
Chaîne litté rale pré fixé e de 'f' ou 'F'. Les ”f-strings” sont un raccourci pour formatted string literals. Voir
la PEP 498.
objet fichier
An object exposing a file-oriented API (with methods such as read() or write()) to an underlying resource.
Depending on the way it was created, a file object can mediate access to a real on-disk file or to another type
of storage or communication device (for example standard input/output, in-memory buffers, sockets, pipes,
etc.). File objects are also called file-like objects or streams.
Il existe en ré alité trois caté gories de fichiers objets : les fichiers binaires bruts, les fichiers binaires avec tampon
(buffer) et les fichiers textes. Leurs interfaces sont dé finies dans le module io. Le moyen le plus simple et direct
de cré er un objet fichier est d’utiliser la fonction open().
objet fichier-compatible
Synonyme de objet fichier.
encodage du système de fichiers et gestionnaire d’erreurs associé
Encodage et gestionnaire d’erreurs utilisé s par Python pour dé coder les octets fournis par le systè me d’exploi-
tation et encoder les chaînes de caractè res Unicode afin de les passer au systè me.
L’encodage du systè me de fichiers doit impé rativement pouvoir dé coder tous les octets jusqu’à 128. Si ce n’est
pas le cas, certaines fonctions de l’API lè vent UnicodeError.
Cet encodage et son gestionnaire d’erreur peuvent ê tre obtenus à l’aide des fonctions sys.
getfilesystemencoding() et [Link]().

L’encodage du système de fichiers et gestionnaire d’erreurs associé sont configuré s au dé marrage de Python
par la fonction PyConfig_Read() : regardez filesystem_encoding et filesystem_errors dans les
membres de PyConfig.
Voir aussi encodage régional.
chercheur
Objet qui essaie de trouver un chargeur pour le module en cours d’importation.
There are two types of finder : meta path finders for use with sys.meta_path, and path entry finders for
use with sys.path_hooks.
See Chercheurs et chargeurs and importlib for much more detail.
division entière
Division mathé matique arrondissant à l’entier infé rieur. L’opé rateur de la division entiè re est //. Par exemple
l’expression 11 // 4 vaut 2, contrairement à 11 / 4 qui vaut 2.75. Notez que (-11) // 4 vaut -3 car
l’arrondi se fait à l’entier infé rieur. Voir la PEP 328.
free threading
A threading model where multiple threads can run Python bytecode simultaneously within the same interpre-
ter. This is in contrast to the global interpreter lock which allows only one thread to execute Python bytecode
at a time. See PEP 703.
free variable
Formally, as defined in the language execution model, a free variable is any variable used in a namespace
which is not a local variable in that namespace. See closure variable for an example. Pragmatically, due to
the name of the codeobject.co_freevars attribute, the term is also sometimes used as a synonym for
closure variable.
fonction
Suite d’instructions qui renvoie une valeur à son appelant. On peut lui passer des arguments qui pourront ê tre
utilisé s dans le corps de la fonction. Voir aussi paramètre, méthode et Définition de fonctions.

160 Annexe A. Glossaire

 The Python Language Reference, Version 3.13.7

annotation de fonction
annotation d’un paramè tre de fonction ou valeur de retour.
Les annotations de fonctions sont gé né ralement utilisé es pour des indications de types : par exemple, cette
fonction devrait prendre deux arguments int et devrait é galement avoir une valeur de retour de type int :

def sum_two_numbers(a: int, b: int) -> int:

return a + b

L’annotation syntaxique de la fonction est expliqué e dans la section Définition de fonctions.

Voir annotation de variable et la PEP 484, qui dé crivent cette fonctionnalité . Voir aussi annotations-howto
sur les bonnes pratiques concernant les annotations.
__future__
Une importation depuis le futur s’é crit from __future__ import <fonctionnalité>. Lorsqu’une im-
portation du futur est active dans un module, Python compile ce module avec une certaine modification de
la syntaxe ou du comportement qui est voué e à devenir standard dans une version ulté rieure. Le module
__future__ documente les possibilité s pour fonctionnalité. L’importation a aussi l’effet normal d’impor-
ter une variable du module. Cette variable contient des informations utiles sur la fonctionnalité en question,
notamment la version de Python dans laquelle elle a é té ajouté e, et celle dans laquelle elle deviendra standard :

>>> import __future__

>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

ramasse-miettes
(garbage collection en anglais) Mé canisme permettant de libé rer de la mé moire lorsqu’elle n’est plus utili-
sé e. Python utilise un ramasse-miettes par comptage de ré fé rence et un ramasse-miettes cyclique capable de
dé tecter et casser les ré fé rences circulaires. Le ramasse-miettes peut ê tre contrô lé en utilisant le module gc.
générateur
Fonction qui renvoie un itérateur de générateur. Cela ressemble à une fonction normale, en dehors du fait
qu’elle contient une ou des expressions yield produisant une sé rie de valeurs utilisable dans une boucle for
ou ré cupé ré es une à une via la fonction next().
Fait gé né ralement ré fé rence à une fonction gé né ratrice mais peut faire ré fé rence à un itérateur de généra-
teur dans certains contextes. Dans les cas où le sens voulu n’est pas clair, utiliser les termes complets lè ve
l’ambiguïté .
itérateur de générateur
Objet cré é par une fonction générateur.
Each yield temporarily suspends processing, remembering the execution state (including local variables
and pending try-statements). When the generator iterator resumes, it picks up where it left off (in contrast to
functions which start fresh on every invocation).
expression génératrice
An expression that returns an iterator. It looks like a normal expression followed by a for clause defining a
loop variable, range, and an optional if clause. The combined expression generates values for an enclosing
function :

>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81

285

fonction générique
Fonction composé e de plusieurs fonctions implé mentant les mê mes opé rations pour diffé rents types. L’im-
plé mentation à utiliser est dé terminé e lors de l’appel par l’algorithme de ré partition.
Voir aussi single dispatch, le dé corateur [Link]() et la PEP 443.
type générique
Un type qui peut ê tre paramé tré ; gé né ralement un conteneur comme list ou dict. Utilisé pour les indica-
tions de type et les annotations.
Pour plus de dé tails, voir types alias gé né riques et le module typing. On trouvera l’historique de cette fonc-
tionnalité dans les PEP 483, PEP 484 et PEP 585.

161
The Python Language Reference, Version 3.13.7

GIL
Voir global interpreter lock.
verrou global de l’interpréteur
(global interpreter lock en anglais) Mé canisme utilisé par l’interpré teur CPython pour s’assurer qu’un seul fil
d’exé cution (thread en anglais) n’exé cute le bytecode à la fois. Cela simplifie l’implé mentation de CPython en
rendant le modè le objet (incluant des parties critiques comme la classe native dict) implicitement proté gé
contre les accè s concourants. Verrouiller l’interpré teur entier rend plus facile l’implé mentation de multiples
fils d’exé cution (multi-thread en anglais), au dé triment malheureusement de beaucoup du parallé lisme possible
sur les machines ayant plusieurs processeurs.
Cependant, certains modules d’extension, standards ou non, sont conçus de maniè re à libé rer le GIL lorsqu’ils
effectuent des tâ ches lourdes tel que la compression ou le hachage. De la mê me maniè re, le GIL est toujours
libé ré lors des entré es-sorties.
As of Python 3.13, the GIL can be disabled using the --disable-gil build configuration. After building
Python with this option, code must be run with -X gil=0 or after setting the PYTHON_GIL=0 environment
variable. This feature enables improved performance for multi-threaded applications and makes it easier to
use multi-core CPUs efficiently. For more details, see PEP 703.
pyc utilisant le hachage
Un fichier de cache de code intermé diaire (bytecode en anglais) qui utilise le hachage plutô t que l’heure
de derniè re modification du fichier source correspondant pour dé terminer sa validité . Voir Invalidation de
bytecode mis en cache.
hachable
An object is hashable if it has a hash value which never changes during its lifetime (it needs a __hash__()
method), and can be compared to other objects (it needs an __eq__() method). Hashable objects which
compare equal must have the same hash value.
La hachabilité permet à un objet d’ê tre utilisé comme clé de dictionnaire ou en tant que membre d’un ensemble
(type set), car ces structures de donné es utilisent ce hash.
La plupart des types immuables natifs de Python sont hachables, mais les conteneurs mutables (comme les
listes ou les dictionnaires) ne le sont pas ; les conteneurs immuables (comme les n-uplets ou les ensembles figé s)
ne sont hachables que si leurs é lé ments sont hachables. Les instances de classes dé finies par les utilisateurs
sont hachables par dé faut. Elles sont toutes considé ré es diffé rentes (sauf avec elles-mê mes) et leur valeur de
hachage est calculé e à partir de leur id().
IDLE
Environnement d’apprentissage et de dé veloppement inté gré pour Python. IDLE est un é diteur basique et un
interpré teur livré avec la distribution standard de Python.
immortal
Immortal objects are a CPython implementation detail introduced in PEP 683.
If an object is immortal, its reference count is never modified, and therefore it is never deallocated while the
interpreter is running. For example, True and None are immortal in CPython.
immuable
Objet dont la valeur ne change pas. Les nombres, les chaînes et les n-uplets sont immuables. Ils ne peuvent ê tre
modifié s. Un nouvel objet doit ê tre cré é si une valeur diffé rente doit ê tre stocké e. Ils jouent un rô le important
quand une valeur de hash constante est requise, typiquement en clé de dictionnaire.
chemin des importations
Liste de entrées dans lesquelles le chercheur basé sur les chemins cherche les modules à importer. Typiquement,
lors d’une importation, cette liste vient de [Link] ; pour les sous-paquets, elle peut aussi venir de l’attribut
__path__ du paquet parent.
importation
Processus rendant le code Python d’un module disponible dans un autre.
importateur
Objet qui trouve et charge un module, en mê me temps un chercheur et un chargeur.
interactif
Python has an interactive interpreter which means you can enter statements and expressions at the interpreter
prompt, immediately execute them and see their results. Just launch python with no arguments (possibly
by selecting it from your computer’s main menu). It is a very powerful way to test out new ideas or inspect
modules and packages (remember help(x)). For more on interactive mode, see tut-interac.

162 Annexe A. Glossaire

 The Python Language Reference, Version 3.13.7

interprété
Python est un langage interpré té , en opposition aux langages compilé s, bien que la frontiè re soit floue en
raison de la pré sence d’un compilateur en code intermé diaire. Cela signifie que les fichiers sources peuvent
ê tre exé cuté s directement, sans avoir à compiler un fichier exé cutable intermé diaire. Les langages interpré té s
ont gé né ralement un cycle de dé veloppement / dé bogage plus court que les langages compilé s. Cependant, ils
s’exé cutent gé né ralement plus lentement. Voir aussi interactif.
arrêt de l’interpréteur
Lorsqu’on lui demande de s’arrê ter, l’interpré teur Python entre dans une phase spé ciale où il libè re graduel-
lement les ressources alloué es, comme les modules ou quelques structures de donné es internes. Il fait aussi
quelques appels au ramasse-miettes. Cela peut dé clencher l’exé cution de code dans des destructeurs ou des
fonctions de rappels de weakrefs. Le code exé cuté lors de l’arrê t peut rencontrer des exceptions puisque les
ressources auxquelles il fait appel sont susceptibles de ne plus fonctionner, (typiquement les modules des
bibliothè ques ou le mé canisme de warning).
La principale raison d’arrê t de l’interpré teur est que le module __main__ ou le script en cours d’exé cution a
terminé de s’exé cuter.
itérable
An object capable of returning its members one at a time. Examples of iterables include all sequence types
(such as list, str, and tuple) and some non-sequence types like dict, file objects, and objects of any
classes you define with an __iter__() method or with a __getitem__() method that implements sequence
semantics.
Iterables can be used in a for loop and in many other places where a sequence is needed (zip(), map(),
...). When an iterable object is passed as an argument to the built-in function iter(), it returns an iterator
for the object. This iterator is good for one pass over the set of values. When using iterables, it is usually not
necessary to call iter() or deal with iterator objects yourself. The for statement does that automatically for
you, creating a temporary unnamed variable to hold the iterator for the duration of the loop. See also iterator,
sequence, and generator.
itérateur
An object representing a stream of data. Repeated calls to the iterator’s __next__() method (or passing
it to the built-in function next()) return successive items in the stream. When no more data are available
a StopIteration exception is raised instead. At this point, the iterator object is exhausted and any fur-
ther calls to its __next__() method just raise StopIteration again. Iterators are required to have an
__iter__() method that returns the iterator object itself so every iterator is also iterable and may be used
in most places where other iterables are accepted. One notable exception is code which attempts multiple
iteration passes. A container object (such as a list) produces a fresh new iterator each time you pass it
to the iter() function or use it in a for loop. Attempting this with an iterator will just return the same
exhausted iterator object used in the previous iteration pass, making it appear like an empty container.
Vous trouverez davantage d’informations dans typeiter.
Particularité de l’implémentation CPython : CPython does not consistently apply the requirement that an
iterator define __iter__(). And also please note that the free-threading CPython does not guarantee the
thread-safety of iterator operations.
fonction clé
Une fonction clé est un objet appelable qui renvoie une valeur à fins de tri ou de classement. Par exemple, la
fonction [Link]() est utilisé e pour gé né rer une clé de classement prenant en compte les conven-
tions de classement spé cifiques aux paramè tres ré gionaux courants.
Plusieurs outils dans Python acceptent des fonctions clé s pour dé terminer comment les é lé ments sont clas-
sé s ou groupé s. On peut citer les fonctions min(), max(), sorted(), [Link](), [Link](),
[Link](), [Link]() et [Link]().

Il existe plusieurs moyens de cré er une fonction clé . Par exemple, la mé thode [Link]() peut servir
de fonction clé pour effectuer des recherches insensibles à la casse. Aussi, il est possible de cré er des fonc-
tions clé s avec des expressions lambda, comme lambda r: (r[0], r[2]). Par ailleurs attrgetter(),
itemgetter() et methodcaller() permettent de cré er des fonctions clé s. Voir le guide pour le tri pour
des exemples de cré ation et d’utilisation de fonctions clefs.
argument nommé
Voir argument.
lambda

163
The Python Language Reference, Version 3.13.7

Fonction anonyme sous la forme d’une expression et ne contenant qu’une seule expression, exé cuté e lorsque
la fonction est appelé e. La syntaxe pour cré er des fonctions lambda est : lambda [parameters]:
expression
LBYL
Regarde avant de sauter, (Look before you leap en anglais). Ce style de programmation consiste à vé rifier des
conditions avant d’effectuer des appels ou des accè s. Ce style contraste avec le style EAFP et se caracté rise
par la pré sence de beaucoup d’instructions if .
Dans un environnement avec plusieurs fils d’exé cution (multi-threaded en anglais), le style LBYL peut engen-
drer un sé quencement critique (race condition en anglais) entre le ”regarde” et le ”sauter”. Par exemple, le
code if key in mapping: return mapping[key] peut é chouer si un autre fil d’exé cution supprime
la clé key du mapping aprè s le test mais avant l’accè s. Ce problè me peut ê tre ré solu avec des verrous (locks)
ou avec l’approche EAFP.
lexical analyzer
Formal name for the tokenizer ; see token.
liste
A built-in Python sequence. Despite its name it is more akin to an array in other languages than to a linked
list since access to elements is O(1).
liste en compréhension (ou liste en intension)
Écriture concise pour manipuler tout ou partie des é lé ments d’une sé quence et renvoyer une liste contenant
les ré sultats. result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] gé nè re
la liste composé e des nombres pairs de 0 à 255 é crits sous formes de chaînes de caractè res et en hexadé cimal
(0x…). La clause if est optionnelle. Si elle est omise, tous les é lé ments du range(256) seront utilisé s.
chargeur
An object that loads a module. It must define the exec_module() and create_module() methods to
implement the Loader interface. A loader is typically returned by a finder. See also :
— Chercheurs et chargeurs
— [Link]
— PEP 302
encodage régional
Sous Unix, il est dé fini par la variable ré gionale LC_CTYPE. Il peut ê tre modifié par locale.
setlocale(locale.LC_CTYPE, new_locale).
Sous Windows, c’est un encodage ANSI (par ex. : "cp1252").
Sous Android et VxWorks, Python utilise "utf-8" comme encodage ré gional.
[Link]() can be used to get the locale encoding.

Voir aussi l’encodage du systèmes de fichiers et gestionnaire d’erreurs associé.

méthode magique
Un synonyme informel de special method.
tableau de correspondances (mapping en anglais)
Conteneur permettant de rechercher des é lé ments à partir de clé s et implé mentant les mé thodes spé cifié es
dans les classes mè res abstraites des tableaux de correspondances (immuables) ou tableaux de
correspondances mutables (voir les classes mè res abstraites). Les classes suivantes sont des exemples
de tableaux de correspondances : dict, [Link], [Link] et
[Link].
chercheur dans les méta-chemins
Un chercheur renvoyé par une recherche dans sys.meta_path. Les chercheurs dans les mé ta-chemins res-
semblent, mais sont diffé rents des chercheurs d’entrée dans path.
Voir [Link] pour les mé thodes que les chercheurs dans les mé ta-chemins
doivent implé menter.
métaclasse
Classe d’une classe. Les dé finitions de classe cré ent un nom pour la classe, un dictionnaire de classe et une
liste de classes parentes. La mé taclasse a pour rô le de ré unir ces trois paramè tres pour construire la classe.
La plupart des langages orienté s objet fournissent une implé mentation par dé faut. La particularité de Python
est la possibilité de cré er des mé taclasses personnalisé es. La plupart des utilisateurs n’auront jamais besoin de
cet outil, mais lorsque le besoin survient, les mé taclasses offrent des solutions é lé gantes et puissantes. Elles

164 Annexe A. Glossaire

 The Python Language Reference, Version 3.13.7

sont utilisé es pour journaliser les accè s à des proprié té s, rendre sû rs les environnements multi-threads, suivre
la cré ation d’objets, implé menter des singletons et bien d’autres tâ ches.
Plus d’informations sont disponibles dans : Métaclasses.
méthode
Fonction dé finie à l’inté rieur d’une classe. Lorsqu’elle est appelé e comme un attribut d’une instance de cette
classe, la mé thode reçoit l’instance en premier argument (qui, par convention, est habituellement nommé
self). Voir function et nested scope.
ordre de résolution des méthodes
Method Resolution Order is the order in which base classes are searched for a member during lookup. See
python_2.3_mro for details of the algorithm used by the Python interpreter since the 2.3 release.
module
Objet utilisé pour organiser une portion unitaire de code en Python. Les modules ont un espace de nommage
et peuvent contenir n’importe quels objets Python. Charger des modules est appelé importer.
Voir aussi paquet.
spécificateur de module
Espace de nommage contenant les informations, relatives à l’importation, utilisé es pour charger un module.
C’est une instance de la classe [Link].
See also Spécificateurs de modules.
MRO
Voir ordre de résolution des méthodes.
mutable
Un objet mutable peut changer de valeur tout en gardant le mê me id(). Voir aussi immuable.
n-uplet nommé
Le terme ”n-uplet nommé ” s’applique à tous les types ou classes qui hé ritent de la classe tuple et dont les
é lé ments indexables sont aussi accessibles en utilisant des attributs nommé s. Les types et classes peuvent avoir
aussi d’autres caracté ristiques.
Plusieurs types natifs sont appelé s n-uplets, y compris les valeurs retourné es par [Link]() et
[Link](). Un autre exemple est sys.float_info :

>>> sys.float_info[1] # indexed access

1024
>>> sys.float_info.max_exp # named field access
1024
>>> isinstance(sys.float_info, tuple) # kind of tuple
True

Some named tuples are built-in types (such as the above examples). Alternatively, a named tuple can be
created from a regular class definition that inherits from tuple and that defines named fields. Such a class
can be written by hand, or it can be created by inheriting [Link], or with the factory function
[Link](). The latter techniques also add some extra methods that may not be found
in hand-written or built-in named tuples.
espace de nommage
L’endroit où une variable est stocké e. Les espaces de nommage sont implé menté s avec des dictionnaires. Il
existe des espaces de nommage globaux, natifs ou imbriqué s dans les objets (dans les mé thodes). Les espaces
de nommage favorisent la modularité car ils permettent d’é viter les conflits de noms. Par exemple, les fonctions
[Link] et [Link]() sont diffé rencié es par leurs espaces de nom. Les espaces de nommage aident
aussi à la lisibilité et la maintenabilité en rendant clair quel module implé mente une fonction. Par exemple,
é crire [Link]() ou [Link]() affiche clairement que ces fonctions sont implé menté es
respectivement dans les modules random et itertools.
paquet-espace de nommage
A package which serves only as a container for subpackages. Namespace packages may have no physical
representation, and specifically are not like a regular package because they have no __init__.py file.
Namespace packages allow several individually installable packages to have a common parent package. Other-
wise, it is recommended to use a regular package.
For more information, see PEP 420 and Paquets espaces de nommage.

165
The Python Language Reference, Version 3.13.7

Voir aussi module.

portée imbriquée
Possibilité de faire ré fé rence à une variable dé claré e dans une dé finition englobante. Typiquement, une fonc-
tion dé finie à l’inté rieur d’une autre fonction a accè s aux variables de cette derniè re. Souvenez-vous cependant
que cela ne fonctionne que pour accé der à des variables, pas pour les assigner. Les variables locales sont lues
et assigné es dans l’espace de nommage le plus proche. Tout comme les variables globales qui sont stocké s
dans l’espace de nommage global, le mot clef nonlocal permet d’é crire dans l’espace de nommage dans
lequel est dé claré e la variable.
nouvelle classe
Old name for the flavor of classes now used for all class objects. In earlier Python versions, only
new-style classes could use Python’s newer, versatile features like __slots__, descriptors, properties,
__getattribute__(), class methods, and static methods.
objet
N’importe quelle donné e comportant des é tats (sous forme d’attributs ou d’une valeur) et un comportement
(des mé thodes). C’est aussi (object) l’ancê tre commun à absolument toutes les nouvelles classes.
optimized scope
A scope where target local variable names are reliably known to the compiler when the code is compiled,
allowing optimization of read and write access to these names. The local namespaces for functions, generators,
coroutines, comprehensions, and generator expressions are optimized in this fashion. Note : most interpreter
optimizations are applied to all scopes, only those relying on a known set of local and nonlocal variable names
are restricted to optimized scopes.
paquet
module Python qui peut contenir des sous-modules ou des sous-paquets. Techniquement, un paquet est un
module qui possè de un attribut __path__.
Voir aussi paquet classique et namespace package.
paramètre
Entité nommé e dans la dé finition d’une fonction (ou mé thode), dé crivant un argument (ou dans certains cas
des arguments) que la fonction accepte. Il existe cinq sortes de paramè tres :
— positional-or-keyword : l’argument peut ê tre passé soit par sa position, soit en tant que argument nommé.
C’est le type de paramè tre par dé faut. Par exemple, foo et bar dans l’exemple suivant :

def func(foo, bar=None): ...

— positional-only : dé finit un argument qui ne peut ê tre fourni que par position. Les paramè tres positional-
only peuvent ê tre dé finis en insé rant un caractè re ”/” dans la liste de paramè tres de la dé finition de fonction
aprè s eux. Par exemple : posonly1 et posonly2 dans le code suivant :

def func(posonly1, posonly2, /, positional_or_keyword): ...

— keyword-only : l’argument ne peut ê tre fourni que nommé . Les paramè tres keyword-only peuvent ê tre
dé finis en utilisant un seul paramè tre var-positional, ou en ajoutant une é toile (*) seule dans la liste des
paramè tres avant eux. Par exemple, kw_only1 et kw_only2 dans le code suivant :

def func(arg, *, kw_only1, kw_only2): ...

— var-positional : une sé quence d’arguments positionnels peut ê tre fournie (en plus de tous les arguments
positionnels dé jà accepté s par d’autres paramè tres). Un tel paramè tre peut ê tre dé fini en pré fixant son
nom par une *. Par exemple args ci-aprè s :

def func(*args, **kwargs): ...

— var-keyword : une quantité arbitraire d’arguments peut ê tre passé e, chacun é tant nommé (en plus de tous
les arguments nommé s dé jà accepté s par d’autres paramè tres). Un tel paramè tre est dé fini en pré fixant le
nom du paramè tre par **. Par exemple, kwargs ci-dessus.
Les paramè tres peuvent spé cifier des arguments obligatoires ou optionnels, ainsi que des valeurs par dé faut
pour les arguments optionnels.
Voir aussi argument dans le glossaire, la question sur la diffé rence entre les arguments et les paramè tres dans
la FAQ, la classe [Link], la section Définition de fonctions et la PEP 362.

166 Annexe A. Glossaire

 The Python Language Reference, Version 3.13.7

entrée de chemin
Emplacement dans le chemin des importations (import path en anglais, d’où le path) que le chercheur basé sur
les chemins consulte pour trouver des modules à importer.
chercheur de chemins
chercheur renvoyé par un appelable sur un sys.path_hooks (c’est-à -dire un point d’entrée pour la recherche
dans path) qui sait où trouver des modules lorsqu’on lui donne une entrée de path.
Voir [Link] pour les mé thodes qu’un chercheur d’entré e dans path doit im-
plé menter.
point d’entrée pour la recherche dans path
A callable on the sys.path_hooks list which returns a path entry finder if it knows how to find modules
on a specific path entry.
chercheur basé sur les chemins
L’un des chercheurs dans les méta-chemins par dé faut qui cherche des modules dans un chemin des importa-
tions.
objet simili-chemin
Objet repré sentant un chemin du systè me de fichiers. Un objet simili-chemin est un objet str ou un objet
bytes repré sentant un chemin ou un objet implé mentant le protocole [Link]. Un objet qui accepte le
protocole [Link] peut ê tre converti en un chemin str ou bytes du systè me de fichiers en appelant la
fonction [Link](). [Link]() et [Link]() peuvent ê tre utilisé es, respectivement, pour
garantir un ré sultat de type str ou bytes à la place. A é té Introduit par la PEP 519.
PEP
Python Enhancement Proposal (Proposition d’amé lioration de Python). Une PEP est un document de concep-
tion fournissant des informations à la communauté Python ou dé crivant une nouvelle fonctionnalité pour
Python, ses processus ou son environnement. Les PEP doivent fournir une spé cification technique concise et
une justification des fonctionnalité s proposé es.
Les PEP sont censé es ê tre les principaux mé canismes pour proposer de nouvelles fonctionnalité s majeures,
pour recueillir les commentaires de la communauté sur une question et pour documenter les dé cisions de
conception qui sont inté gré es en Python. L’auteur du PEP est responsable de l’é tablissement d’un consensus
au sein de la communauté et de documenter les opinions contradictoires.
Voir la PEP 1.
portion
Jeu de fichiers dans un seul dossier (pouvant ê tre stocké sous forme de fichier zip) qui contribue à l’espace de
nommage d’un paquet, tel que dé fini dans la PEP 420.
argument positionnel
Voir argument.
API provisoire
Une API provisoire est une API qui n’offre aucune garantie de ré trocompatibilité (la bibliothè que standard
exige la ré trocompatibilité ). Bien que des changements majeurs d’une telle interface ne soient pas attendus,
tant qu’elle est é tiqueté e provisoire, des changements cassant la ré trocompatibilité (y compris sa suppres-
sion complè te) peuvent survenir si les dé veloppeurs principaux le jugent né cessaire. Ces modifications ne
surviendront que si de sé rieux problè mes sont dé couverts et qu’ils n’avaient pas é té identifié s avant l’ajout de
l’API.
Mê me pour les API provisoires, les changements cassant la ré trocompatibilité sont considé ré s comme des
”solutions de dernier recours”. Tout ce qui est possible sera fait pour tenter de ré soudre les problè mes en
conservant la ré trocompatibilité .
Ce processus permet à la bibliothè que standard de continuer à é voluer avec le temps, sans se bloquer long-
temps sur des erreurs d’architecture. Voir la PEP 411 pour plus de dé tails.
paquet provisoire
Voir provisional API.
Python 3000
Surnom donné à la sé rie des Python 3.x (trè s vieux surnom donné à l’é poque où Python 3 repré sentait un
futur lointain). Aussi abré gé Py3k.
Pythonique
Idé e, ou bout de code, qui colle aux idiomes de Python plutô t qu’aux concepts communs rencontré s dans

167
The Python Language Reference, Version 3.13.7

d’autres langages. Par exemple, il est idiomatique en Python de parcourir les é lé ments d’un ité rable en utilisant
for. Beaucoup d’autres langages n’ont pas cette possibilité , donc les gens qui ne sont pas habitué s à Python
utilisent parfois un compteur numé rique à la place :

for i in range(len(food)):
print(food[i])

Plutô t qu’utiliser la mé thode, plus propre et é lé gante, donc Pythonique :

for piece in food:

print(piece)

nom qualifié
Nom, comprenant des points, montrant le ”chemin” de l’espace de nommage global d’un module vers une
classe, fonction ou mé thode dé finie dans ce module, tel que dé fini dans la PEP 3155. Pour les fonctions et
classes de premier niveau, le nom qualifié est le mê me que le nom de l’objet :

>>> class C:
... class D:
... def meth(self):
... pass
...
>>> C.__qualname__
'C'
>>> C.D.__qualname__
'C.D'
>>> [Link].__qualname__
'[Link]'

Lorsqu’il est utilisé pour nommer des modules, le nom qualifié complet (fully qualified name - FQN en anglais)
signifie le chemin complet (sé paré par des points) vers le module, incluant tous les paquets parents. Par
exemple : [Link] :

>>> import [Link]

>>> [Link].__name__
'[Link]'

nombre de références
The number of references to an object. When the reference count of an object drops to zero, it is deallocated.
Some objects are immortal and have reference counts that are never modified, and therefore the objects are
never deallocated. Reference counting is generally not visible to Python code, but it is a key element of the
CPython implementation. Programmers can call the [Link]() function to return the reference
count for a particular object.
In CPython, reference counts are not considered to be stable or well-defined values ; the number of references
to an object, and how that number is affected by Python code, may be different between versions.
paquet classique
paquet traditionnel, tel qu’un dossier contenant un fichier __init__.py.
Voir aussi paquet-espace de nommage.
REPL
An acronym for the ”read–eval–print loop”, another name for the interactive interpreter shell.
__slots__
Dé claration dans une classe qui é conomise de la mé moire en pré -allouant de l’espace pour les attributs des
instances et qui é limine le dictionnaire (des attributs) des instances. Bien que populaire, cette technique est
difficile à maîtriser et devrait ê tre ré servé e à de rares cas où un grand nombre d’instances dans une application
devient un sujet critique pour la mé moire.
séquence
An iterable which supports efficient element access using integer indices via the __getitem__() special
method and defines a __len__() method that returns the length of the sequence. Some built-in sequence

168 Annexe A. Glossaire

 The Python Language Reference, Version 3.13.7

types are list, str, tuple, and bytes. Note that dict also supports __getitem__() and __len__(),
but is considered a mapping rather than a sequence because the lookups use arbitrary hashable keys rather
than integers.
The [Link] abstract base class defines a much richer interface that goes
beyond just __getitem__() and __len__(), adding count(), index(), __contains__(), and
__reversed__(). Types that implement this expanded interface can be registered explicitly using
register(). For more documentation on sequence methods generally, see Common Sequence Operations.
ensemble en compréhension (ou ensemble en intension)
Une façon compacte de traiter tout ou partie des é lé ments d’un ité rable et de renvoyer un set avec les ré sul-
tats. results = {c for c in 'abracadabra' if c not in 'abc'} gé nè re l’ensemble contenant
les lettres « r » et « d » {'r', 'd'}. Voir Agencements des listes, ensembles et dictionnaires.
distribution simple
Forme de distribution, comme les fonction génériques, où l’implé mentation est choisie en fonction du type
d’un seul argument.
tranche
(slice en anglais), un objet contenant habituellement une portion de séquence. Une tranche est cré ée
en utilisant la notation [] avec des : entre les nombres lorsque plusieurs sont fournis, comme dans
variable_name[1:3:5]. Cette notation utilise des objets slice en interne.
soft deprecated
A soft deprecated API should not be used in new code, but it is safe for already existing code to use it. The
API remains documented and tested, but will not be enhanced further.
Soft deprecation, unlike normal deprecation, does not plan on removing the API and will not emit warnings.
See PEP 387 : Soft Deprecation.
méthode spéciale
(special method en anglais) Mé thode appelé e implicitement par Python pour exé cuter une opé ration sur un
type, comme une addition. De telles mé thodes ont des noms commençant et terminant par des doubles tirets
bas. Les mé thodes spé ciales sont documenté es dans Méthodes spéciales.
standard library
The collection of packages, modules and extension modules distributed as a part of the official Python in-
terpreter package. The exact membership of the collection may vary based on platform, available system
libraries, or other criteria. Documentation can be found at library-index.
See also sys.stdlib_module_names for a list of all possible standard library module names.
instruction
Une instruction (statement en anglais) est un composant d’un ”bloc” de code. Une instruction est soit une
expression, soit une ou plusieurs constructions basé es sur un mot-clé , comme if , while ou for.
static type checker
An external tool that reads Python code and analyzes it, looking for issues such as incorrect types. See also
type hints and the typing module.
stdlib
An abbreviation of standard library.
référence forte
In Python’s C API, a strong reference is a reference to an object which is owned by the code holding the
reference. The strong reference is taken by calling Py_INCREF() when the reference is created and released
with Py_DECREF() when the reference is deleted.
Une ré fé rence forte est cré ée à l’aide de la fonction Py_NewRef(). Il faut normalement appeler
Py_DECREF() dessus avant de sortir de sa porté e lexicale, sans quoi il y a une fuite de ré fé rence.
Voir aussi référence empruntée.
encodages de texte
Une chaîne de caractè res en Python est une suite de points de code Unicode (dans l’intervalle U+0000--
U+10FFFF). Pour stocker ou transmettre une chaîne, il est né cessaire de la sé rialiser en suite d’octets.

Sé rialiser une chaîne de caractè res en une suite d’octets s’appelle « encoder » et recré er la chaîne à partir de
la suite d’octets s’appelle « dé coder ».
Il existe de multiples codecs pour la sé rialisation de texte, que l’on regroupe sous l’expression « encodages de

169
The Python Language Reference, Version 3.13.7

texte ».
fichier texte
Objet fichier capable de lire et d’é crire des objets str. Souvent, un fichier texte (text file en anglais) accè de
en fait à un flux de donné e en octets et gè re l’encodage de texte automatiquement. Des exemples de fichiers
textes sont les fichiers ouverts en mode texte ('r' ou 'w'), [Link], [Link] et les instances de
[Link].
Voir aussi fichier binaire pour un objet fichier capable de lire et d’é crire des objets octets-compatibles.
token
A small unit of source code, generated by the lexical analyzer (also called the tokenizer). Names, numbers,
strings, operators, newlines and similar are represented by tokens.
The tokenize module exposes Python’s lexical analyzer. The token module contains information on the
various types of tokens.
chaîne entre triple guillemets
Chaîne qui est dé limité e par trois guillemets simples (') ou trois guillemets doubles ("). Bien qu’elle ne
fournisse aucune fonctionnalité qui ne soit pas disponible avec une chaîne entre guillemets, elle est utile pour
de nombreuses raisons. Elle vous autorise à insé rer des guillemets simples et doubles dans une chaîne sans
avoir à les proté ger et elle peut s’é tendre sur plusieurs lignes sans avoir à terminer chaque ligne par un \. Elle
est ainsi particuliè rement utile pour les chaînes de documentation (docstrings).
type
The type of a Python object determines what kind of object it is ; every object has a type. An object’s type is
accessible as its __class__ attribute or can be retrieved with type(obj).
alias de type
Synonyme d’un type, cré é en affectant le type à un identifiant.
Les alias de types sont utiles pour simplifier les indications de types. Par exemple :

def remove_gray_shades(
colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
pass

pourrait ê tre rendu plus lisible comme ceci :

Color = tuple[int, int, int]

def remove_gray_shades(colors: list[Color]) -> list[Color]:

pass

Voir typing et la PEP 484, qui dé crivent cette fonctionnalité .

indication de type
L’annotation qui spé cifie le type attendu pour une variable, un attribut de classe, un paramè tre de fonction ou
une valeur de retour.
Type hints are optional and are not enforced by Python but they are useful to static type checkers. They can
also aid IDEs with code completion and refactoring.
Les indications de type de variables globales, d’attributs de classe et de fonctions, mais pas de variables locales,
peuvent ê tre consulté es en utilisant typing.get_type_hints().
Voir typing et la PEP 484, qui dé crivent cette fonctionnalité .
retours à la ligne universels
Une maniè re d’interpré ter des flux de texte dans lesquels sont reconnues toutes les fins de ligne suivantes : la
convention Unix '\n', la convention Windows '\r\n' et l’ancienne convention Macintosh '\r'. Voir la
PEP 278 et la PEP 3116, ainsi que la fonction [Link]() pour d’autres usages.
annotation de variable
annotation d’une variable ou d’un attribut de classe.
Lorsque vous annotez une variable ou un attribut de classe, l’affectation est facultative :

170 Annexe A. Glossaire

 The Python Language Reference, Version 3.13.7

class C:
field: 'annotation'

Les annotations de variables sont gé né ralement utilisé es pour des indications de types : par exemple, cette
variable devrait prendre des valeurs de type int :

count: int = 0

La syntaxe d’annotation de variable est expliqué e dans la section Les assignations annotées.
Reportez-vous à annotation de fonction, à la PEP 484 et à la PEP 526 qui dé crivent cette fonctionnalité . Voir
aussi annotations-howto sur les bonnes pratiques concernant les annotations.
environnement virtuel
Environnement d’exé cution isolé (en mode coopé ratif) qui permet aux utilisateurs de Python et aux applica-
tions d’installer et de mettre à jour des paquets sans interfé rer avec d’autres applications Python fonctionnant
sur le mê me systè me.
Voir aussi venv.
machine virtuelle
Ordinateur dé fini entiè rement par du logiciel. La machine virtuelle (virtual machine) de Python exé cute le
code intermédiaire produit par le compilateur de bytecode.
walrus operator
A light-hearted way to refer to the assignment expression operator := because it looks a bit like a walrus if
you turn your head.
Le zen de Python
Liste de principes et de pré ceptes utiles pour comprendre et utiliser le langage. Cette liste peut ê tre obtenue
en tapant ”import this” dans une invite Python interactive.

171
The Python Language Reference, Version 3.13.7

172 Annexe A. Glossaire

 ANNEXE B

About this documentation

Python’s documentation is generated from reStructuredText sources using Sphinx, a documentation generator origi-
nally created for Python and now maintained as an independent project.
Le dé veloppement de la documentation et de ses outils est entiè rement basé sur le volontariat, tout comme Python.
Si vous voulez contribuer, allez voir la page reporting-bugs qui contient des informations pour vous y aider. Les
nouveaux volontaires sont toujours les bienvenus !
Merci beaucoup à :
— Fred L. Drake, Jr., the creator of the original Python documentation toolset and author of much of the content ;
— le projet Docutils pour avoir cré é reStructuredText et la suite d’outils Docutils ;
— Fredrik Lundh pour son projet Alternative Python Reference, dont Sphinx a pris beaucoup de bonnes idé es.

B.1 Contributors to the Python documentation

De nombreuses personnes ont contribué au langage Python, à sa bibliothè que standard et à sa documentation. Consul-
tez Misc/ACKS dans les sources de la distribution Python pour avoir une liste partielle des contributeurs.
Ce n’est que grâ ce aux suggestions et contributions de la communauté Python que Python a une documentation si
merveilleuse — Merci !

173
The Python Language Reference, Version 3.13.7

174 Annexe B. About this documentation

 ANNEXE C

Histoire et licence

C.1 Histoire du logiciel

Python was created in the early 1990s by Guido van Rossum at Stichting Mathematisch Centrum (CWI, see https:
//[Link]) in the Netherlands as a successor of a language called ABC. Guido remains Python’s principal author,
although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for National Research Initiatives (CNRI, see https:
//[Link]) in Reston, Virginia where he released several versions of the software.
In May 2000, Guido and the Python core development team moved to [Link] to form the BeOpen PythonLabs
team. In October of the same year, the PythonLabs team moved to Digital Creations, which became Zope Corpo-
ration. In 2001, the Python Software Foundation (PSF, see [Link] was formed, a non-profit
organization created specifically to own Python-related Intellectual Property. Zope Corporation was a sponsoring
member of the PSF.
All Python releases are Open Source (see [Link] for the Open Source Definition). Historically, most,
but not all, Python releases have also been GPL-compatible ; the table below summarizes the various releases.

Version Dérivé de Année Propriétaire GPL-compatible ? (1)

0.9.0 à 1.2 n/a 1991-1995 CWI oui
1.3 à 1.5.2 1.2 1995-1999 CNRI oui
1.6 1.5.2 2000 CNRI non
2.0 1.6 2000 [Link] non
1.6.1 1.6 2001 CNRI yes (2)
2.1 2.0+1.6.1 2001 PSF non
2.0.1 2.0+1.6.1 2001 PSF oui
2.1.1 2.1+2.0.1 2001 PSF oui
2.1.2 2.1.1 2002 PSF oui
2.1.3 2.1.2 2002 PSF oui
2.2 et ulté rieure 2.1.1 2001-maintenant PSF oui

® Note

175
The Python Language Reference, Version 3.13.7

(1) GPL-compatible doesn’t mean that we’re distributing Python under the GPL. All Python licenses, unlike
the GPL, let you distribute a modified version without making your changes open source. The GPL-
compatible licenses make it possible to combine Python with other software that is released under the
GPL ; the others don’t.
(2) According to Richard Stallman, 1.6.1 is not GPL-compatible, because its license has a choice of law
clause. According to CNRI, however, Stallman’s lawyer has told CNRI’s lawyer that 1.6.1 is ”not incom-
patible” with the GPL.

Merci aux nombreux bé né voles qui ont travaillé sous la direction de Guido pour rendre ces versions possibles.

C.2 Conditions générales pour accéder à, ou utiliser, Python

Python software and documentation are licensed under the Python Software Foundation License Version 2.
Starting with Python 3.8.6, examples, recipes, and other code in the documentation are dual licensed under the PSF
License Version 2 and the Zero-Clause BSD license.
Certains logiciels faisant partie de Python sont soumis à d’autres licences. Ces licences sont incluses avec le code lié
à celles-ci. Voir Licences et remerciements pour les logiciels tiers pour une liste non exhaustive de ces licences.

C.2.1 PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2

1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
the Individual or Organization ("Licensee") accessing and otherwise using this
software ("Python") in source or binary form and its associated documentation.

2. Subject to the terms and conditions of this License Agreement, PSF hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python alone or in any derivative
version, provided, however, that PSF's License Agreement and PSF's notice of
copyright, i.e., "Copyright © 2001-2024 Python Software Foundation; All Rights
Reserved" are retained in Python alone or in any derivative version
prepared by Licensee.

3. In the event Licensee prepares a derivative work that is based on or

incorporates Python or any part thereof, and wants to make the
derivative work available to others as provided herein, then Licensee hereby
agrees to include in any such work a brief summary of the changes made to␣
,→Python.

4. PSF is making Python available to Licensee on an "AS IS" basis.

PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON

FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.

7. Nothing in this License Agreement shall be deemed to create any relationship

(suite sur la page suivante)

176 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

of agency, partnership, or joint venture between PSF and Licensee. This License
Agreement does not grant permission to use PSF trademarks or trade name in a
trademark sense to endorse or promote products or services of Licensee, or any
third party.

8. By copying, installing or otherwise using Python, Licensee agrees

to be bound by the terms and conditions of this License Agreement.

C.2.2 LICENCE D’UTILISATION [Link] POUR PYTHON 2.0

LICENCE D’UTILISATION LIBRE BEOPEN PYTHON VERSION 1

1. This LICENSE AGREEMENT is between [Link] ("BeOpen"), having an office at

160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization
("Licensee") accessing and otherwise using this software in source or binary
form and its associated documentation ("the Software").

2. Subject to the terms and conditions of this BeOpen Python License Agreement,
BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license
to reproduce, analyze, test, perform and/or display publicly, prepare derivative
works, distribute, and otherwise use the Software alone or in any derivative
version, provided, however, that the BeOpen Python License is retained in the
Software, alone or in any derivative version prepared by Licensee.

3. BeOpen is making the Software available to Licensee on an "AS IS" basis.

BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING,
MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF
ADVISED OF THE POSSIBILITY THEREOF.

5. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.

6. This License Agreement shall be governed by and interpreted in all respects

by the law of the State of California, excluding conflict of law provisions.
Nothing in this License Agreement shall be deemed to create any relationship of
agency, partnership, or joint venture between BeOpen and Licensee. This License
Agreement does not grant permission to use BeOpen trademarks or trade names in a
trademark sense to endorse or promote products or services of Licensee, or any
third party. As an exception, the "BeOpen Python" logos available at
[Link] may be used according to the permissions
granted on that web page.

7. By copying, installing or otherwise using the software, Licensee agrees to be

bound by the terms and conditions of this License Agreement.

C.2.3 LICENCE D’UTILISATION CNRI POUR PYTHON 1.6.1

1. This LICENSE AGREEMENT is between the Corporation for National Research
Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191
(suite sur la page suivante)

C.2. Conditions générales pour accéder à, ou utiliser, Python 177

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

("CNRI"), and the Individual or Organization ("Licensee") accessing and
otherwise using Python 1.6.1 software in source or binary form and its
associated documentation.

2. Subject to the terms and conditions of this License Agreement, CNRI hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python 1.6.1 alone or in any derivative version,
provided, however, that CNRI's License Agreement and CNRI's notice of copyright,
i.e., "Copyright © 1995-2001 Corporation for National Research Initiatives; All
Rights Reserved" are retained in Python 1.6.1 alone or in any derivative version
prepared by Licensee. Alternately, in lieu of CNRI's License Agreement,
Licensee may substitute the following text (omitting the quotes): "Python 1.6.1
is made available subject to the terms and conditions in CNRI's License
Agreement. This Agreement together with Python 1.6.1 may be located on the
internet using the following unique, persistent identifier (known as a handle):
1895.22/1013. This Agreement may also be obtained from a proxy server on the
internet using the following URL: [Link]

3. In the event Licensee prepares a derivative work that is based on or

incorporates Python 1.6.1 or any part thereof, and wants to make the derivative
work available to others as provided herein, then Licensee hereby agrees to
include in any such work a brief summary of the changes made to Python 1.6.1.

4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" basis. CNRI
MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.

7. This License Agreement shall be governed by the federal intellectual property

law of the United States, including without limitation the federal copyright
law, and, to the extent such U.S. federal law does not apply, by the law of the
Commonwealth of Virginia, excluding Virginia's conflict of law provisions.
Notwithstanding the foregoing, with regard to derivative works based on Python
1.6.1 that incorporate non-separable material that was previously distributed
under the GNU General Public License (GPL), the law of the Commonwealth of
Virginia shall govern this License Agreement only as to issues arising under or
with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in
this License Agreement shall be deemed to create any relationship of agency,
partnership, or joint venture between CNRI and Licensee. This License Agreement
does not grant permission to use CNRI trademarks or trade name in a trademark
sense to endorse or promote products or services of Licensee, or any third
party.

8. By clicking on the "ACCEPT" button where indicated, or by copying, installing

or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and
conditions of this License Agreement.

178 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

C.2.4 LICENCE D’UTILISATION CWI POUR PYTHON 0.9.0 à 1.2

Copyright © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The
Netherlands. All rights reserved.

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted, provided that
the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and that
the name of Stichting Mathematisch Centrum or CWI not be used in advertising or
publicity pertaining to distribution of the software without specific, written
prior permission.

STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT
OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.

C.2.5 ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTA-

TION
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

C.3 Licences et remerciements pour les logiciels tiers

Cette section est une liste incomplè te mais grandissante de licences et remerciements pour les logiciels tiers incorporé s
dans la distribution de Python.

C.3.1 Mersenne twister

The _random C extension underlying the random module includes code based on a download from [Link]
[Link]/~m-mat/MT/MT2002/[Link]. The following are the verbatim comments from the
original code :

A C-program for MT19937, with initialization improved 2002/1/26.

Coded by Takuji Nishimura and Makoto Matsumoto.

Before using, initialize the state by using init_genrand(seed)

or init_by_array(init_key, key_length).

Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,

All rights reserved.

Redistribution and use in source and binary forms, with or without

(suite sur la page suivante)

C.3. Licences et remerciements pour les logiciels tiers 179

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

3. The names of its contributors may not be used to endorse or promote

products derived from this software without specific prior written
permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Any feedback is very welcome.

[Link]
email: m-mat @ [Link] (remove space)

C.3.2 Interfaces de connexion (sockets)

The socket module uses the functions, getaddrinfo(), and getnameinfo(), which are coded in separate source
files from the WIDE Project, [Link]

Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the project nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
(suite sur la page suivante)

180 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

C.3.3 Interfaces de connexion asynchrones

The [Link] and [Link] modules contain the following notice :

Copyright 1996 by Sam Rushing

All Rights Reserved

Permission to use, copy, modify, and distribute this software and

its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of Sam
Rushing not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

C.3.4 Gestion de témoin (cookie)

Le module [Link] contient la note suivante :

Copyright 2000 by Timothy O'Malley <timo@[Link]>

All Rights Reserved

Permission to use, copy, modify, and distribute this software

and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Timothy O'Malley not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.

Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
(suite sur la page suivante)

C.3. Licences et remerciements pour les logiciels tiers 181

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

C.3.5 Traçage d’exécution

Le module trace contient la note suivante :
portions copyright 2001, Autonomous Zones Industries, Inc., all rights...
err... reserved and offered to the public under the terms of the
Python 2.2 license.
Author: Zooko O'Whielacronx
[Link]
[Link]

Copyright 2000, Mojam Media, Inc., all rights reserved.

Author: Skip Montanaro

Copyright 1999, Bioreason, Inc., all rights reserved.

Author: Andrew Dalke

Copyright 1995-1997, Automatrix, Inc., all rights reserved.

Author: Skip Montanaro

Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.

Permission to use, copy, modify, and distribute this Python software and
its associated documentation for any purpose without fee is hereby
granted, provided that the above copyright notice appears in all copies,
and that both that copyright notice and this permission notice appear in
supporting documentation, and that the name of neither Automatrix,
Bioreason or Mojam Media be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.

C.3.6 Les fonctions UUencode et UUdecode

The uu codec contains the following notice :
Copyright 1994 by Lance Ellinghouse
Cathedral City, California Republic, United States of America.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Lance Ellinghouse
not be used in advertising or publicity pertaining to distribution
of the software without specific, written prior permission.
LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

(suite sur la page suivante)

182 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

Modified by Jack Jansen, CWI, July 1995:
- Use binascii module to do the actual line-by-line conversion
between ascii and binary. This results in a 1000-fold speedup. The C
version is still 5 times faster, though.
- Arguments more compliant with Python standard

C.3.7 Appel de procédures distantes en XML (RPC, pour Remote Procedure Call)
Le module [Link] contient la note suivante :
The XML-RPC client interface is

Copyright (c) 1999-2002 by Secret Labs AB

Copyright (c) 1999-2002 by Fredrik Lundh

By obtaining, using, and/or copying this software and/or its

associated documentation, you agree that you have read, understood,
and will comply with the following terms and conditions:

Permission to use, copy, modify, and distribute this software and

its associated documentation for any purpose and without fee is
hereby granted, provided that the above copyright notice appears in
all copies, and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Secret Labs AB or the author not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.

SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.

C.3.8 test_epoll
The test.test_epoll module contains the following notice :
Copyright (c) 2001-2006 Twisted Matrix Laboratories.

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be

included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
(suite sur la page suivante)

C.3. Licences et remerciements pour les logiciels tiers 183

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

C.3.9 Select kqueue

Le module select contient la note suivante pour l’interface kqueue :
Copyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes
All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

C.3.10 SipHash24
Le fichier Python/pyhash.c contient une implé mentation par Marek Majkowski de l’algorithme SipHash24 de
Dan Bernstein. Il contient la note suivante :
<MIT License>
Copyright (c) 2013 Marek Majkowski <marek@[Link]>

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
</MIT License>

Original location:
[Link]

(suite sur la page suivante)

184 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

Solution inspired by code from:
Samuel Neves (supercop/crypto_auth/siphash24/little)
djb (supercop/crypto_auth/siphash24/little2)
Jean-Philippe Aumasson ([Link]

C.3.11 strtod et dtoa

The file Python/dtoa.c, which supplies C functions dtoa and strtod for conversion of C doubles to and from strings,
is derived from the file of the same name by David M. Gay, currently available from [Link]
20220517033456/[Link] The original file, as retrieved on March 16, 2009, contains the
following copyright and licensing notice :

/****************************************************************
*
* The author of this software is David M. Gay.
*
* Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose without fee is hereby granted, provided that this entire notice
* is included in all copies of any software which is or includes a copy
* or modification of this software and in all copies of the supporting
* documentation for such software.
*
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
* OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
*
***************************************************************/

C.3.12 OpenSSL
The modules hashlib, posix and ssl use the OpenSSL library for added performance if made available by the
operating system. Additionally, the Windows and macOS installers for Python may include a copy of the OpenSSL
libraries, so we include a copy of the OpenSSL license here. For the OpenSSL 3.0 release, and later releases derived
from that, the Apache License v2 applies :
Apache License
Version 2.0, January 2004
[Link]

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by

the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
(suite sur la page suivante)

C.3. Licences et remerciements pour les logiciels tiers 185

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity

exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.

"Object" form shall mean any form resulting from mechanical

transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or

Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object

form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including

the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity

on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of

this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of

this License, each Contributor hereby grants to You a perpetual,
(suite sur la page suivante)

186 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the

Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:

(a) You must give any other recipients of the Work or

Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its

distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.

You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,

(suite sur la page suivante)

C.3. Licences et remerciements pour les logiciels tiers 187

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or

agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,

whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing

the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

C.3.13 expat
The pyexpat extension is built using an included copy of the expat sources unless the build is configured
--with-system-expat :

Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
and Clark Cooper

Permission is hereby granted, free of charge, to any person obtaining

(suite sur la page suivante)

188 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

C.3.14 libffi
The _ctypes C extension underlying the ctypes module is built using an included copy of the libffi sources unless
the build is configured --with-system-libffi :
Copyright (c) 1996-2008 Red Hat, Inc and others.

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

C.3.15 zlib
Le module zlib est compilé en utilisant une copie du code source de zlib si la version de zlib trouvé e sur le systè me
est trop vieille pour ê tre utilisé e :
Copyright (C) 1995-2011 Jean-loup Gailly and Mark Adler

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

(suite sur la page suivante)

C.3. Licences et remerciements pour les logiciels tiers 189

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

Jean-loup Gailly Mark Adler

jloup@[Link] madler@[Link]

C.3.16 cfuhash
L’implé mentation des dictionnaires, utilisé e par le module tracemalloc est basé e sur le projet cfuhash :

Copyright (c) 2005 Don Owens

All rights reserved.

This code is released under the BSD license:

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.

* Neither the name of the author nor the names of its

contributors may be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.

190 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

C.3.17 libmpdec
The _decimal C extension underlying the decimal module is built using an included copy of the libmpdec library
unless the build is configured --with-system-libmpdec :

Copyright (c) 2008-2020 Stefan Krah. All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

C.3.18 Ensemble de tests C14N du W3C

Les tests de C14N version 2.0 du module test (Lib/test/xmltestdata/c14n-20/) proviennent du site du
W3C à l’adresse [Link] et sont distribué s sous licence BSD modifié e :

Copyright (c) 2013 W3C(R) (MIT, ERCIM, Keio, Beihang),

All Rights Reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

* Redistributions of works must retain the original copyright notice,

this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the original copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the W3C nor the names of its contributors may be
used to endorse or promote products derived from this work without
specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
(suite sur la page suivante)

C.3. Licences et remerciements pour les logiciels tiers 191

The Python Language Reference, Version 3.13.7

(suite de la page pré cé dente)

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

C.3.19 mimalloc
MIT License :

Copyright (c) 2018-2021 Microsoft Corporation, Daan Leijen

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

C.3.20 asyncio
Parts of the asyncio module are incorporated from uvloop 0.16, which is distributed under the MIT license :

Copyright (c) 2015-2021 MagicStack Inc. [Link]

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be

included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

192 Annexe C. Histoire et licence

 The Python Language Reference, Version 3.13.7

C.3.21 Global Unbounded Sequences (GUS)

The file Python/qsbr.c is adapted from FreeBSD’s ”Global Unbounded Sequences” safe memory reclamation
scheme in subr_smr.c. The file is distributed under the 2-Clause BSD License :

Copyright (c) 2019,2020 Jeffrey Roberson <jeff@[Link]>

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice unmodified, this list of conditions, and the following
disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

C.3. Licences et remerciements pour les logiciels tiers 193

The Python Language Reference, Version 3.13.7

194 Annexe C. Histoire et licence

 ANNEXE D

Copyright

Python et cette documentation sont :

Copyright © 2001-2024 Python Software Foundation. Tous droits ré servé s.
Copyright © 2000 [Link]. Tous droits ré servé s.
Copyright © 1995-2000 Corporation for National Research Initiatives. Tous droits ré servé s.
Copyright © 1991-1995 Stichting Mathematisch Centrum. Tous droits ré servé s.

Voir Histoire et licence pour des informations complè tes concernant la licence et les permissions.

195
The Python Language Reference, Version 3.13.7

196 Annexe D. Copyright

 Index

Non alphabétique in function calls, 87

..., 155 operator, 89
ellipsis literal, 18, 155 **
''' function definition, 126
string literal, 10 in dictionary displays, 80
. (dot) in function calls, 88
attribute reference, 85 operator, 89
in numeric literal, 15 **=
! (exclamation) augmented assignment, 101
in formatted string literal, 12 *=
- (minus) augmented assignment, 101
binary operator, 90 + (plus)
unary operator, 89 binary operator, 90
' (single quote) unary operator, 89
string literal, 10 +=
! patterns, 119 augmented assignment, 101
" (double quote) , (comma), 78
string literal, 10 argument list, 87
""" expression list, 79, 80, 95, 103, 127
string literal, 10 identifier list, 109
# (hash) import statement, 106
comment, 5 in dictionary displays, 80
source encoding declaration, 6 in target list, 100
% (percent) parameter list, 125
operator, 90 slicing, 86
%= with statement, 116
augmented assignment, 101 / (slash)
& (ampersand) function definition, 126
operator, 91 operator, 90
&= //
augmented assignment, 101 operator, 90
() (parentheses) //=
call, 87 augmented assignment, 101
class definition, 127 /=
function definition, 125 augmented assignment, 101
generator expression, 80 0b
in assignment target list, 100 integer literal, 14
tuple display, 78 0o
* (asterisk) integer literal, 14
function definition, 126 0x
import statement, 107 integer literal, 14
in assignment target list, 100 : (colon)
in expression lists, 95 annotated variable, 102

197
The Python Language Reference, Version 3.13.7

compound statement, 112, 113, 116, 117, 125, escape sequence, 10

127 \N
function annotations, 126 escape sequence, 10
in dictionary expressions, 80 \n
in formatted string literal, 12 escape sequence, 10
lambda expression, 95 \r
slicing, 86 escape sequence, 10
:= (colon equals), 94 \t
; (semicolon), 111 escape sequence, 10
< (less) \U
operator, 91 escape sequence, 10
<< \u
operator, 90 escape sequence, 10
<<= \v
augmented assignment, 101 escape sequence, 10
<= \x
operator, 91 escape sequence, 10
!= ^ (caret)
operator, 91 operator, 91
-= ^=
augmented assignment, 101 augmented assignment, 101
= (equals) _ (underscore)
assignment statement, 100 in numeric literal, 14, 15
class definition, 44 _, identifiers, 9
for help in debugging using string __, identifiers, 9
literals, 12 __abs__() (méthode object), 52
function definition, 126 __add__() (méthode object), 50
in function calls, 87 __aenter__() (méthode object), 57
== __aexit__() (méthode object), 57
operator, 91 __aiter__() (méthode object), 56
-> __all__ (attribut module), 107
function annotations, 126 __all__ (optional module attribute), 107
> (greater) __and__() (méthode object), 50
operator, 91 __anext__() (méthode agen), 84
>= __anext__() (méthode object), 56
operator, 91 __annotations__ (attribut function), 22
>> __annotations__ (attribut module), 27
operator, 90 __annotations__ (attribut type), 28
>>= __annotations__ (class attribute), 28
augmented assignment, 101 __annotations__ (function attribute), 22
>>>, 155 __annotations__ (module attribute), 24
@ (at) __await__() (méthode object), 55
class definition, 128 __bases__ (attribut type), 28
function definition, 125 __bases__ (class attribute), 28
operator, 90 __bool__() (méthode object), 39
[] (square brackets) __bool__() (object method), 49
in assignment target list, 100 __buffer__() (méthode object), 53
list expression, 79 __bytes__() (méthode object), 36
subscription, 86 __cached__ (attribut module), 26
\ (backslash) __cached__ (module attribute), 24
escape sequence, 10 __call__() (méthode object), 48
\\ __call__() (object method), 88
escape sequence, 10 __cause__ (exception attribute), 105
\a __ceil__() (méthode object), 52
escape sequence, 10 __class__ (attribut module), 40
\b __class__ (attribut object), 29
escape sequence, 10 __class__ (instance attribute), 29
\f __class__ (method cell), 45

198 Index
 The Python Language Reference, Version 3.13.7

__class__ (module attribute), 40 __getattribute__() (méthode object), 39

__class_getitem__() (méthode de la classe object), __getitem__() (mapping object method), 34
47 __getitem__() (méthode object), 49
__classcell__ (class namespace entry), 45 __globals__ (attribut function), 22
__closure__ (attribut function), 22 __globals__ (function attribute), 22
__closure__ (function attribute), 22 __gt__() (méthode object), 37
__code__ (attribut function), 22 __hash__() (méthode object), 37
__code__ (function attribute), 22 __iadd__() (méthode object), 51
__complex__() (méthode object), 52 __iand__() (méthode object), 51
__contains__() (méthode object), 50 __ifloordiv__() (méthode object), 51
__context__ (exception attribute), 105 __ilshift__() (méthode object), 51
__debug__, 103 __imatmul__() (méthode object), 51
__defaults__ (attribut function), 22 __imod__() (méthode object), 51
__defaults__ (function attribute), 22 __imul__() (méthode object), 51
__del__() (méthode object), 35 __index__() (méthode object), 52
__delattr__() (méthode object), 39 __init__() (méthode object), 35
__delete__() (méthode object), 41 __init_subclass__() (méthode de la classe object),
__delitem__() (méthode object), 50 43
__dict__ (attribut function), 22 __instancecheck__() (méthode type), 46
__dict__ (attribut module), 27 __int__() (méthode object), 52
__dict__ (attribut object), 29 __invert__() (méthode object), 52
__dict__ (attribut type), 28 __ior__() (méthode object), 51
__dict__ (class attribute), 28 __ipow__() (méthode object), 51
__dict__ (function attribute), 22 __irshift__() (méthode object), 51
__dict__ (instance attribute), 29 __isub__() (méthode object), 51
__dict__ (module attribute), 27 __iter__() (méthode object), 50
__dir__ (module attribute), 40 __itruediv__() (méthode object), 51
__dir__() (méthode module), 40 __ixor__() (méthode object), 51
__dir__() (méthode object), 39 __kwdefaults__ (attribut function), 22
__divmod__() (méthode object), 50 __kwdefaults__ (function attribute), 22
__doc__ (attribut function), 22 __le__() (méthode object), 37
__doc__ (attribut method), 23 __len__() (mapping object method), 39
__doc__ (attribut module), 27 __len__() (méthode object), 49
__doc__ (attribut type), 28 __length_hint__() (méthode object), 49
__doc__ (class attribute), 28 __loader__ (attribut module), 26
__doc__ (function attribute), 22 __loader__ (module attribute), 24
__doc__ (method attribute), 23 __lshift__() (méthode object), 50
__doc__ (module attribute), 24 __lt__() (méthode object), 37
__enter__() (méthode object), 53 __main__
__eq__() (méthode object), 37 module, 60, 135
__exit__() (méthode object), 53 __matmul__() (méthode object), 50
__file__ (attribut module), 26 __missing__() (méthode object), 50
__file__ (module attribute), 24 __mod__() (méthode object), 50
__firstlineno__ (attribut type), 28 __module__ (attribut function), 22
__firstlineno__ (class attribute), 28 __module__ (attribut method), 23
__float__() (méthode object), 52 __module__ (attribut type), 28
__floor__() (méthode object), 52 __module__ (class attribute), 28
__floordiv__() (méthode object), 50 __module__ (function attribute), 22
__format__() (méthode object), 37 __module__ (method attribute), 23
__func__ (attribut method), 23 __mro__ (attribut type), 28
__func__ (method attribute), 23 __mro_entries__() (méthode object), 44
__future__, 161 __mul__() (méthode object), 50
future statement, 108 __name__ (attribut function), 22
__ge__() (méthode object), 37 __name__ (attribut method), 23
__get__() (méthode object), 40 __name__ (attribut module), 25
__getattr__ (module attribute), 40 __name__ (attribut type), 28
__getattr__() (méthode module), 40 __name__ (class attribute), 28
__getattr__() (méthode object), 39 __name__ (function attribute), 22

Index 199
The Python Language Reference, Version 3.13.7

__name__ (method attribute), 23 __xor__() (méthode object), 50

__name__ (module attribute), 24 ``None``
__ne__() (méthode object), 37 object, 18
__neg__() (méthode object), 52 {} (curly brackets)
__new__() (méthode object), 35 dictionary expression, 80
__next__() (méthode generator), 82 in formatted string literal, 12
__objclass__ (attribut object), 41 set expression, 80
__or__() (méthode object), 50 | (vertical bar)
__package__ (attribut module), 25 operator, 91
__package__ (module attribute), 24 |=
__path__ (attribut module), 26 augmented assignment, 101
__path__ (module attribute), 24 ~ (tilde)
__pos__() (méthode object), 52 operator, 89
__pow__() (méthode object), 50
__prepare__ (metaclass method), 45 A
__qualname__ (attribut function), 22 abs
__qualname__ (attribut type), 28 built-in function, 52
__radd__() (méthode object), 51 aclose() (méthode agen), 85
__rand__() (méthode object), 51 addition, 90
__rdivmod__() (méthode object), 51 alias de type, 170
__release_buffer__() (méthode object), 54 and
__repr__() (méthode object), 36 bitwise, 91
__reversed__() (méthode object), 50 operator, 94
__rfloordiv__() (méthode object), 51 annotated
__rlshift__() (méthode object), 51 assignment, 102
__rmatmul__() (méthode object), 51 annotation, 155
__rmod__() (méthode object), 51 annotation de fonction, 161
__rmul__() (méthode object), 51 annotation de variable, 170
__ror__() (méthode object), 51 annotations
__round__() (méthode object), 52 function, 126
__rpow__() (méthode object), 51 anonymous
__rrshift__() (méthode object), 51 function, 95
__rshift__() (méthode object), 50 API provisoire, 167
__rsub__() (méthode object), 51 appelable (callable), 157
__rtruediv__() (méthode object), 51 argument, 155
__rxor__() (méthode object), 51 call semantics, 87
__self__ (attribut method), 23 function, 21
__self__ (method attribute), 23 function definition, 126
__set__() (méthode object), 41 argument nommé, 163
__set_name__() (méthode object), 43 argument positionnel, 167
__setattr__() (méthode object), 39 arithmetic
__setitem__() (méthode object), 49 conversion, 77
__slots__, 168 operation, binary, 89
__spec__ (attribut module), 25 operation, unary, 89
__spec__ (module attribute), 24 array
__static_attributes__ (attribut type), 28 module, 20
__static_attributes__ (class attribute), 28 arrêt de l'interpréteur, 163
__str__() (méthode object), 36 as
__sub__() (méthode object), 50 except clause, 113
__subclasscheck__() (méthode type), 46 import statement, 107
__subclasses__() (méthode type), 29 keyword, 106, 113, 116, 117
__traceback__ (exception attribute), 104 match statement, 117
__truediv__() (méthode object), 50 with statement, 116
__trunc__() (méthode object), 52 AS pattern, OR pattern, capture pattern,
__type_params__ (attribut function), 22 wildcard pattern, 119
__type_params__ (attribut type), 28 ASCII, 4, 10
__type_params__ (class attribute), 28 asend() (méthode agen), 85
__type_params__ (function attribute), 22 assert

200 Index
 The Python Language Reference, Version 3.13.7

statement, 103 backslash character, 6

AssertionError BDFL, 156
exception, 103 binary
assertions arithmetic operation, 89
debugging, 103 bitwise operation, 91
assignment binary literal, 14
annotated, 102 binding
attribute, 100 global name, 109
augmented, 101 name, 59, 100, 106, 107, 125, 127
class attribute, 27 bitwise
class instance attribute, 29 and, 91
expression, 94 operation, binary, 91
slicing, 101 operation, unary, 89
statement, 20, 100 or, 91
subscription, 101 xor, 91
target list, 100 blank line, 6
assignment expression, 94 block, 59
async code, 59
keyword, 128 BNF, 4, 77
async def Boolean
statement, 128 object, 19
async for operation, 94
in comprehensions, 79 break
statement, 129 statement, 106, 112, 115
async with built-in
statement, 129 method, 24
asynchronous generator built-in function
asynchronous iterator, 24 abs, 52
function, 24 bytes, 36
asynchronous-generator call, 88
object, 84 chr, 20
athrow() (méthode agen), 85 compile, 109
atom, 77 complex, 52
attendable (awaitable), 156 divmod, 51
attribut, 156 eval, 109, 136
attribute, 18 exec, 109
assignment, 100 float, 52
assignment, class, 27 hash, 38
assignment, class instance, 29 id, 17
class, 27 int, 52
class instance, 29 len, 19, 21, 49
deletion, 103 object, 24, 88
generic special, 18 open, 29
reference, 85 ord, 20
special, 18 pow, 51
AttributeError print, 37
exception, 85 range, 113
augmented repr, 99
assignment, 101 round, 52
await slice, 34
in comprehensions, 79 type, 17, 44
keyword, 88, 128 built-in method
call, 88
B object, 24, 88
b' builtins
bytes literal, 10 module, 135
b" byte, 20
bytes literal, 10 bytearray, 20

Index 201
The Python Language Reference, Version 3.13.7

bytecode, 29 call, 27, 88

bytes, 20 classe, 157
built-in function, 36 classe mère abstraite, 155
bytes literal, 10 classique
Les paquets, 66
C clause, 111
C, 10 clear() (méthode frame), 33
language, 18, 19, 24, 91 close() (méthode coroutine), 56
call, 87 close() (méthode generator), 83
built-in function, 88 closure variable, 157
built-in method, 88 co_argcount (attribut codeobject), 30
class instance, 88 co_argcount (code object attribute), 29
class object, 27, 88 co_cellvars (attribut codeobject), 30
function, 21, 88 co_cellvars (code object attribute), 29
instance, 48, 88 co_code (attribut codeobject), 30
method, 88 co_code (code object attribute), 29
procedure, 99 co_consts (attribut codeobject), 30
user-defined function, 88 co_consts (code object attribute), 29
callable co_filename (attribut codeobject), 30
object, 21, 87 co_filename (code object attribute), 29
case co_firstlineno (attribut codeobject), 30
keyword, 117 co_firstlineno (code object attribute), 29
match, 117 co_flags (attribut codeobject), 30
case block, 119 co_flags (code object attribute), 29
C-contiguous, 158 co_freevars (attribut codeobject), 30
chaîne de documentation (docstring), 159 co_freevars (code object attribute), 29
chaîne entre triple guillemets, 170 co_kwonlyargcount (attribut codeobject), 30
chaining co_kwonlyargcount (code object attribute), 29
comparisons, 91 co_lines() (méthode codeobject), 31
exception, 105 co_lnotab (attribut codeobject), 30
character, 20, 86 co_lnotab (code object attribute), 29
chargeur, 67, 164 co_name (attribut codeobject), 30
chemin co_name (code object attribute), 29
points d'entrée, 68 co_names (attribut codeobject), 30
chemin des importations, 162 co_names (code object attribute), 29
chercheur, 67, 160 co_nlocals (attribut codeobject), 30
find_spec, 68 co_nlocals (code object attribute), 29
chercheur basé sur les chemins, 167 co_positions() (méthode codeobject), 31
chercheur dans les méta-chemins, 164 co_posonlyargcount (attribut codeobject), 30
chercheur de chemins, 167 co_posonlyargcount (code object attribute), 29
chr co_qualname (attribut codeobject), 30
built-in function, 20 co_qualname (code object attribute), 29
class co_stacksize (attribut codeobject), 30
attribute, 27 co_stacksize (code object attribute), 29
attribute assignment, 27 co_varnames (attribut codeobject), 30
body, 45 co_varnames (code object attribute), 29
constructor, 35 code
definition, 104, 127 block, 59
instance, 29 code intermédiaire (bytecode), 157
name, 127 code object, 29
object, 27, 88, 127 collections
statement, 127 module, 20
class instance comma, 78
attribute, 29 trailing, 95
attribute assignment, 29 command line, 135
call, 88 comment, 5
object, 27, 29, 88 comparison, 91
class object comparisons, 37

202 Index
 The Python Language Reference, Version 3.13.7

chaining, 91 del
compile statement, 35, 103
built-in function, 109 deletion
complex attribute, 103
built-in function, 52 target, 103
number, 19 target list, 103
object, 19 delimiters, 16
complex literal, 14 descripteur, 159
compound destructor, 35, 100
statement, 111 dictionary
comprehensions, 79 comprehensions, 80
dictionary, 80 display, 80
list, 79 object, 21, 27, 38, 80, 86, 101
set, 80 dictionnaire, 159
Conditional dictionnaire en compréhension (ou dictionnaire
expression, 94 en intension), 159
conditional display
expression, 95 dictionary, 80
constant, 10 list, 79
constructor set, 80
class, 35 distribution simple, 169
container, 18, 27 division, 90
context, 158 division entière, 160
context management protocol, 158 divmod
context manager, 52 built-in function, 51
contigu, 158 docstring, 127
continue documentation string, 31
statement, 106, 112, 115 dunder, 159
conversion
arithmetic, 77 E
string, 37, 99 e
coroutine, 55, 81, 158 in numeric literal, 15
function, 24 EAFP, 159
CPython, 158 elif
current context, 158 keyword, 112
Ellipse
D object, 18
dangling else
else, 112 conditional expression, 95
data, 17 dangling, 112
type, 18 keyword, 106, 112, 113, 115
type, immutable, 78 empty
[Link] list, 79
module, 21 tuple, 20, 78
[Link] encodage du système de fichiers et
module, 21 gestionnaire d'erreurs associé,
debugging 160
assertions, 103 encodage régional, 164
decimal literal, 14 encodages de texte, 169
décorateur, 158 encoding declarations (source file), 6
DEDENT token, 7, 112 ensemble en compréhension (ou ensemble en inten-
def sion), 169
statement, 125 entrée de chemin, 167
default environment, 60
parameter value, 126 environnement virtuel, 171
definition error handling, 62
class, 104, 127 errors, 62
function, 104, 125 escape sequence, 10

Index 203
The Python Language Reference, Version 3.13.7

espace de nommage, 165 f_code (attribut frame), 32

Les paquets, 66 f_code (frame attribute), 32
eval f_globals (attribut frame), 32
built-in function, 109, 136 f_globals (frame attribute), 32
evaluation f_lasti (attribut frame), 32
order, 96 f_lasti (frame attribute), 32
exc_info (in module sys), 33 f_lineno (attribut frame), 33
except f_lineno (frame attribute), 32
keyword, 113 f_locals (attribut frame), 32
except_star f_locals (frame attribute), 32
keyword, 114 f_trace (attribut frame), 33
exception, 62, 104 f_trace (frame attribute), 32
AssertionError, 103 f_trace_lines (attribut frame), 33
AttributeError, 85 f_trace_lines (frame attribute), 32
chaining, 105 f_trace_opcodes (attribut frame), 33
GeneratorExit, 83, 85 f_trace_opcodes (frame attribute), 32
handler, 33 False, 19
ImportError, 106 fichier binaire, 156
NameError, 77 fichier texte, 170
raising, 104 finalizer, 35
StopAsyncIteration, 84 finally
StopIteration, 82, 104 keyword, 104, 106, 113, 115
TypeError, 89 find_spec
ValueError, 91 chercheur, 68
ZeroDivisionError, 90 float
exception handler, 62 built-in function, 52
exclusive floating-point
or, 91 number, 19
exec object, 19
built-in function, 109 floating-point literal, 14
execution fonction, 160
frame, 59, 127 fonction clé, 163
restricted, 62 fonction coroutine, 158
stack, 33 fonction de rappel (callback), 157
execution model, 59 fonction générique, 161
expression, 77, 160 for
assignment, 94 in comprehensions, 79
Conditional, 94 statement, 106, 112
conditional, 95 form
generator, 80 lambda, 95
lambda, 95, 127 format() (built-in function)
list, 95, 99 __str__() (object method), 36
statement, 99 formatted string literal, 12
yield, 81 Fortran contiguous, 158
expression génératrice, 161 frame
extension execution, 59, 127
module, 18 object, 32
free
F variable, 60
f' free threading, 160
formatted string literal, 10 free variable, 160
f" from
formatted string literal, 10 import statement, 59, 107
f-string, 160 keyword, 81, 106
f_back (attribut frame), 32 yield from expression, 82
f_back (frame attribute), 32 frozenset
f_builtins (attribut frame), 32 object, 21
f_builtins (frame attribute), 32 fstring, 12

204 Index
 The Python Language Reference, Version 3.13.7

f-string, 12 identity of an object, 17

function IDLE, 162
annotations, 126 if
anonymous, 95 conditional expression, 95
argument, 21 in comprehensions, 79
call, 21, 88 keyword, 117
call, user-defined, 88 statement, 112
definition, 104, 125 imaginary literal, 14
generator, 81, 104 immortal, 162
name, 125 immuable, 162
object, 22, 24, 88, 125 immutable
user-defined, 22 data type, 78
future object, 20, 78, 80
statement, 108 immutable object, 17
immutable sequence
G object, 20
garbage collection, 17 immutable types
générateur, 161 subclassing, 35
générateur asynchrone, 156 import
generator statement, 24, 106
expression, 80 importateur, 162
function, 23, 81, 104 importation, 65, 162
iterator, 23, 104 points d'entrée, 68
object, 31, 80, 82 ImportError
GeneratorExit exception, 106
exception, 83, 85 in
generic keyword, 112
special attribute, 18 operator, 94
gestionnaire de contexte, 158 inclusive
gestionnaire de contexte asynchrone, 156 or, 91
GIL, 162 INDENT token, 7
global indentation, 7
name binding, 109 index operation, 19
namespace, 22 indication de type, 170
statement, 103, 109 indices() (méthode slice), 34
grammar, 4 inheritance, 127
grouping, 7 input, 136
guard, 119 instance
call, 48, 88
H class, 29
hachable, 162 object, 27, 29, 88
handle an exception, 62 instruction, 169
handler int
exception, 33 built-in function, 52
hash integer, 20
built-in function, 38 object, 19
hash character, 5 representation, 19
hashable, 80 integer literal, 14
hexadecimal literal, 14 interactif, 162
hierarchy interactive mode, 135
type, 18 internal type, 29
interpolated string literal, 12
I interprété, 163
interpreter, 135
id
inversion, 89
built-in function, 17
invocation, 21
identifier, 8, 77
io
identity
module, 29
test, 94

Index 205
The Python Language Reference, Version 3.13.7

irrefutable case block, 119 espace de nommage, 66

is portion, 66
operator, 94 lexical analysis, 5
is not lexical analyzer, 164
operator, 94 lexical definitions, 4
item line continuation, 6
sequence, 86 line joining, 5, 6
string, 86 line structure, 5
item selection, 19 list
iterable assignment, target, 100
unpacking, 95 comprehensions, 79
itérable, 163 deletion target, 103
itérable asynchrone, 156 display, 79
itérateur, 163 empty, 79
itérateur asynchrone, 156 expression, 95, 99
itérateur de générateur, 161 object, 20, 79, 85, 86, 101
itérateur de générateur asynchrone, 156 target, 100, 112
liste, 164
J liste en compréhension (ou liste en intension), 164
j literal, 10, 78
in numeric literal, 15 logical line, 5
Java loop
language, 19 statement, 106, 112
loop control
K target, 106
key, 80
key/value pair, 80
M
keyword, 9 machine virtuelle, 171
as, 106, 113, 116, 117 magic
async, 128 méthode, 164
await, 88, 128 makefile() (socket method), 29
case, 117 mangling
elif, 112 name, 77
else, 106, 112, 113, 115 mapping
except, 113 object, 21, 29, 86, 101
except_star, 114 match
finally, 104, 106, 113, 115 case, 117
from, 81, 106 statement, 117
if, 117 matrix multiplication, 90
in, 112 membership
yield, 81 test, 94
méta
L points d'entrée, 68
lambda, 163 metaclass, 44
expression, 95, 127 metaclass hint, 44
form, 95 métaclasse, 164
language méta-points d'entrée d'importation, 68
C, 18, 19, 24, 91 method
Java, 19 built-in, 24
last_traceback (in module sys), 33 call, 88
LBYL, 164 object, 23, 24, 88
le chercheur dans *path*, 72 user-defined, 23
Le zen de Python, 171 méthode, 165
leading whitespace, 7 magic, 164
len special, 169
built-in function, 19, 21, 49 méthode magique, 164
Les paquets, 66 méthode spéciale, 169
classique, 66 minus, 89

206 Index
 The Python Language Reference, Version 3.13.7

module, 165 object, 18

__main__, 60, 135 nouvelle classe, 166
array, 20 null
builtins, 135 operation, 103
collections, 20 number, 14
[Link], 21 complex, 19
[Link], 21 floating-point, 19
extension, 18 numeric
importing, 106 object, 19, 29
io, 29 numeric literal, 14
namespace, 24
object, 24, 85 O
sys, 114, 135 object, 17
module d'extension, 160 ``None``, 18
modulo, 90 asynchronous-generator, 84
MRO, 165 Boolean, 19
mro() (méthode type), 28 built-in function, 24, 88
multiplication, 89 built-in method, 24, 88
mutable, 165 callable, 21, 87
object, 20, 100, 101 class, 27, 88, 127
mutable object, 17 class instance, 27, 29, 88
mutable sequence code, 29
object, 20 complex, 19
dictionary, 21, 27, 38, 80, 86, 101
N Ellipse, 18
n-uplet nommé, 165 floating-point, 19
name, 8, 59, 77 frame, 32
binding, 59, 100, 106, 107, 125, 127 frozenset, 21
binding, global, 109 function, 22, 24, 88, 125
class, 127 generator, 31, 80, 82
function, 125 immutable, 20, 78, 80
mangling, 77 immutable sequence, 20
rebinding, 100 instance, 27, 29, 88
unbinding, 103 integer, 19
named expression, 94 list, 20, 79, 85, 86, 101
NameError mapping, 21, 29, 86, 101
exception, 77 method, 23, 24, 88
NameError (built-in exception), 60 module, 24, 85
names mutable, 20, 100, 101
private, 77 mutable sequence, 20
namespace, 59 None, 99
global, 22 NotImplemented, 18
module, 24 numeric, 19, 29
negation, 89 sequence, 19, 29, 86, 94, 101, 112
NEWLINE token, 5, 112 set, 21, 80
nom qualifié, 168 set type, 21
nombre complexe, 158 slice, 49
nombre de références, 168 string, 86
None traceback, 33, 104, 114
object, 99 tuple, 20, 86, 95
nonlocal user-defined function, 22, 88, 125
statement, 109 user-defined method, 23
not object.__match_args__ (variable de base), 53
operator, 94 object.__slots__ (variable de base), 42
not in objet, 166
operator, 94 objet fichier, 160
notation, 4 objet fichier-compatible, 160
NotImplemented objet octet-compatible, 157

Index 207
The Python Language Reference, Version 3.13.7

objet simili-chemin, 167 overloading

octal literal, 14 operator, 34
open
built-in function, 29 P
operation paquet, 166
binary arithmetic, 89 paquet classique, 168
binary bitwise, 91 paquet provisoire, 167
Boolean, 94 paquet-espace de nommage, 165
null, 103 parameter
power, 89 call semantics, 87
shifting, 90 function definition, 125
unary arithmetic, 89 value, default, 126
unary bitwise, 89 paramètre, 166
operator parenthesized form, 78
- (minus), 89, 90 parser, 5
% (percent), 90 pass
& (ampersand), 91 statement, 103
* (asterisk), 89 pattern matching, 117
**, 89 PEP, 167
+ (plus), 89, 90 physical line, 5, 6, 10
/ (slash), 90 plus, 89
//, 90 point d'entrée pour la recherche dans
< (less), 91 path, 167
<<, 90 points d'entrée
<=, 91 chemin, 68
!=, 91 importation, 68
==, 91 méta, 68
> (greater), 91 points d'entrée de chemin de fichier, 68
>=, 91 points d'entrée d'importation, 68
>>, 90 popen() (in module os), 29
@ (at), 90 portée imbriquée, 166
^ (caret), 91 portion, 167
| (vertical bar), 91 Les paquets, 66
~ (tilde), 89 pow
and, 94 built-in function, 51
in, 94 power
is, 94 operation, 89
is not, 94 precedence
not, 94 operator, 96
not in, 94 primary, 85
or, 94 print
overloading, 34 built-in function, 37
precedence, 96 print() (built-in function)
ternary, 95 __str__() (object method), 36
operators, 15 private
optimized scope, 166 names, 77
or procedure
bitwise, 91 call, 99
exclusive, 91 program, 135
inclusive, 91 pyc utilisant le hachage, 162
operator, 94 Python 3000, 167
ord Python Enhancement Proposals
built-in function, 20 PEP 1, 167
order PEP 8, 92
evaluation, 96 PEP 236, 108
ordre de résolution des méthodes, 165 PEP 252, 41
output, 99 PEP 255, 82
standard, 99 PEP 278, 170

208 Index
 The Python Language Reference, Version 3.13.7

PEP 302, 65, 76, 164 PYTHONPATH, 73

PEP 308, 95
PEP 318, 127, 128 R
PEP 328, 76, 160 r'
PEP 338, 76 raw string literal, 10
PEP 342, 82 r"
PEP 343, 46, 53, 117, 158 raw string literal, 10
PEP 362, 156, 166 raise
PEP 366, 25, 76 statement, 104
PEP 380, 82 raise an exception, 62
PEP 411, 167 raising
PEP 414, 10 exception, 104
PEP 420, 65, 66, 71, 76, 165, 167 ramasse-miettes, 161
PEP 443, 161 range
PEP 448, 80, 88, 95 built-in function, 113
PEP 451, 76 raw string, 10
PEP 483, 161 rebinding
PEP 484, 102, 127, 155, 161, 170, 171 name, 100
PEP 492, 55, 82, 130, 156, 158 reference
PEP 498, 14, 160 attribute, 85
PEP 519, 167 reference counting, 17
PEP 525, 82, 156 référence empruntée, 157
PEP 526, 102, 127, 155, 171 référence forte, 169
PEP 530, 79 relative
PEP 560, 44, 48 import, 107
PEP 562, 40 REPL, 168
PEP 563, 108, 127 replace() (méthode codeobject), 32
PEP 570, 126 repr
PEP 572, 80, 95, 121 built-in function, 99
PEP 585, 161 repr() (built-in function)
PEP 614, 126, 128 __repr__() (object method), 36
PEP 617, 137 representation
PEP 626, 32 integer, 19
PEP 634, 53, 118, 125 reserved word, 9
PEP 636, 118, 125 restricted
PEP 646, 86, 95, 127 execution, 62
PEP 649, 61 retours à la ligne universels, 170
PEP 683, 162 return
PEP 688, 54 statement, 104, 115
PEP 695, 61, 110 round
PEP 696, 61, 130 built-in function, 52
PEP 703, 160, 162
PEP 3104, 109 S
PEP 3107, 127 scope, 59, 60
PEP 3115, 45, 128 send() (méthode coroutine), 56
PEP 3116, 170 send() (méthode generator), 82
PEP 3119, 46 sequence
PEP 3120, 5 item, 86
PEP 3129, 127, 128 object, 19, 29, 86, 94, 101, 112
PEP 3131, 8 séquence, 168
PEP 3132, 101 set
PEP 3135, 46 comprehensions, 80
PEP 3147, 26 display, 80
PEP 3155, 168 object, 21, 80
PYTHON_GIL, 162 set type
PYTHONHASHSEED, 38 object, 21
Pythonique, 167 shifting
PYTHONNODEBUGRANGES, 31 operation, 90

Index 209
The Python Language Reference, Version 3.13.7

simple yield, 104

statement, 99 statement grouping, 7
singleton static type checker, 169
tuple, 20 stderr (in module sys), 29
slice, 86 stdin (in module sys), 29
built-in function, 34 stdio, 29
object, 49 stdlib, 169
slicing, 20, 86 stdout (in module sys), 29
assignment, 101 step (slice object attribute), 34, 86
soft deprecated, 169 stop (slice object attribute), 34, 86
soft keyword, 9 StopAsyncIteration
source character set, 6 exception, 84
space, 7 StopIteration
special exception, 82, 104
attribute, 18 string
attribute, generic, 18 __format__() (object method), 37
méthode, 169 __str__() (object method), 36
spécificateur de module, 67, 165 conversion, 37, 99
stack formatted literal, 12
execution, 33 immutable sequences, 20
trace, 33 interpolated literal, 12
standard item, 86
output, 99 object, 86
Standard C, 10 string literal, 10
standard input, 135 subclassing
standard library, 169 immutable types, 35
start (slice object attribute), 34, 86 subscription, 1921, 86
statement assignment, 101
assert, 103 subtraction, 90
assignment, 20, 100 suite, 111
assignment, annotated, 102 syntax, 4
assignment, augmented, 101 sys
async def, 128 module, 114, 135
async for, 129 sys.exc_info, 33
async with, 129 [Link], 33
break, 106, 112, 115 sys.last_traceback, 33
class, 127 sys.meta_path, 68
compound, 111 [Link], 67
continue, 106, 112, 115 [Link], 73
def, 125 sys.path_hooks, 73
del, 35, 103 sys.path_importer_cache, 73
expression, 99 [Link], 29
for, 106, 112 [Link], 29
future, 108 [Link], 29
global, 103, 109 SystemExit (built-in exception), 63
if, 112
import, 24, 106 T
loop, 106, 112 tab, 7
match, 117 tableau de correspondances (mapping en an-
nonlocal, 109 glais), 164
pass, 103 target, 100
raise, 104 deletion, 103
return, 104, 115 list, 100, 112
simple, 99 list assignment, 100
try, 33, 113 list, deletion, 103
type, 109 loop control, 106
while, 106, 112 tb_frame (attribut traceback), 34
with, 52, 116 tb_frame (traceback attribute), 33

210 Index
 The Python Language Reference, Version 3.13.7

tb_lasti (attribut traceback), 34 unpacking

tb_lasti (traceback attribute), 33 dictionary, 80
tb_lineno (attribut traceback), 34 in function calls, 87
tb_lineno (traceback attribute), 33 iterable, 95
tb_next (attribut traceback), 34 unreachable object, 17
tb_next (traceback attribute), 34 unrecognized escape sequence, 11
termination model, 63 user-defined
ternary function, 22
operator, 95 function call, 88
test method, 23
identity, 94 user-defined function
membership, 94 object, 22, 88, 125
throw() (méthode coroutine), 56 user-defined method
throw() (méthode generator), 83 object, 23
token, 5, 170
trace V
stack, 33 value, 80
traceback default parameter, 126
object, 33, 104, 114 value of an object, 17
trailing ValueError
comma, 95 exception, 91
tranche, 169 values
triple-quoted string, 10 writing, 99
True, 19 variable
try free, 60
statement, 33, 113 variable de classe, 157
tuple variable de contexte, 158
empty, 20, 78 variable d'environnement
object, 20, 86, 95 PYTHON_GIL, 162
singleton, 20 PYTHONHASHSEED, 38
typage canard (duck-typing), 159 PYTHONNODEBUGRANGES, 31
type, 18, 170 PYTHONPATH, 73
built-in function, 17, 44 verrou global de l'interpréteur, 162
data, 18 vue de dictionnaire, 159
hierarchy, 18
immutable data, 78 W
statement, 109 walrus operator, 94, 171
type générique, 161 while
type of an object, 17 statement, 106, 112
type parameters, 130 Windows, 135
TypeError with
exception, 89 statement, 52, 116
types, internal, 29 writing
values, 99
U X
u'
xor
string literal, 10
bitwise, 91
u"
string literal, 10 Y
unary
yield
arithmetic operation, 89
examples, 83
bitwise operation, 89
expression, 81
unbinding
keyword, 81
name, 103
statement, 104
UnboundLocalError, 60
Unicode, 20 Z
Unicode Consortium, 10 ZeroDivisionError
UNIX, 135 exception, 90

Index 211