# 3. Modèle de données

## 3.1. Objets, valeurs et types

Objects are Python's abstraction for data. All data in a Python program is represented by objects or by relations between objects. Even code is represented by objects.

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 optionnelle, 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).

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 conteneurs, 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 Implémentation des opérations arithmétiques pour davantage de détails.

Modifié dans la version 3.9: Evaluating `NotImplemented` in a boolean context was deprecated.

Modifié dans la version 3.14: Evaluating `NotImplemented` in a boolean context now raises a `TypeError`. It previously evaluated to `True` and emitted a `DeprecationWarning` since Python 3.9.

### 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.

### 3.2.4. `numbers.Number`

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:

#### 3.2.4.1. `numbers.Integral`

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.

#### 3.2.4.2. `numbers.Real` (`float`)

These represent machine-level double precision floating-point numbers. You are at the mercy of the underlying machine 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.

#### 3.2.4.3. `numbers.Complex` (`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 `z.real` and `z.imag`.

### 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 adding the sequence length. For example, `a[-2]` equals `a[n-2]`, the second to last item of sequence a with length `n`.

The resulting value must be a nonnegative integer less than the number of items in the sequence. If it is not, an `IndexError` is raised.

Sequences also support slicing: `a[start:stop]` selects all items with index k such that start `<=` k `<` stop. When used as an expression, a slice is a sequence of the same type. The comment above about negative subscripts also applies to negative slice positions. Note that no error is raised if a slice position is less than zero or larger than the length of the sequence.

If start is missing or `None`, slicing behaves as if start was zero. If stop is missing or `None`, slicing behaves as if stop was equal to the length of the sequence.

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é :

#### 3.2.5.1. 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 (`str`) is a sequence of values that represent characters, or more formally, Unicode code points. All the code points in the range `0` to `0x10FFFF` can be represented in a string.

  Python doesn't have a dedicated character 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` to `0x10FFFF`; `chr()` converts an integer in the range `0` to `0x10FFFF` to the corresponding length `1` string object. `str.encode()` can be used to convert a `str` to `bytes` using the given text encoding, and `bytes.decode()` can be used to achieve the opposite.

n-uplets (tuples en anglais)

  The items of a `tuple` are arbitrary Python objects. Tuples of two or more items are formed by comma-separated lists of expressions. A tuple of one item (a 'singleton') can be formed by affixing a comma to an expression (an expression by itself does not create a tuple, since parentheses must be usable for grouping of expressions). An empty tuple can be formed by an empty pair of parentheses.

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.

#### 3.2.5.2. 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`.

### 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 doublons 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 dictionnaires. 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

  These represent a mutable set. They are created by the built-in `set()` constructor and can be modified afterwards by several methods, such as `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 :

#### 3.2.7.1. 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 `dbm.ndbm` et `dbm.gnu` 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 à Python 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.8.1. 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.

##### 3.2.8.1.1. Special read-only attributes

Attribut | Signification
--- | ---
function.__builtins__ | A reference to the `dictionary` that holds the function's builtins namespace. Ajouté dans la version 3.10.
function.__globals__ | A reference to the `dictionary` that holds the function's global variables -- the global namespace of the module in which the function was defined.
function.__closure__ | `None` or a `tuple` of cells that contain bindings for the 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.

##### 3.2.8.1.2. Special writable attributes

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

Attribut | Signification
--- | ---
function.__doc__ | The function's documentation string, or `None` if unavailable.
function.__name__ | The function's name. See also: `__name__ attributes`.
function.__qualname__ | The function's qualified name. See also: `__qualname__ attributes`. Ajouté dans la version 3.3.
function.__module__ | Nom du module où la fonction est définie ou `None` si ce nom n'est pas disponible.
function.__defaults__ | A `tuple` containing default parameter values for those parameters that have defaults, or `None` if no parameters have a default value.
function.__code__ | The code object representing the compiled function body.
function.__dict__ | The namespace supporting arbitrary function attributes. See also: `__dict__ attributes`.
function.__annotations__ | A `dictionary` containing annotations of parameters. The keys of the dictionary are the parameter names, and `'return'` for the return annotation, if provided. See also: `object.__annotations__`. Modifié dans la version 3.14: Annotations are now lazily evaluated. See PEP 649.
function.__annotate__ | The annotate function for this function, or `None` if the function has no annotations. See `object.__annotate__`. Ajouté dans la version 3.14.
function.__kwdefaults__ | A `dictionary` containing defaults for keyword-only parameters.
function.__type_params__ | A `tuple` containing the type parameters of a generic function. Ajouté dans la version 3.12.

Function objects also support getting and setting arbitrary attributes, which can be used, for example, to attach metadata 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).

#### 3.2.8.2. 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:

method.__self__ | Refers to the class instance object to which the method is bound
method.__func__ | Refers to the original function object
method.__doc__ | The method's documentation (same as `method.__func__.__doc__`). A `string` if the original function had a docstring, else `None`.
method.__name__ | The name of the method (same as `method.__func__.__name__`)
method.__module__ | The name of the module the method was defined in, or `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 method.

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.

#### 3.2.8.3. 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` 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.

#### 3.2.8.4. 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.

#### 3.2.8.5. Fonctions génératrices asynchrones

Une fonction ou une méthode définie avec `async def` et qui utilise l'instruction `yield` est appelée fonction génératrice 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.

#### 3.2.8.6. 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__`.

#### 3.2.8.7. 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 `alist.append()`, 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`.)

#### 3.2.8.8. 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.

#### 3.2.8.9. 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`.

#### 3.2.9.1. 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 `importlib.util.module_from_spec()`, which will set the various import-controlled attributes to appropriate values. It's also possible to use the `types.ModuleType` 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 instead 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 `types.ModuleType` constructor; use `importlib.util.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 deprecated.

  Modifié dans la version 3.4: This attribute now defaults to `None` for modules created dynamically using the `types.ModuleType` 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.

  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 `types.ModuleType` constructor; use `importlib.util.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 `types.ModuleType` 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.

#### 3.2.9.2. 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__

  A dictionary containing variable annotations collected during module body execution. For best practices on working with `__annotations__`, see `annotationlib`.

  Modifié dans la version 3.14: Annotations are now lazily evaluated. See PEP 649.

module.__annotate__

  The annotate function for this module, or `None` if the module has no annotations. See also: `__annotate__` attributes.

  Ajouté dans la version 3.14.

#### 3.2.9.3. 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 The Python 2.3 Method Resolution Order.

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.10.1. Special attributes

Attribut | Signification
--- | ---
type.__name__ | The class's name. See also: `__name__ attributes`.
type.__qualname__ | The class's qualified name. See also: `__qualname__ attributes`.
type.__module__ | Nom du module où la classe a été définie.
type.__dict__ | A `mapping proxy` providing a read-only view of the class's namespace. See also: `__dict__ attributes`.
type.__bases__ | A `tuple` containing the class's bases. In most cases, for a class defined as `class X(A, B, C)`, `X.__bases__` will be exactly equal to `(A, B, C)`.
type.__base__ | Particularité de l'implémentation CPython : The single base class in the inheritance chain that is responsible for the memory layout of instances. This attribute corresponds to `tp_base` at the C level.
type.__doc__ | The class's documentation string, or `None` if undefined. Not inherited by subclasses.
type.__annotations__ | A dictionary containing variable annotations collected during class body execution. See also: `__annotations__ attributes`. For best practices on working with `__annotations__`, please see `annotationlib`. Use `annotationlib.get_annotations()` instead of accessing this attribute directly. Avertissement Accessing the `__annotations__` attribute directly on a class object may return annotations for the wrong class, specifically in certain cases where the class, its base class, or a metaclass is defined under `from __future__ import annotations`. See 749 for details. This attribute does not exist on certain builtin classes. On user-defined classes without `__annotations__`, it is an empty dictionary. Modifié dans la version 3.14: Annotations are now lazily evaluated. See PEP 649.
type.__annotate__() | The annotate function for this class, or `None` if the class has no annotations. See also: `__annotate__ attributes`. Ajouté dans la version 3.14.
type.__type_params__ | A `tuple` containing the type parameters of a generic class. Ajouté dans la version 3.12.
type.__static_attributes__ | A `tuple` containing names of attributes of this class which are assigned through `self.X` from any function in its body. Ajouté dans la version 3.13.
type.__firstlineno__ | The line number of the first line of the class definition, including decorators. Setting the `__module__` attribute removes the `__firstlineno__` item from the type's dictionary. Ajouté dans la version 3.13.
type.__mro__ | The `tuple` of classes that are considered when looking for base classes during method resolution.

#### 3.2.10.2. Special methods

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

type.mro()

  This method can be overridden by a metaclass to customize the method resolution order for its instances. It is 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.

#### 3.2.11.1. 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 fonction native `open()` et aussi `os.popen()`, `os.fdopen()` ou la méthode `makefile()` des objets connecteurs (et sûrement d'autres fonctions ou méthodes fournies par les modules d'extensions).

File objects implement common methods, listed below, to simplify usage in generic code. They are expected to be Gestionnaire de contexte With.

Les objets `sys.stdin`, `sys.stdout` et `sys.stderr` 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 `io.TextIOBase`.

file.read(size=-1, /)

  Retrieve up to size data from the file. As a convenience if size is unspecified or -1 retrieve all data available.

file.write(data, /)

  Store data to the file.

file.close()

  Flush any buffers and close the underlying file.

### 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é.

#### 3.2.13.1. 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.13.1.1. Special read-only attributes

codeobject.co_name | The function name
codeobject.co_qualname | The fully qualified function name Ajouté dans la version 3.11.
codeobject.co_argcount | The total number of positional parameters (including positional-only parameters and parameters with default values) that the function has
codeobject.co_posonlyargcount | The number of positional-only parameters (including arguments with default values) that the function has
codeobject.co_kwonlyargcount | The number of keyword-only parameters (including arguments with default values) that the function has
codeobject.co_nlocals | The number of local variables used by the function (including parameters)
codeobject.co_varnames | A `tuple` containing the names of the local variables in the function (starting with the parameter names)
codeobject.co_cellvars | A `tuple` containing the names of local variables that are referenced from at least one nested scope inside the function
codeobject.co_freevars | A `tuple` containing the names of free (closure) variables that a nested scope references in an outer scope. See also `function.__closure__`. Note: references to global and builtin names are not included.
codeobject.co_code | A string representing the sequence of bytecode instructions in the function
codeobject.co_consts | A `tuple` containing the literals used by the bytecode in the function
codeobject.co_names | A `tuple` containing the names used by the bytecode in the function
codeobject.co_filename | The name of the file from which the code was compiled
codeobject.co_firstlineno | The line number of the first line of the function
codeobject.co_lnotab | A string encoding the mapping from bytecode offsets 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.
codeobject.co_stacksize | The required stack size of the code object
codeobject.co_flags | An `integer` encoding a number of flags for the interpreter.

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 Bit d'option des objets code 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 and has a docstring, the `CO_HAS_DOCSTRING` bit is set in `co_flags` and the first item in `co_consts` is the docstring of the function.

##### 3.2.13.1.2. 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 `tuple`s 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 `tuple`s, 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.

  Voir aussi

  PEP 626 - Precise line numbers for debugging and other tools.

    The PEP that introduced the `co_lines()` method.

codeobject.replace(**kwargs)

  Return a copy of the code object with new values for the specified fields.

  Code objects are also supported by the generic function `copy.replace()`.

  Ajouté dans la version 3.8.

#### 3.2.13.2. Objets cadres

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

##### 3.2.13.2.1. Special read-only attributes

frame.f_back | Points to the previous stack frame (towards the caller), or `None` if this is the bottom stack frame
frame.f_code | The code object being executed in this frame. Accessing this attribute raises an auditing event `object.__getattr__` with arguments `obj` and `"f_code"`.
frame.f_locals | The mapping used by the frame to look up local variables. 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 optimized scopes.
frame.f_globals | The dictionary used by the frame to look up global variables
frame.f_builtins | The dictionary used by the frame to look up built-in (intrinsic) names
frame.f_lasti | The "precise instruction" of the frame object (this is an index into the bytecode string of the code object)
frame.f_generator | The generator or coroutine object that owns this frame, or `None` if the frame is a normal function. Ajouté dans la version 3.14.

##### 3.2.13.2.2. Special writable attributes

frame.f_trace | If not `None`, this is a function called for various events during code execution (this is used by debuggers). Normally an event is triggered for each new source line (see `f_trace_lines`).
frame.f_trace_lines | Set this attribute to `False` to disable triggering a tracing event for each source line.
frame.f_trace_opcodes | Set this attribute to `True` to allow per-opcode events 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.
frame.f_lineno | The current line number of the frame -- writing to this from within a trace function jumps to the given line (only for the bottom-most frame). A debugger can implement a Jump command (aka Set Next Statement) by writing to this attribute.

##### 3.2.13.2.3. Frame object methods

Les objets cadres comprennent une méthode :

frame.clear()

  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).

#### 3.2.13.3. 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 `types.TracebackType`.

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:

traceback.tb_frame | Points to the execution frame of the current level. Accessing this attribute raises an auditing event `object.__getattr__` with arguments `obj` and `"tb_frame"`.
traceback.tb_lineno | Gives the line number where the exception occurred
traceback.tb_lasti | Indicates the "precise instruction".

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 exception occurred), or `None` if there is no next level.

  Modifié dans la version 3.7: This attribute is now writable

#### 3.2.13.4. 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 :

slice.indices(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.

#### 3.2.13.5. 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()`.

#### 3.2.13.6. 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 de cette classe, alors `x[i]` est globalement équivalent à `type(x).__getitem__(x, i)`. Sauf lorsque c'est mentionné, 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].

When implementing a class that emulates any built-in type, it is important that the emulation only be implemented to the degree that it makes sense for the object being modelled. For example, some sequences may work well with retrieval of individual elements, but extracting a slice may not make sense. (One example of this is the NodeList interface in the W3C's Document Object Model.)

### 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 instance 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 arguments 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 (improprement) 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. `weakref.finalize` provides a straightforward way to register a cleanup function to be called when an object 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.

  Il est possible qu'un cycle de référence empêche le compteur de références d'un objet d'atteindre zéro. Dans ce cas, le cycle sera ultérieurement détecté et supprimé par le ramasse-miettes. Une cause fréquente de cycle de références est lorsqu'une exception a été interceptée dans une variable locale. Les paramètres locaux de la trame font ensuite référence à l'exception, qui fait référence à sa propre trace d'appels, qui fait référence aux paramètres locaux de toutes les cadres capturés dans la trace d'appels.

  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 `sys.stderr`. En particulier :

  - `__del__()` peut être invoquée quand du code arbitraire est en cours d'exécution, et ce dans n'importe 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 unambiguous. 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 expression 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 `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 `str.format()`. 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 formatage 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 Format specification mini-language 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 support 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.

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((self.name, self.nick, self.color))

  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émentation 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__()` implicitement 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, collections.abc.Hashable)`.

  Si une classe qui surcharge `__eq__()` a besoin de conserver l'implémentation de `__hash__()` de la classe parente, 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, collections.abc.Hashable)`.

  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 https://ocert.org/advisories/ocert-2011-003.html 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`.

  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, suppression de `x.name`) 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 arguments `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 obj.name` 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`.

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.

#### 3.3.2.1. 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 accessible 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 `types.ModuleType`. 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)

    sys.modules[__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.

#### 3.3.2.2. 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.

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).

#### 3.3.2.3. 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 dictionnaire 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é.

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.

Python methods (including those decorated with `@staticmethod` and `@classmethod`) are implemented as non-data descriptors. Accordingly, instances can redefine and override methods. This allows individual instances to acquire behaviors that differ from other instances of the same class.

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é.

#### 3.3.2.4. 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éfinition 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.

- Une `TypeError` est levée si un __slot__ non vide est défini pour une classe dérivée des `types natifs à longueur variable` tels que `int`, `bytes` et `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 `inspect.getdoc()` 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.

### 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 passé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.

When a class is created, `type.__new__()` scans the class variables and makes callbacks to those with a `__set_name__()` hook.

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.3.1. 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éé.

#### 3.3.3.2. Résolution des entrées MRO

object.__mro_entries__(self, bases)

  Si une classe mère qui apparaît dans la définition d'une classe n'est pas une instance de `type`, alors Python cherche une méthode `__mro_entries__()` dans cette classe mère. S'il la trouve, au moment de la création de la classe, la classe mère est remplacée par le résultat de l'appel à `__mro_entries__()`. Cette méthode est appelée avec le n-uplet des classes mères originales passé au paramètre bases. Cette méthode doit renvoyer un n-uplet de classes qui seront utilisées à la place de la classe mère. Le n-uplet renvoyé peut être vide : dans ce cas la classe mère originale est ignorée.

Voir aussi

`types.resolve_bases()`

  Résout dynamiquement les classes mères qui ne sont pas des instances de `type`.

`types.get_original_bases()`

  Retrieve a class's "original bases" prior to modifications by `__mro_entries__()`.

PEP 560

  Prise en charge native du module typing et des types génériques

#### 3.3.3.3. 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`.

#### 3.3.3.4. 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

#### 3.3.3.5. Exécution du corps de la classe

Le corps de la classe est exécuté (approximativement) avec `exec(body, globals(), namespace)`. La principale 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.

#### 3.3.3.6. 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.

Voir aussi

PEP 3135 — Nouvelle méthode super

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

#### 3.3.3.7. 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ération, 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 `abc.ABCMeta` implémente ces méthodes pour autoriser l'ajout de classes de base abstraites (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

Génériques, Types génériques définis par l'utilisateur et classe `typing.Generic (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.

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.

  When defined on a class, `__class_getitem__()` is automatically a class method. As such, there is no need for it to be decorated with `@classmethod` when it is defined.

#### 3.3.5.1. 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 implémente déjà `__class_getitem__()`, ou hériter de `typing.Generic`, 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 bibliothè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.

#### 3.3.5.2. __class_getitem__ contre __getitem__

D'habitude, la sélection 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__()` :

    >>> # 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 'types.GenericAlias'>

Cependant, si une classe a une métaclasse particularisée qui définit `__getitem__()`, la sélection d'indices 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 'enum.EnumMeta'>
    >>> # EnumMeta defines __getitem__,
    >>> # so __class_getitem__ is not called,
    >>> # and the result is not a GenericAlias object:
    >>> Menu['SPAM']
    <Menu.SPAM: '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ù une sélection d'indices 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 `collections.abc` 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 methods `append()`, `clear()`, `count()`, `extend()`, `index()`, `insert()`, `pop()`, `remove()`, and `reverse()`, 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 recommended 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 `sys.maxsize`. If the length is larger than `sys.maxsize` 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.

object.__getitem__(self, subscript)

  Called to implement subscription, that is, `self[subscript]`. See Subscriptions and slicings for details on the syntax.

  There are two types of built-in objects that support subscription via `__getitem__()`:

  - sequences, where subscript (also called index) should be an integer or a `slice` object. See the sequence documentation for the expected behavior, including handling `slice` objects and negative indices.

  - mappings, where subscript is also called the key. See mapping documentation for the expected behavior.

  If subscript is of an inappropriate type, `__getitem__()` should raise `TypeError`. If subscript has an inappropriate value, `__getitem__()` should raise an `LookupError` or one of its subclasses (`IndexError` for sequences; `KeyError` for mappings).

  Note

  Slicing is handled by `__getitem__()`, `__setitem__()`, and `__delitem__()`. A call like

      a[1:2] = b

  est traduit en

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

  and so forth. Missing slice items are always filled in with `None`.

  Note

  The sequence iteration protocol (used, for example, in `for` loops), expects that an `IndexError` will be raised for illegal indexes to allow proper detection of the end of a sequence.

  Note

  When subscripting a class, the special class method `__class_getitem__()` may be called instead of `__getitem__()`. See __class_getitem__ contre __getitem__ for more details.

object.__setitem__(self, key, value)

  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'applique. 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émentation 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)
object.__rshift__(self, other)
object.__and__(self, other)
object.__xor__(self, other)
object.__or__(self, other)

  These methods are called to implement the binary arithmetic operations (`+`, `-`, `*`, `@`, `/`, `//`, `%`, `divmod()`, `pow()`, `**`, `<<`, `>>`, `&`, `^`, `|`). For instance, to evaluate the expression `x + y`, where x is an instance of a class that has an `__add__()` method, `type(x).__add__(x, y)` is called. The `__divmod__()` method should be the equivalent to using `__floordiv__()` and `__mod__()`; it should not be related to `__truediv__()`. Note that `__pow__()` should be defined to accept an optional third argument if the three-argument version of the built-in `pow()` function is to be supported.

  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 operands are of different types, when the left operand does not support the corresponding operation [3], or the right operand's class is derived from the left operand's class. [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` or `type(y)` is a subclass of `type(x)`. [5]

  Note that `__rpow__()` should be defined to accept an optional third argument if the three-argument version of the built-in `pow()` function is to be supported.

  Modifié dans la version 3.14: Three-argument `pow()` now try calling `__rpow__()` if necessary. Previously it was only called in two-argument `pow()` and the binary power operator.

  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)
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 Pourquoi a_tuple[i] += ['item'] lève-t-il une exception alors que l'addition fonctionne ?), 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 `operator.index()` 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`).

  Modifié dans la version 3.14: `int()` no longer delegates to the `__trunc__()` method.

### 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.

Les utilisations classiques des gestionnaires de contexte sont la sauvegarde et la restauration d'états divers, le verrouillage et le déverrouillage de ressources, la fermeture de fichiers ouverts, etc.

For more information on context managers, see Le type gestionnaire de contexte. 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 is an integer representing the kind of buffer requested, affecting for example whether the returned buffer is read-only or writable. `inspect.BufferFlags` provides a convenient way to interpret the flags. The method must return a `memoryview` object.

  Thread safety: In free-threaded Python, implementations must manage any internal export counter using atomic operations. The method must be safe to call concurrently from multiple threads, and the returned buffer's underlying data must remain valid until the corresponding `__release_buffer__()` call completes. See Thread safety for memoryview objects for details.

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`.

  Thread safety: In free-threaded Python, any export counter decrement must use atomic operations. Resource cleanup must be thread-safe, as the final release may race with concurrent releases from other threads.

  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.

`collections.abc.Buffer`

  ABC for buffer types.

### 3.3.12. Annotations

Functions, classes, and modules may contain annotations, which are a way to associate information (usually type hints) with a symbol.

object.__annotations__

  This attribute contains the annotations for an object. It is lazily evaluated, so accessing the attribute may execute arbitrary code and raise exceptions. If evaluation is successful, the attribute is set to a dictionary mapping from variable names to annotations.

  Modifié dans la version 3.14: Annotations are now lazily evaluated.

object.__annotate__(format)

  An annotate function. Returns a new dictionary object mapping attribute/parameter names to their annotation values.

  Takes a format parameter specifying the format in which annotations values should be provided. It must be a member of the `annotationlib.Format` enum, or an integer with a value corresponding to a member of the enum.

  If an annotate function doesn't support the requested format, it must raise `NotImplementedError`. Annotate functions must always support `VALUE` format; they must not raise `NotImplementedError()` when called with this format.

  When called with `VALUE` format, an annotate function may raise `NameError`; it must not raise `NameError` when called requesting any other format.

  If an object does not have any annotations, `__annotate__` should preferably be set to `None` (it can’t be deleted), rather than set to a function that returns an empty dict.

  Ajouté dans la version 3.14.

Voir aussi

PEP 649 --- Deferred evaluation of annotation using descriptors

  Introduces lazy evaluation of annotations and the `__annotate__` function.

### 3.3.13. 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 :

    >>> 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 `types.coroutine()` 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, `asyncio.Future` implements this method to be compatible with the `await` expression. The `object` class itself is not awaitable and does not provide this method.

  Note

  le langage n'impose aucune restriction sur le type ou la valeur des objets générés par l'itérateur renvoyé par `__await__`, car cela est spécifique à l'implémentation du cadriciel d'exécution asynchrone (par exemple `asyncio`) qui gère l'objet awaitable.

Ajouté dans la version 3.5.

Voir aussi

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

### 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`.

coroutine.send(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.

coroutine.throw(value)
coroutine.throw(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.

coroutine.close()

  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):
            ...

        def __aiter__(self):
            return self

        async def __anext__(self):
            val = await self.readline()
            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.

Notes

[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.

[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]

"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]

For operands of the same type, it is assumed that if the non-reflected method (such as `__add__()`) fails then the operation is not supported, which is why the reflected method is not called.

[5]

If the right operand's type is a subclass of the left operand's type, the reflected method having precedence allows subclasses to override their ancestors' operations.