2016-10-30 09:46:26 +00:00
|
|
|
|
# SOME DESCRIPTIVE TITLE.
|
|
|
|
|
# Copyright (C) 2001-2016, Python Software Foundation
|
|
|
|
|
# This file is distributed under the same license as the Python package.
|
|
|
|
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
|
|
|
|
#
|
|
|
|
|
msgid ""
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Project-Id-Version: Python 3.6\n"
|
|
|
|
|
"Report-Msgid-Bugs-To: \n"
|
2018-03-23 08:57:03 +00:00
|
|
|
|
"POT-Creation-Date: 2018-03-23 09:03+0100\n"
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"PO-Revision-Date: 2018-04-14 16:10+0200\n"
|
2017-05-23 22:40:56 +00:00
|
|
|
|
"Language: fr\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
|
|
|
"Content-Transfer-Encoding: 8bit\n"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Last-Translator: \n"
|
|
|
|
|
"Language-Team: \n"
|
|
|
|
|
"X-Generator: Poedit 2.0.2\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:6
|
|
|
|
|
msgid "Data model"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Modèle de données"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:12
|
|
|
|
|
msgid "Objects, values and types"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Objets, valeurs et types"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:18
|
|
|
|
|
msgid ""
|
|
|
|
|
":dfn:`Objects` are Python's abstraction for data. All data in a Python "
|
|
|
|
|
"program is represented by objects or by relations between objects. (In a "
|
|
|
|
|
"sense, and in conformance to Von Neumann's model of a \"stored program "
|
|
|
|
|
"computer,\" code is also represented by objects.)"
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"En Python, les données sont représentées sous forme :dfn:`d'objets`. Toutes "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"les données d'un programme Python sont représentées par des objets ou par "
|
|
|
|
|
"des relations entre les objets (dans un certain sens, et en conformité avec "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"le modèle de Von Neumann \"d'ordinateur à programme enregistré\", le code "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"est aussi représenté par des objets)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:35
|
|
|
|
|
msgid ""
|
|
|
|
|
"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 ':keyword:`is`' operator compares the identity of "
|
|
|
|
|
"two objects; the :func:`id` function returns an integer representing its "
|
|
|
|
|
"identity."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Chaque objet possède un identifiant, un type et une valeur. *L'identifiant* "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"d'un objet ne change jamais après sa création ; vous pouvez vous le "
|
|
|
|
|
"représenter comme l'adresse de l'objet en mémoire. L'opérateur ':keyword:"
|
|
|
|
|
"`is`' compare les identifiants de deux objets ; la fonction :func:`id` "
|
|
|
|
|
"renvoie un entier représentant cet identifiant."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:42
|
|
|
|
|
msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored."
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "en CPython, ``id(x)`` est l'adresse mémoire où est stocké ``x``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:44
|
|
|
|
|
msgid ""
|
|
|
|
|
"An object's type determines the operations that the object supports (e.g., "
|
|
|
|
|
"\"does it have a length?\") and also defines the possible values for objects "
|
|
|
|
|
"of that type. The :func:`type` function returns an object's type (which is "
|
|
|
|
|
"an object itself). Like its identity, an object's :dfn:`type` is also "
|
|
|
|
|
"unchangeable. [#]_"
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 :func:`type` "
|
|
|
|
|
"renvoie le type de l'objet (qui est lui-même un objet). Comme l'identifiant, "
|
|
|
|
|
"le :dfn:`type` d'un objet ne peut pas être modifié [#]_."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:50
|
|
|
|
|
msgid ""
|
|
|
|
|
"The *value* of some objects can change. Objects whose value can change are "
|
|
|
|
|
"said to be *mutable*; objects whose value is unchangeable once they are "
|
|
|
|
|
"created are called *immutable*. (The value of an immutable container object "
|
|
|
|
|
"that contains a reference to a mutable object can change when the latter's "
|
|
|
|
|
"value is changed; however the container is still considered immutable, "
|
|
|
|
|
"because the collection of objects it contains cannot be changed. So, "
|
|
|
|
|
"immutability is not strictly the same as having an unchangeable value, it is "
|
|
|
|
|
"more subtle.) An object's mutability is determined by its type; for "
|
|
|
|
|
"instance, numbers, strings and tuples are immutable, while dictionaries and "
|
|
|
|
|
"lists are mutable."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"La *valeur* de certains objets peut changer. Les objets dont la valeur peut "
|
|
|
|
|
"changer sont dits *muables* (*mutable* en anglais) ; 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 muable peut varier lorsque la valeur de "
|
|
|
|
|
"l'objet muable 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 "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"objet est définie par son type ; par exemple, les nombres, les chaînes de "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"caractères et les tuples sont immuables alors que les dictionnaires et les "
|
|
|
|
|
"listes sont muables."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:65
|
|
|
|
|
msgid ""
|
|
|
|
|
"Objects are never explicitly destroyed; however, when they become "
|
|
|
|
|
"unreachable they may be garbage-collected. An implementation is allowed to "
|
|
|
|
|
"postpone garbage collection or omit it altogether --- it is a matter of "
|
|
|
|
|
"implementation quality how garbage collection is implemented, as long as no "
|
|
|
|
|
"objects are collected that are still reachable."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"ramasse-miette est particulière à chaque implémentation, l'important étant "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"qu'il ne supprime pas d'objet qui peut encore être atteint."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:73
|
|
|
|
|
msgid ""
|
|
|
|
|
"CPython currently uses a reference-counting scheme with (optional) delayed "
|
|
|
|
|
"detection of cyclically linked garbage, which collects most objects as soon "
|
|
|
|
|
"as they become unreachable, but is not guaranteed to collect garbage "
|
|
|
|
|
"containing circular references. See the documentation of the :mod:`gc` "
|
|
|
|
|
"module for information on controlling the collection of cyclic garbage. "
|
|
|
|
|
"Other implementations act differently and CPython may change. Do not depend "
|
|
|
|
|
"on immediate finalization of objects when they become unreachable (so you "
|
|
|
|
|
"should always close files explicitly)."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 :mod:`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)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:82
|
|
|
|
|
msgid ""
|
|
|
|
|
"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 ':keyword:`try`...\\ :keyword:`except`' "
|
|
|
|
|
"statement may keep objects alive."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Notez que si vous utilisez les fonctionnalités de débogage ou de trace de "
|
|
|
|
|
"l'implémentation, il est possible que des références qui seraient "
|
|
|
|
|
"normalement supprimées soient toujours présentes. Notez aussi que capturer "
|
|
|
|
|
"une exception avec l'instruction ':keyword:`try`...\\ :keyword:`except`' "
|
|
|
|
|
"peut conserver des objets en vie."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:87
|
|
|
|
|
msgid ""
|
|
|
|
|
"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 :meth:`close` method. Programs are strongly recommended "
|
|
|
|
|
"to explicitly close such objects. The ':keyword:`try`...\\ :keyword:"
|
|
|
|
|
"`finally`' statement and the ':keyword:`with`' statement provide convenient "
|
|
|
|
|
"ways to do this."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Certains objets font référence à des ressources \"externes\" telles que des "
|
|
|
|
|
"fichiers ouverts ou des fenêtres. Ces objets libèrent ces ressources au "
|
|
|
|
|
"moment où ils sont supprimés, mais comme le ramasse-miettes ne garantit pas "
|
|
|
|
|
"qu'il supprime tous les objets, ces objets fournissent également un moyen "
|
|
|
|
|
"explicite de libérer la ressource externe, généralement sous la forme d'une "
|
|
|
|
|
"méthode :meth:`close`. Nous incitons fortement les programmeurs à fermer "
|
|
|
|
|
"explicitement de tels objets. Les instructions ':keyword:`try`...\\ :"
|
|
|
|
|
"keyword:`finally`' et ':keyword:`with`' sont très pratiques pour cela."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:97
|
|
|
|
|
msgid ""
|
|
|
|
|
"Some objects contain references to other objects; these are called "
|
|
|
|
|
"*containers*. Examples of containers are tuples, lists and dictionaries. "
|
|
|
|
|
"The references are part of a container's value. In most cases, when we talk "
|
|
|
|
|
"about the value of a container, we imply the values, not the identities of "
|
|
|
|
|
"the contained objects; however, when we talk about the mutability of a "
|
|
|
|
|
"container, only the identities of the immediately contained objects are "
|
|
|
|
|
"implied. So, if an immutable container (like a tuple) contains a reference "
|
|
|
|
|
"to a mutable object, its value changes if that mutable object is changed."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Certains objets contiennent des références à d'autres objets ; on les "
|
|
|
|
|
"appelle *conteneurs*. Comme exemples de conteneurs, nous pouvons citer les "
|
|
|
|
|
"tuples, 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 les "
|
|
|
|
|
"identifiants des objets contenus ; cependant, lorsque nous parlons de la "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"muabilité d'un conteneur, seuls les identifiants des objets immédiatement "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"contenus sont concernés. Ainsi, si un conteneur immuable (comme un tuple) "
|
|
|
|
|
"contient une référence à un objet muable, sa valeur change si cet objet "
|
|
|
|
|
"muable est modifié."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:106
|
|
|
|
|
msgid ""
|
|
|
|
|
"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. E.g., 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, but "
|
|
|
|
|
"after ``c = []; d = []``, ``c`` and ``d`` are guaranteed to refer to two "
|
|
|
|
|
"different, unique, newly created empty lists. (Note that ``c = d = []`` "
|
|
|
|
|
"assigns the same object to both ``c`` and ``d``.)"
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Presque tous les comportements d'un objet dépendent du type de l'objet. "
|
|
|
|
|
"Même son identifiant est concerné dans un certain sens : pour les types "
|
|
|
|
|
"immuables, les opérations qui calculent de nouvelles valeurs peuvent en fait "
|
|
|
|
|
"renvoyer une référence à n'importe quel objet existant avec le même type et "
|
|
|
|
|
"la même valeur, alors que pour les objets muables cela n'est pas autorisé. "
|
|
|
|
|
"Par exemple, après ``a = 1 ; b = 1``, ``a`` et ``b`` peuvent ou non se "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"référer au même objet avec la valeur un, en fonction de l'implémentation. "
|
|
|
|
|
"Mais après ``c = [] ; d = []``, il est garanti que ``c`` et ``d`` font "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"référence à deux listes vides distinctes nouvellement créées. Notez que ``c "
|
|
|
|
|
"= d = []`` attribue le même objet à ``c`` et ``d``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:120
|
|
|
|
|
msgid "The standard type hierarchy"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Hiérarchie des types standards"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:129
|
|
|
|
|
msgid ""
|
|
|
|
|
"Below is a list of the types that are built into Python. Extension modules "
|
|
|
|
|
"(written in C, Java, or other languages, depending on the implementation) "
|
|
|
|
|
"can define additional types. Future versions of Python may add types to the "
|
|
|
|
|
"type hierarchy (e.g., rational numbers, efficiently stored arrays of "
|
|
|
|
|
"integers, etc.), although such additions will often be provided via the "
|
|
|
|
|
"standard library instead."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:140
|
|
|
|
|
msgid ""
|
|
|
|
|
"Some of the type descriptions below contain a paragraph listing 'special "
|
|
|
|
|
"attributes.' These are attributes that provide access to the implementation "
|
|
|
|
|
"and are not intended for general use. Their definition may change in the "
|
|
|
|
|
"future."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Quelques descriptions des types ci-dessous contiennent un paragraphe listant "
|
|
|
|
|
"des \"attributs spéciaux\". Ces attributs donnent accès à l'implémentation "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"et n'ont, en général, pas vocation à être utilisés. Leur définition peut "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"changer dans le futur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:150
|
|
|
|
|
msgid "None"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "None"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:147
|
|
|
|
|
msgid ""
|
|
|
|
|
"This type has a single value. There is a single object with this value. "
|
|
|
|
|
"This object is accessed through the built-in name ``None``. It is used to "
|
|
|
|
|
"signify the absence of a value in many situations, e.g., it is returned from "
|
|
|
|
|
"functions that don't explicitly return anything. Its truth value is false."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 retournent rien explicitement. Sa valeur booléenne "
|
|
|
|
|
"est fausse."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:165
|
|
|
|
|
msgid "NotImplemented"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:155
|
|
|
|
|
msgid ""
|
|
|
|
|
"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.) Its truth value is true."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 ``NotImplemented``. "
|
|
|
|
|
"Les méthodes numériques et les comparaisons riches doivent renvoyer cette "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"valeur si elles n'implémentent pas l'opération pour les opérandes fournies "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"(l'interpréteur essaie alors l'opération en permutant les opérandes ou tout "
|
|
|
|
|
"autre stratégie de contournement, en fonction de l'opérateur). Sa valeur "
|
|
|
|
|
"booléenne est vraie."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:162
|
|
|
|
|
msgid "See :ref:`implementing-the-arithmetic-operations` for more details."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Consultez :ref:`implementing-the-arithmetic-operations` pour davantage de "
|
|
|
|
|
"details."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:172
|
|
|
|
|
msgid "Ellipsis"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Ellipse"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:170
|
|
|
|
|
msgid ""
|
|
|
|
|
"This type has a single value. There is a single object with this value. "
|
|
|
|
|
"This object is accessed through the literal ``...`` or the built-in name "
|
|
|
|
|
"``Ellipsis``. Its truth value is true."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:242
|
|
|
|
|
msgid ":class:`numbers.Number`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:177
|
|
|
|
|
msgid ""
|
|
|
|
|
"These are created by numeric literals and returned as results by arithmetic "
|
|
|
|
|
"operators and arithmetic built-in functions. Numeric objects are immutable; "
|
|
|
|
|
"once created their value never changes. Python numbers are of course "
|
|
|
|
|
"strongly related to mathematical numbers, but subject to the limitations of "
|
|
|
|
|
"numerical representation in computers."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:183
|
|
|
|
|
msgid ""
|
|
|
|
|
"Python distinguishes between integers, floating point numbers, and complex "
|
|
|
|
|
"numbers:"
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Python distingue les entiers, les nombres à virgule flottante et les nombres "
|
|
|
|
|
"complexes :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:217
|
|
|
|
|
msgid ":class:`numbers.Integral`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:189
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent elements from the mathematical set of integers (positive and "
|
|
|
|
|
"negative)."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Ils représentent des éléments de l'ensemble mathématique des entiers "
|
|
|
|
|
"(positifs ou négatifs)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:192
|
|
|
|
|
msgid "There are two types of integers:"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Il existe deux types d'entiers :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:194
|
|
|
|
|
msgid "Integers (:class:`int`)"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Entiers (:class:`int`)"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:196
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent numbers in an unlimited range, subject to available "
|
|
|
|
|
"(virtual) memory only. For the purpose of shift and mask operations, a "
|
|
|
|
|
"binary representation is assumed, and negative numbers are represented in a "
|
|
|
|
|
"variant of 2's complement which gives the illusion of an infinite string of "
|
|
|
|
|
"sign bits extending to the left."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"complément à 2, qui donne l'illusion d'une chaîne infinie de bits de signe "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"s'étendant vers la gauche."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:212
|
|
|
|
|
msgid "Booleans (:class:`bool`)"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Booléens (:class:`bool`)"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:208
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent the truth values False and True. The two objects "
|
|
|
|
|
"representing the values ``False`` and ``True`` are the only Boolean objects. "
|
|
|
|
|
"The Boolean type is a subtype of the integer type, and Boolean values behave "
|
|
|
|
|
"like the values 0 and 1, respectively, in almost all contexts, the exception "
|
|
|
|
|
"being that when converted to a string, the strings ``\"False\"`` or ``\"True"
|
|
|
|
|
"\"`` are returned, respectively."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:216
|
|
|
|
|
msgid ""
|
|
|
|
|
"The rules for integer representation are intended to give the most "
|
|
|
|
|
"meaningful interpretation of shift and mask operations involving negative "
|
|
|
|
|
"integers."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:232
|
|
|
|
|
msgid ":class:`numbers.Real` (:class:`float`)"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr ":class:`numbers.Real` (:class:`float`)"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:226
|
|
|
|
|
msgid ""
|
|
|
|
|
"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."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Ils représentent les nombres à virgule flottante en double précision, tels "
|
|
|
|
|
"que manipulés directement par la machine. Vous dépendez donc de "
|
|
|
|
|
"l'architecture machine sous-jacente (et de l'implémentation C ou Java) pour "
|
|
|
|
|
"les intervalles gérés et le traitement des débordements. Python ne gère pas "
|
|
|
|
|
"les nombres à virgule flottante en précision simple ; les gains en puissance "
|
|
|
|
|
"de calcul et mémoire, qui sont généralement la raison de l'utilisation des "
|
|
|
|
|
"nombres en simple précision, sont annihilés par le fait que Python encapsule "
|
|
|
|
|
"de toute façon ces nombres dans des objets. Il n'y a donc aucune raison de "
|
|
|
|
|
"compliquer le langage avec deux types de nombres à virgule flottante."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:242
|
|
|
|
|
msgid ":class:`numbers.Complex` (:class:`complex`)"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr ":class:`numbers.Complex` (:class:`complex`)"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:239
|
|
|
|
|
msgid ""
|
|
|
|
|
"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``."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Ils représentent les nombres complexes, sous la forme d'un couple de nombres "
|
|
|
|
|
"à virgule flottante en double précision, tels que manipulés directement par "
|
|
|
|
|
"la machine. Les mêmes restrictions s'appliquent que pour les nombres à "
|
|
|
|
|
"virgule flottante. La partie réelle et la partie imaginaire d'un nombre "
|
|
|
|
|
"complexe ``z`` peuvent être demandées par les attributs en lecture seule ``z."
|
|
|
|
|
"real`` et ``z.imag``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:359
|
|
|
|
|
msgid "Sequences"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Séquences"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:252
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent finite ordered sets indexed by non-negative numbers. The "
|
|
|
|
|
"built-in function :func:`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]``."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Ils représentent des ensembles de taille finie indicés par des entiers "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"positifs ou nuls. La fonction native :func:`len` renvoie le nombre "
|
|
|
|
|
"d'éléments de la séquence. Quand la longueur d'une séquence est *n*, "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"l'ensemble des indices contient les entiers 0, 1 ..., *n*-1. L'élément "
|
|
|
|
|
"d'indice *i* de la séquence *a* est accédé par ``a[i]``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:259
|
|
|
|
|
msgid ""
|
|
|
|
|
"Sequences also support slicing: ``a[i:j]`` selects all items with index *k* "
|
|
|
|
|
"such that *i* ``<=`` *k* ``<`` *j*. When used as an expression, a slice is "
|
|
|
|
|
"a sequence of the same type. This implies that the index set is renumbered "
|
|
|
|
|
"so that it starts at 0."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les séquences peuvent aussi être découpées (*slicing* en anglais) : ``a[i:"
|
|
|
|
|
"j]`` sélectionne tous les éléments d'indice *k* tel que *i* ``<=`` *k* ``<`` "
|
|
|
|
|
"*j*. Quand on l'utilise dans une expression, la tranche est du même type que "
|
|
|
|
|
"la séquence. Ceci veut dire que l'ensemble des indices est renuméroté de "
|
|
|
|
|
"manière à partir de 0."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:264
|
|
|
|
|
msgid ""
|
|
|
|
|
"Some sequences also support \"extended slicing\" with a third \"step\" "
|
|
|
|
|
"parameter: ``a[i:j:k]`` selects all items of *a* with index *x* where ``x = "
|
|
|
|
|
"i + n*k``, *n* ``>=`` ``0`` and *i* ``<=`` *x* ``<`` *j*."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Quelques séquences gèrent le \"découpage étendu\" (*extended slicing* en "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"anglais) avec un troisième paramètre : ``a[i:j:k]`` sélectionne tous les "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"éléments de *a* d'indice *x* où ``x = i + n*k``, avec *n* ``>=`` ``0`` et "
|
|
|
|
|
"*i* ``<=`` *x* ``<`` *j*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:268
|
|
|
|
|
msgid "Sequences are distinguished according to their mutability:"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Les séquences se différencient en fonction de leur muabilité :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:325
|
|
|
|
|
msgid "Immutable sequences"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Séquences immuables"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:275
|
|
|
|
|
msgid ""
|
|
|
|
|
"An object of an immutable sequence type cannot change once it is created. "
|
|
|
|
|
"(If the object contains references to other objects, these other objects may "
|
|
|
|
|
"be mutable and may be changed; however, the collection of objects directly "
|
|
|
|
|
"referenced by an immutable object cannot change.)"
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 muables et peuvent être modifiés ; cependant, les "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"objets directement référencés par un objet immuable ne peuvent pas être "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"modifiés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:280
|
|
|
|
|
msgid "The following types are immutable sequences:"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Les types suivants sont des séquences immuables :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:303
|
|
|
|
|
msgid "Strings"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Chaînes de caractères"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:293
|
|
|
|
|
msgid ""
|
|
|
|
|
"A string is a sequence of values that represent Unicode code points. All the "
|
|
|
|
|
"code points in the range ``U+0000 - U+10FFFF`` can be represented in a "
|
|
|
|
|
"string. Python doesn't have a :c:type:`char` type; instead, every code "
|
|
|
|
|
"point in the string is represented as a string object with length ``1``. "
|
|
|
|
|
"The built-in function :func:`ord` converts a code point from its string form "
|
|
|
|
|
"to an integer in the range ``0 - 10FFFF``; :func:`chr` converts an integer "
|
|
|
|
|
"in the range ``0 - 10FFFF`` to the corresponding length ``1`` string "
|
|
|
|
|
"object. :meth:`str.encode` can be used to convert a :class:`str` to :class:"
|
|
|
|
|
"`bytes` using the given text encoding, and :meth:`bytes.decode` can be used "
|
|
|
|
|
"to achieve the opposite."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Une chaîne de caractères (*string* en anglais) est une séquence de valeurs "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"qui représentent des caractères Unicode. Tout caractère dont le code est "
|
|
|
|
|
"dans l'intervalle ``U+0000 - U+10FFFF`` peut être représenté dans une "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"chaîne. Python ne possède pas de type :c:type:`char` ; à la place, chaque "
|
|
|
|
|
"caractère Unicode dans la chaîne est représenté par un objet chaîne de "
|
|
|
|
|
"longueur ``1``. La fonction native :func:`ord` convertit un caractère "
|
|
|
|
|
"Unicode de la représentation en chaîne vers un entier dans l'intervalle ``0 "
|
|
|
|
|
"- 10FFFF`` ; la fonction :func:`chr` convertit un entier de l'intervalle ``0 "
|
|
|
|
|
"- 10FFFF`` vers l'objet chaîne de longueur ``1`` correspondant. :meth:`str."
|
|
|
|
|
"encode` peut être utilisée pour convertir un objet :class:`str` vers :class:"
|
|
|
|
|
"`bytes` selon l'encodage spécifié et :meth:`bytes.decode` effectue "
|
|
|
|
|
"l'opération inverse."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:316
|
|
|
|
|
msgid "Tuples"
|
|
|
|
|
msgstr "Tuples"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:311
|
|
|
|
|
msgid ""
|
|
|
|
|
"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."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Les éléments d'un tuple sont n'importe quels objets Python. Les tuples de "
|
|
|
|
|
"deux ou plus éléments sont formés par une liste d'expressions dont les "
|
|
|
|
|
"éléments sont séparés par des virgules. Un tuple composé d'un seul élément "
|
|
|
|
|
"(un \"singleton\") est formé en suffixant une expression avec une virgule "
|
|
|
|
|
"(une expression en tant que telle ne crée pas un tuple car les parenthèses "
|
|
|
|
|
"doivent rester disponibles pour grouper les expressions). Un tuple vide peut "
|
|
|
|
|
"être formé à l'aide d'une paire de parenthèses vides."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:325
|
|
|
|
|
msgid "Bytes"
|
|
|
|
|
msgstr "Bytes"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:321
|
|
|
|
|
msgid ""
|
|
|
|
|
"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 "
|
2017-08-01 11:29:09 +00:00
|
|
|
|
"``b'abc'``) and the built-in :func:`bytes()` constructor can be used to "
|
|
|
|
|
"create bytes objects. Also, bytes objects can be decoded to strings via "
|
|
|
|
|
"the :meth:`~bytes.decode` method."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les objets *bytes* sont des tableaux immuables. Les éléments sont des octets "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"(donc composés de 8 bits), représentés par des entiers dans l'intervalle 0 à "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"255 inclus. Les littéraux *bytes* (tels que ``b'abc'``) et la fonction "
|
|
|
|
|
"native constructeur :func:`bytes()` peuvent être utilisés pour créer des "
|
|
|
|
|
"objets *bytes*. Aussi, un objet *bytes* peut être décodé vers une chaîne "
|
|
|
|
|
"*via* la méthode :meth:`~bytes.decode`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:359
|
|
|
|
|
msgid "Mutable sequences"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Séquences muables"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:335
|
|
|
|
|
msgid ""
|
|
|
|
|
"Mutable sequences can be changed after they are created. The subscription "
|
|
|
|
|
"and slicing notations can be used as the target of assignment and :keyword:"
|
|
|
|
|
"`del` (delete) statements."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Les séquences muables peuvent être modifiées après leur création. Les "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"notations de tranches et de sous-ensembles peuvent être utilisées en tant "
|
|
|
|
|
"que cibles d'une assignation ou de l'instruction :keyword:`del` "
|
|
|
|
|
"(suppression)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:339
|
|
|
|
|
msgid "There are currently two intrinsic mutable sequence types:"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Il existe aujourd'hui deux types intrinsèques de séquences muables :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:346
|
|
|
|
|
msgid "Lists"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Listes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:344
|
|
|
|
|
msgid ""
|
|
|
|
|
"The items of a list are arbitrary Python objects. Lists are formed by "
|
|
|
|
|
"placing a comma-separated list of expressions in square brackets. (Note that "
|
|
|
|
|
"there are no special cases needed to form lists of length 0 or 1.)"
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"sont séparés par des virgules (notez que les listes de longueur 0 ou 1 ne "
|
|
|
|
|
"sont pas des cas particuliers)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:354
|
|
|
|
|
msgid "Byte Arrays"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Tableaux d'octets"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:351
|
|
|
|
|
msgid ""
|
|
|
|
|
"A bytearray object is a mutable array. They are created by the built-in :"
|
|
|
|
|
"func:`bytearray` constructor. Aside from being mutable (and hence "
|
|
|
|
|
"unhashable), byte arrays otherwise provide the same interface and "
|
2017-08-01 11:29:09 +00:00
|
|
|
|
"functionality as immutable :class:`bytes` objects."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Un objet *bytearray* est un tableau muable. Il est créé par la fonction "
|
|
|
|
|
"native constructeur :func:`bytearray`. À part la propriété d'être muable (et "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"donc de ne pas pouvoir calculer une empreinte par hachage), les tableaux "
|
|
|
|
|
"d'octets possèdent la même interface et les mêmes fonctionnalités que les "
|
|
|
|
|
"objets immuables :class:`bytes`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:358
|
|
|
|
|
msgid ""
|
|
|
|
|
"The extension module :mod:`array` provides an additional example of a "
|
|
|
|
|
"mutable sequence type, as does the :mod:`collections` module."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Le module d'extension :mod:`array` fournit un autre exemple de type de "
|
|
|
|
|
"séquence muable, de même que le module :mod:`collections`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:393
|
|
|
|
|
msgid "Set types"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Ensembles"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:366
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent unordered, finite sets of unique, immutable objects. As "
|
|
|
|
|
"such, they cannot be indexed by any subscript. However, they can be iterated "
|
|
|
|
|
"over, and the built-in function :func:`len` returns the number of items in a "
|
|
|
|
|
"set. Common uses for sets are fast membership testing, removing duplicates "
|
|
|
|
|
"from a sequence, and computing mathematical operations such as intersection, "
|
|
|
|
|
"union, difference, and symmetric difference."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Ils représentent les ensembles d'objets, non ordonnés, finis et dont les "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"éléments sont uniques. Tels quels, ils ne peuvent pas être indicés. "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Cependant, il est possible d'itérer dessus et la fonction native :func:`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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:373
|
|
|
|
|
msgid ""
|
|
|
|
|
"For set elements, the same immutability rules apply as for dictionary keys. "
|
|
|
|
|
"Note that numeric types obey the normal rules for numeric comparison: if two "
|
|
|
|
|
"numbers compare equal (e.g., ``1`` and ``1.0``), only one of them can be "
|
|
|
|
|
"contained in a set."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:378
|
|
|
|
|
msgid "There are currently two intrinsic set types:"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Actuellement, il existe deux types d'ensembles natifs :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:385
|
|
|
|
|
msgid "Sets"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Ensembles"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:383
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent a mutable set. They are created by the built-in :func:`set` "
|
|
|
|
|
"constructor and can be modified afterwards by several methods, such as :meth:"
|
|
|
|
|
"`~set.add`."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Ils représentent les ensembles muables. Un ensemble est créé par la fonction "
|
|
|
|
|
"native constructeur :func:`set` et peut être modifié par la suite à l'aide "
|
|
|
|
|
"de différentes méthodes, par exemple :meth:`~set.add`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:393
|
|
|
|
|
msgid "Frozen sets"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Ensembles gelés"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:390
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent an immutable set. They are created by the built-in :func:"
|
|
|
|
|
"`frozenset` constructor. As a frozenset is immutable and :term:`hashable`, "
|
|
|
|
|
"it can be used again as an element of another set, or as a dictionary key."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Ils représentent les ensembles immuables. Ils sont créés par la fonction "
|
|
|
|
|
"native constructeur :func:`frozenset`. Comme un ensemble gelé est immuable "
|
|
|
|
|
"et :term:`hachable`, il peut être utilisé comme élément d'un autre ensemble "
|
|
|
|
|
"ou comme clé de dictionnaire."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:430
|
|
|
|
|
msgid "Mappings"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Tableaux de correspondances"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:401
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent finite sets of objects indexed by arbitrary index sets. The "
|
|
|
|
|
"subscript notation ``a[k]`` selects the item indexed by ``k`` from the "
|
|
|
|
|
"mapping ``a``; this can be used in expressions and as the target of "
|
|
|
|
|
"assignments or :keyword:`del` statements. The built-in function :func:`len` "
|
|
|
|
|
"returns the number of items in a mapping."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"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 "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"``k`` dans le tableau de correspondance ``a`` ; elle peut être utilisée dans "
|
|
|
|
|
"des expressions, comme cible d'une assignation ou avec l'instruction :"
|
|
|
|
|
"keyword:`del`. La fonction native :func:`len` renvoie le nombre d'éléments "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"dans le tableau de correspondances."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:407
|
|
|
|
|
msgid "There is currently a single intrinsic mapping type:"
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Il n'existe actuellement qu'un seul type natif pour les tableaux de "
|
|
|
|
|
"correspondances :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:430
|
|
|
|
|
msgid "Dictionaries"
|
|
|
|
|
msgstr "Dictionnaires"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:412
|
|
|
|
|
msgid ""
|
|
|
|
|
"These represent finite sets of objects indexed by nearly arbitrary values. "
|
|
|
|
|
"The only types of values not acceptable as keys are values containing lists "
|
|
|
|
|
"or dictionaries or other mutable types that are compared by value rather "
|
|
|
|
|
"than by object identity, the reason being that the efficient implementation "
|
|
|
|
|
"of dictionaries requires a key's hash value to remain constant. Numeric "
|
|
|
|
|
"types used for keys obey the normal rules for numeric comparison: if two "
|
|
|
|
|
"numbers compare equal (e.g., ``1`` and ``1.0``) then they can be used "
|
|
|
|
|
"interchangeably to index the same dictionary entry."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Ils représentent les ensembles finis d'objets indicés par des valeurs "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"presqu'arbitraires. Les seuls types de valeurs non reconnus comme clés sont "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"les valeurs contenant des listes, des dictionnaires ou les autres types "
|
|
|
|
|
"muables 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 "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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 "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:421
|
|
|
|
|
msgid ""
|
|
|
|
|
"Dictionaries are mutable; they can be created by the ``{...}`` notation (see "
|
|
|
|
|
"section :ref:`dict`)."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Les dictionnaires sont muables : ils peuvent être créés par la notation "
|
|
|
|
|
"``{...}`` (lisez la section :ref:`dict`)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:428
|
|
|
|
|
msgid ""
|
|
|
|
|
"The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide additional "
|
|
|
|
|
"examples of mapping types, as does the :mod:`collections` module."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Les modules d'extensions :mod:`dbm.ndbm` et :mod:`dbm.gnu` apportent "
|
|
|
|
|
"d'autres exemples de types tableaux de correspondances, de même que le "
|
|
|
|
|
"module :mod:`collections`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:686
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Callable types"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Types appelables"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:439
|
|
|
|
|
msgid ""
|
|
|
|
|
"These are the types to which the function call operation (see section :ref:"
|
|
|
|
|
"`calls`) can be applied:"
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Ce sont les types sur lesquels on peut faire un appel de fonction (lisez la "
|
|
|
|
|
"section :ref:`calls`) :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:534
|
|
|
|
|
msgid "User-defined functions"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Fonctions définies par l'utilisateur"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:448
|
|
|
|
|
msgid ""
|
|
|
|
|
"A user-defined function object is created by a function definition (see "
|
|
|
|
|
"section :ref:`function`). It should be called with an argument list "
|
|
|
|
|
"containing the same number of items as the function's formal parameter list."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Un objet fonction définie par l'utilisateur est créé par la définition d'une "
|
|
|
|
|
"fonction (voir la section :ref:`function`). 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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:453
|
|
|
|
|
msgid "Special attributes:"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Attributs spéciaux :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:471
|
|
|
|
|
msgid "Attribute"
|
2017-03-05 09:57:28 +00:00
|
|
|
|
msgstr "Attribut"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:471
|
|
|
|
|
msgid "Meaning"
|
|
|
|
|
msgstr "Signification"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:473
|
|
|
|
|
msgid ":attr:`__doc__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:473
|
|
|
|
|
msgid ""
|
|
|
|
|
"The function's documentation string, or ``None`` if unavailable; not "
|
|
|
|
|
"inherited by subclasses"
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Chaîne de documentation de la fonction ou ``None`` s'il n'en existe pas ; "
|
|
|
|
|
"n'est pas héritée par les sous-classes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:473 ../Doc/reference/datamodel.rst:478
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:481 ../Doc/reference/datamodel.rst:486
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:490 ../Doc/reference/datamodel.rst:496
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:506 ../Doc/reference/datamodel.rst:514
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:521
|
|
|
|
|
msgid "Writable"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Accessible en écriture"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:478
|
|
|
|
|
msgid ":attr:`~definition.\\ __name__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:478
|
|
|
|
|
msgid "The function's name"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Nom de la fonction"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:481
|
|
|
|
|
msgid ":attr:`~definition.\\ __qualname__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:481
|
|
|
|
|
msgid "The function's :term:`qualified name`"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr ":term:`qualified name` de la fonction"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:486
|
|
|
|
|
msgid ":attr:`__module__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:486
|
|
|
|
|
msgid ""
|
|
|
|
|
"The name of the module the function was defined in, or ``None`` if "
|
|
|
|
|
"unavailable."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Nom du module où la fonction est définie ou ``None`` si ce nom n'est pas "
|
|
|
|
|
"disponible."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:490
|
|
|
|
|
msgid ":attr:`__defaults__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:490
|
|
|
|
|
msgid ""
|
|
|
|
|
"A tuple containing default argument values for those arguments that have "
|
|
|
|
|
"defaults, or ``None`` if no arguments have a default value"
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Tuple contenant les valeurs des arguments par défaut pour ceux qui en sont "
|
|
|
|
|
"dotés ou ``None`` si aucun argument n'a de valeur par défaut."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:496
|
|
|
|
|
msgid ":attr:`__code__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:496
|
|
|
|
|
msgid "The code object representing the compiled function body."
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Objet code représentant le corps de la fonction compilée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:499
|
|
|
|
|
msgid ":attr:`__globals__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:499
|
|
|
|
|
msgid ""
|
|
|
|
|
"A reference to the dictionary that holds the function's global variables --- "
|
|
|
|
|
"the global namespace of the module in which the function was defined."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Référence pointant vers le dictionnaire contenant les variables globales de "
|
|
|
|
|
"la fonction -- l'espace de noms global du module dans lequel la fonction est "
|
|
|
|
|
"définie."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:499 ../Doc/reference/datamodel.rst:510
|
|
|
|
|
msgid "Read-only"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Accessible en lecture seule"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:506
|
|
|
|
|
msgid ":attr:`~object.__dict__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:506
|
|
|
|
|
msgid "The namespace supporting arbitrary function attributes."
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Espace de noms accueillant les attributs de la fonction."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:510
|
|
|
|
|
msgid ":attr:`__closure__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:510
|
|
|
|
|
msgid ""
|
|
|
|
|
"``None`` or a tuple of cells that contain bindings for the function's free "
|
|
|
|
|
"variables."
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
"``None`` ou tuple de cellules qui contient un lien pour chaque variable "
|
|
|
|
|
"libre de la fonction."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:514
|
|
|
|
|
msgid ":attr:`__annotations__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:514
|
|
|
|
|
msgid ""
|
|
|
|
|
"A dict containing annotations of parameters. The keys of the dict are the "
|
|
|
|
|
"parameter names, and ``'return'`` for the return annotation, if provided."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Dictionnaire contenant les annotations des paramètres. Les clés du "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"dictionnaire sont les noms des paramètres et la clé ``\"return\"`` est "
|
|
|
|
|
"utilisée pour les annotations de la valeur renvoyée. Les entrées du "
|
|
|
|
|
"dictionnaire ne sont présentes que si les paramètres sont effectivement "
|
|
|
|
|
"annotés."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:521
|
|
|
|
|
msgid ":attr:`__kwdefaults__`"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:521
|
|
|
|
|
msgid "A dict containing defaults for keyword-only parameters."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Dictionnaire contenant les valeurs par défaut pour les paramètres passés par "
|
|
|
|
|
"mot-clé."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:525
|
|
|
|
|
msgid ""
|
|
|
|
|
"Most of the attributes labelled \"Writable\" check the type of the assigned "
|
|
|
|
|
"value."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"La plupart des attributs étiquetés \"Accessibles en écriture\" vérifient le "
|
|
|
|
|
"type de la valeur qu'on leur assigne."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:527
|
|
|
|
|
msgid ""
|
|
|
|
|
"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. *Note that "
|
|
|
|
|
"the current implementation only supports function attributes on user-defined "
|
|
|
|
|
"functions. Function attributes on built-in functions may be supported in the "
|
|
|
|
|
"future.*"
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les objets fonctions acceptent également l'assignation et la lecture "
|
|
|
|
|
"d'attributs arbitraires. Vous pouvez utiliser cette fonctionnalité pour, par "
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"exemple, associer des métadonnées aux fonctions. La notation classique par "
|
|
|
|
|
"point est utilisée pour définir et lire de tels attributs. *Notez que "
|
|
|
|
|
"l'implémentation actuelle accepte seulement les attributs de fonction sur "
|
|
|
|
|
"les fonctions définies par l'utilisateur. Les attributs de fonction pour les "
|
|
|
|
|
"fonctions natives seront peut-être acceptés dans le futur.*"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:533
|
|
|
|
|
msgid ""
|
|
|
|
|
"Additional information about a function's definition can be retrieved from "
|
|
|
|
|
"its code object; see the description of internal types below."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Vous trouvez davantage d'informations sur la définition de fonctions dans le "
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"code de cet objet ; la description des types internes est donnée plus bas."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:603
|
|
|
|
|
msgid "Instance methods"
|
2018-03-29 21:02:55 +00:00
|
|
|
|
msgstr "Méthodes d'instances"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:542
|
|
|
|
|
msgid ""
|
|
|
|
|
"An instance method object combines a class, a class instance and any "
|
|
|
|
|
"callable object (normally a user-defined function)."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"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)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:552
|
|
|
|
|
msgid ""
|
|
|
|
|
"Special read-only attributes: :attr:`__self__` is the class instance "
|
|
|
|
|
"object, :attr:`__func__` is the function object; :attr:`__doc__` is the "
|
|
|
|
|
"method's documentation (same as ``__func__.__doc__``); :attr:`~definition."
|
|
|
|
|
"__name__` is the method name (same as ``__func__.__name__``); :attr:"
|
|
|
|
|
"`__module__` is the name of the module the method was defined in, or "
|
|
|
|
|
"``None`` if unavailable."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs spéciaux en lecture seule : :attr:`__self__` est l'objet instance "
|
|
|
|
|
"de classe, :attr:`__func__` est l'objet fonction ; :attr:`__doc__` est la "
|
|
|
|
|
"documentation de la méthode (comme ``__func__.__doc__``) ; :attr:"
|
|
|
|
|
"`~definition.__name__` est le nom de la méthode (comme ``__func__."
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"__name__``) ; :attr:`__module__` est le nom du module où la méthode est "
|
|
|
|
|
"définie ou ``None`` s'il n'est pas disponible."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:558
|
|
|
|
|
msgid ""
|
|
|
|
|
"Methods also support accessing (but not setting) the arbitrary function "
|
|
|
|
|
"attributes on the underlying function object."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Les méthodes savent aussi accéder (mais pas modifier) les attributs de la "
|
|
|
|
|
"fonction de l'objet fonction sous-jacent."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:561
|
|
|
|
|
msgid ""
|
|
|
|
|
"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 class method object."
|
|
|
|
|
msgstr ""
|
2018-03-29 21:02:55 +00:00
|
|
|
|
"Les objets méthodes définies par l'utilisateur peuvent être créés quand vous "
|
|
|
|
|
"récupérez un attribut de classe (par exemple *via* une instance de cette "
|
|
|
|
|
"classe) si cet attribut est un objet fonction définie par l'utilisateur ou "
|
|
|
|
|
"un objet méthode de classe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:565
|
|
|
|
|
msgid ""
|
|
|
|
|
"When an instance method object is created by retrieving a user-defined "
|
|
|
|
|
"function object from a class via one of its instances, its :attr:`__self__` "
|
|
|
|
|
"attribute is the instance, and the method object is said to be bound. The "
|
|
|
|
|
"new method's :attr:`__func__` attribute is the original function object."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Quand un objet méthode d'instance est créé à partir d'un objet fonction "
|
|
|
|
|
"défini par l'utilisateur *via* une des instances, son attribut :attr:"
|
|
|
|
|
"`__self__` est l'instance et l'objet méthode est réputé lié. Le nouvel "
|
|
|
|
|
"attribut de la méthode :attr:`__func__` est l'objet fonction original."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:571
|
|
|
|
|
msgid ""
|
|
|
|
|
"When a user-defined method object is created by retrieving another method "
|
|
|
|
|
"object from a class or instance, the behaviour is the same as for a function "
|
|
|
|
|
"object, except that the :attr:`__func__` attribute of the new instance is "
|
|
|
|
|
"not the original method object but its :attr:`__func__` attribute."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Quand un objet méthode définie par l'utilisateur est créé à partir d'un "
|
|
|
|
|
"autre objet méthode de la classe ou de l'instance, son comportement est "
|
|
|
|
|
"identique à l'objet fonction sauf pour l'attribut :attr:`__func__` de la "
|
|
|
|
|
"nouvelle instance qui n'est pas l'objet méthode original mais son attribut :"
|
|
|
|
|
"attr:`__func__`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:577
|
|
|
|
|
msgid ""
|
|
|
|
|
"When an instance method object is created by retrieving a class method "
|
|
|
|
|
"object from a class or instance, its :attr:`__self__` attribute is the class "
|
|
|
|
|
"itself, and its :attr:`__func__` attribute is the function object underlying "
|
|
|
|
|
"the class method."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Quand un objet méthode d'instance est créé à partir d'un autre objet méthode "
|
|
|
|
|
"de la classe ou de l'instance, son attribut :attr:`__self__` est la classe "
|
|
|
|
|
"elle-même et son attribut :attr:`__func__` est l'objet fonction sous-jacent "
|
|
|
|
|
"la méthode de classe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:582
|
|
|
|
|
msgid ""
|
|
|
|
|
"When an instance method object is called, the underlying function (:attr:"
|
|
|
|
|
"`__func__`) is called, inserting the class instance (:attr:`__self__`) in "
|
|
|
|
|
"front of the argument list. For instance, when :class:`C` is a class which "
|
|
|
|
|
"contains a definition for a function :meth:`f`, and ``x`` is an instance of :"
|
|
|
|
|
"class:`C`, calling ``x.f(1)`` is equivalent to calling ``C.f(x, 1)``."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Quand un objet méthode d'instance est appelé, la fonction sous-jacente (:"
|
|
|
|
|
"attr:`__func__`) est appelée et l'objet instance de la classe (:attr:"
|
|
|
|
|
"`__self__`) est inséré en tête de liste des arguments. Par exemple, si :"
|
|
|
|
|
"class:`C` est une classe qui contient la définition d'une fonction :meth:`f` "
|
|
|
|
|
"et que ``x`` est une instance de :class:`C`, alors appeler ``x.f(1)`` est "
|
|
|
|
|
"équivalent à appeler ``C.f(x, 1)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:589
|
|
|
|
|
msgid ""
|
|
|
|
|
"When an instance method object is derived from a class method object, the "
|
|
|
|
|
"\"class instance\" stored in :attr:`__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."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Quand un objet méthode d'instance est dérivé à partir d'un objet méthode de "
|
|
|
|
|
"classe, l'instance de classe stockée dans :attr:`__self__` est en fait la "
|
|
|
|
|
"classe elle-même. Ainsi, appeler ``x.f(1)`` ou ``C.f(1)`` est équivalent à "
|
|
|
|
|
"appeler ``f(C, 1)`` où ``f`` est la fonction sous-jacente."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:594
|
|
|
|
|
msgid ""
|
|
|
|
|
"Note that the transformation from function object to instance method object "
|
|
|
|
|
"happens each time the attribute is retrieved from the instance. In some "
|
|
|
|
|
"cases, a fruitful optimization is to assign the attribute to a local "
|
|
|
|
|
"variable and call that local variable. Also notice that this transformation "
|
|
|
|
|
"only happens for user-defined functions; other callable objects (and all non-"
|
|
|
|
|
"callable objects) are retrieved without transformation. It is also "
|
|
|
|
|
"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."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Notez que la transformation d'objet fonction en objet méthode d'instance se "
|
|
|
|
|
"produit à chaque fois que l'attribut est récupéré à partir de l'instance. "
|
|
|
|
|
"Dans certains cas, assigner l'attribut à une variable locale et appeler "
|
|
|
|
|
"cette variable locale constitue une bonne optimisation. Notez aussi que "
|
|
|
|
|
"cette transformation n'a lieu que pour les fonctions définies par "
|
|
|
|
|
"l'utilisateur : les autres objets appelables (et les objets non appelables) "
|
|
|
|
|
"sont récupérés sans transformation. Il est aussi important de remarquer que "
|
|
|
|
|
"les fonctions définies par l'utilisateur qui sont attributs d'une instance "
|
|
|
|
|
"de classe ne sont pas converties en méthodes liées ; ceci n'a lieu que pour "
|
|
|
|
|
"les fonctions qui sont attributs de la classe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:618
|
|
|
|
|
msgid "Generator functions"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Fonctions générateurs"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:610
|
|
|
|
|
msgid ""
|
|
|
|
|
"A function or method which uses the :keyword:`yield` statement (see section :"
|
|
|
|
|
"ref:`yield`) is called a :dfn:`generator function`. Such a function, when "
|
|
|
|
|
"called, always returns an iterator object which can be used to execute the "
|
|
|
|
|
"body of the function: calling the iterator's :meth:`iterator.__next__` "
|
|
|
|
|
"method will cause the function to execute until it provides a value using "
|
|
|
|
|
"the :keyword:`yield` statement. When the function executes a :keyword:"
|
|
|
|
|
"`return` statement or falls off the end, a :exc:`StopIteration` exception is "
|
|
|
|
|
"raised and the iterator will have reached the end of the set of values to be "
|
|
|
|
|
"returned."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Une fonction ou une méthode qui utilise l'instruction :keyword:`yield` (voir "
|
|
|
|
|
"la section :ref:`yield`) est appelée :dfn:`fonction générateur`. Une telle "
|
|
|
|
|
"fonction, lorsqu'elle est appelée, retourne toujours un objet itérateur qui "
|
|
|
|
|
"peut être utilisé pour exécuter le corps de la fonction : appeler la "
|
|
|
|
|
"méthode :meth:`iterator.__next__` de l'itérateur exécute la fonction jusqu'à "
|
|
|
|
|
"ce qu'elle renvoie une valeur à l'aide de l'instruction :keyword:`yield`. "
|
|
|
|
|
"Quand la fonction exécute l'instruction :keyword:`return` ou se termine, une "
|
|
|
|
|
"exception :exc:`StopIteration` est levée et l'itérateur a atteint la fin de "
|
|
|
|
|
"l'ensemble de valeurs qu'il peut prendre."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:628
|
|
|
|
|
msgid "Coroutine functions"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Fonctions coroutines"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:624
|
|
|
|
|
msgid ""
|
|
|
|
|
"A function or method which is defined using :keyword:`async def` is called "
|
|
|
|
|
"a :dfn:`coroutine function`. Such a function, when called, returns a :term:"
|
|
|
|
|
"`coroutine` object. It may contain :keyword:`await` expressions, as well "
|
|
|
|
|
"as :keyword:`async with` and :keyword:`async for` statements. See also the :"
|
|
|
|
|
"ref:`coroutine-objects` section."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Une fonction ou méthode définie en utilisant :keyword:`async def` est "
|
|
|
|
|
"appelée :dfn:`fonction coroutine`. Une telle fonction, quand elle est "
|
|
|
|
|
"appelée, renvoie un objet :term:`coroutine`. Elle peut contenir des "
|
|
|
|
|
"expressions :keyword:`await` ou :keyword:`async with` ou des instructions :"
|
|
|
|
|
"keyword:`async for`. Voir également la section :ref:`coroutine-objects`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:647
|
|
|
|
|
msgid "Asynchronous generator functions"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Fonctions générateurs asynchrones"
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:635
|
|
|
|
|
msgid ""
|
|
|
|
|
"A function or method which is defined using :keyword:`async def` and which "
|
|
|
|
|
"uses the :keyword:`yield` statement is called a :dfn:`asynchronous generator "
|
|
|
|
|
"function`. Such a function, when called, returns an asynchronous iterator "
|
|
|
|
|
"object which can be used in an :keyword:`async for` statement to execute the "
|
|
|
|
|
"body of the function."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Une fonction ou une méthode définie avec :keyword:`async def` et qui utilise "
|
|
|
|
|
"l'instruction :keyword:`yield` est appelée :dfn:`fonction générateur "
|
|
|
|
|
"asynchrone`. Une telle fonction, quand elle est appelée, renvoie un objet "
|
|
|
|
|
"itérateur asynchrone qui peut être utilisé dans des instructions :keyword:"
|
|
|
|
|
"`async for` pour exécuter le corps de la fonction."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:641
|
|
|
|
|
msgid ""
|
|
|
|
|
"Calling the asynchronous iterator's :meth:`aiterator.__anext__` method will "
|
|
|
|
|
"return an :term:`awaitable` which when awaited will execute until it "
|
|
|
|
|
"provides a value using the :keyword:`yield` expression. When the function "
|
|
|
|
|
"executes an empty :keyword:`return` statement or falls off the end, a :exc:"
|
|
|
|
|
"`StopAsyncIteration` exception is raised and the asynchronous iterator will "
|
|
|
|
|
"have reached the end of the set of values to be yielded."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Appeler la méthode :meth:`aiterator.__anext__` de l'itérateur asynchrone "
|
|
|
|
|
"renvoie un :term:`awaitable` qui, lorsqu'on l'attend, s'exécute jusqu'à ce "
|
|
|
|
|
"qu'il fournisse une valeur à l'aide de l'expression :keyword:`yield`. Quand "
|
|
|
|
|
"la fonction exécute une instruction vide :keyword:`return` ou arrive à la "
|
|
|
|
|
"fin, une exception :exc:`StopAsynciteration` est levée et l'itérateur "
|
|
|
|
|
"asynchrone a atteint la fin de l'ensemble des valeurs qu'il peut produire."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:662
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Built-in functions"
|
2018-02-15 00:01:41 +00:00
|
|
|
|
msgstr "Fonctions natives"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:655
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A built-in function object is a wrapper around a C function. Examples of "
|
|
|
|
|
"built-in functions are :func:`len` and :func:`math.sin` (:mod:`math` is a "
|
|
|
|
|
"standard built-in module). The number and type of the arguments are "
|
|
|
|
|
"determined by the C function. Special read-only attributes: :attr:`__doc__` "
|
|
|
|
|
"is the function's documentation string, or ``None`` if unavailable; :attr:"
|
|
|
|
|
"`~definition.__name__` is the function's name; :attr:`__self__` is set to "
|
|
|
|
|
"``None`` (but see the next item); :attr:`__module__` is the name of the "
|
|
|
|
|
"module the function was defined in or ``None`` if unavailable."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Un objet fonction native est une enveloppe autour d'une fonction C. Nous "
|
|
|
|
|
"pouvons citer :func:`len` et :func:`math.sin` (:mod:`math` est un module "
|
|
|
|
|
"standard natif) comme fonctions natives. Le nombre et le type des arguments "
|
|
|
|
|
"sont déterminés par la fonction C. Des attributs spéciaux en lecture seule "
|
|
|
|
|
"existent : :attr:`__doc__` contient la chaîne de documentation de la "
|
|
|
|
|
"fonction (ou ``None`` s'il n'y en a pas) ; :attr:`~definition.__name__` est "
|
|
|
|
|
"le nom de la fonction ; :attr:`__self__` est défini à ``None`` ; :attr:"
|
|
|
|
|
"`__module__` est le nom du module où la fonction est définie ou ``None`` "
|
|
|
|
|
"s'il n'est pas disponible."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:674
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Built-in methods"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Méthodes natives"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:670
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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 :"
|
|
|
|
|
"attr:`__self__` is set to the object denoted by *alist*."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Ce sont des fonctions natives déguisées, contenant un objet passé à une "
|
|
|
|
|
"fonction C en tant qu'argument supplémentaire implicite. Un exemple de "
|
|
|
|
|
"méthode native est ``une_liste.append()`` (une_liste étant un objet liste). "
|
|
|
|
|
"Dans ce cas, l'attribut spécial en lecture seul :attr:`__self__` est défini "
|
|
|
|
|
"à l'objet *une_liste*."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:681
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Classes"
|
|
|
|
|
msgstr "Classes"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:677
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Classes are callable. These objects normally act as factories for new "
|
|
|
|
|
"instances of themselves, but variations are possible for class types that "
|
|
|
|
|
"override :meth:`__new__`. The arguments of the call are passed to :meth:"
|
|
|
|
|
"`__new__` and, in the typical case, to :meth:`__init__` to initialize the "
|
|
|
|
|
"new instance."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les classes sont des appelables. Ces objets sont normalement utilisés pour "
|
|
|
|
|
"créer des instances d'elles-mêmes mais des variations sont possibles pour "
|
|
|
|
|
"les types de classes qui surchargent :meth:`__new__`. Les arguments de "
|
|
|
|
|
"l'appel sont passés à :meth:`__new__` et, dans le cas classique, :meth:"
|
|
|
|
|
"`__new__` initialise une nouvelle instance."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:686
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Class Instances"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Instances de classe"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:684
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Instances of arbitrary classes can be made callable by defining a :meth:"
|
|
|
|
|
"`__call__` method in their class."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les instances d'une classe peuvent devenir des appelables si vous définissez "
|
|
|
|
|
"la méthode :meth:`__call__` de leur classe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:736
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Modules"
|
|
|
|
|
msgstr "Modules"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:693
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Modules are a basic organizational unit of Python code, and are created by "
|
|
|
|
|
"the :ref:`import system <importsystem>` as invoked either by the :keyword:"
|
|
|
|
|
"`import` statement (see :keyword:`import`), or by calling functions such as :"
|
|
|
|
|
"func:`importlib.import_module` and built-in :func:`__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)."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les modules constituent l'organisation de base du code Python et sont créés "
|
|
|
|
|
"par le :ref:`mécanisme d'import <importsystem>` soit avec l'instruction :"
|
|
|
|
|
"keyword:`import` (voir :keyword:`import`), soit en appelant des fonctions "
|
|
|
|
|
"telles que :func:`importlib.import_module` ou la fonction native :func:"
|
|
|
|
|
"`__import__`. Un objet module possède un espace de noms implémenté par un "
|
|
|
|
|
"objet dictionnaire (c'est le dictionnaire référencé par l'attribut "
|
|
|
|
|
"``__globals__`` des fonctions définies dans le module). Les références à un "
|
|
|
|
|
"attribut sont traduites en recherches dans ce dictionnaire, par exemple ``m."
|
|
|
|
|
"x`` est équivalent à ``m.__dict__[\"x\"]``. Un objet module ne contient pas "
|
|
|
|
|
"l'objet code utilisé pour initialiser le module (puisque celui-ci n'est plus "
|
|
|
|
|
"nécessaire une fois l'initialisation terminée)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:705
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Attribute assignment updates the module's namespace dictionary, e.g., ``m.x "
|
|
|
|
|
"= 1`` is equivalent to ``m.__dict__[\"x\"] = 1``."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"L'assignation d'un attribut met à jour le dictionnaire d'espace de noms du "
|
|
|
|
|
"module, par exemple ``m.x = 1`` est équivalent à ``m.__dict__[\"x\"] = 1``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:715
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Predefined (writable) attributes: :attr:`__name__` is the module's name; :"
|
|
|
|
|
"attr:`__doc__` is the module's documentation string, or ``None`` if "
|
|
|
|
|
"unavailable; :attr:`__annotations__` (optional) is a dictionary containing :"
|
|
|
|
|
"term:`variable annotations <variable annotation>` collected during module "
|
|
|
|
|
"body execution; :attr:`__file__` is the pathname of the file from which the "
|
|
|
|
|
"module was loaded, if it was loaded from a file. The :attr:`__file__` "
|
|
|
|
|
"attribute may be missing for certain types of modules, such as C modules "
|
|
|
|
|
"that are statically linked into the interpreter; for extension modules "
|
|
|
|
|
"loaded dynamically from a shared library, it is the pathname of the shared "
|
|
|
|
|
"library file."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs prédéfinis (en lecture-écriture) : :attr:`__name__` est le nom du "
|
|
|
|
|
"module ; :attr:`__doc__` est la chaîne de documentation du module (ou "
|
|
|
|
|
"``None`` s'il n'y en a pas) ; :attr:`__annotations__` (optionnel) est un "
|
|
|
|
|
"dictionnaire contenant les g :term:`Annotations de variables <variable "
|
|
|
|
|
"annotation>` collectées durant l'exécution du corps du module ; :attr:"
|
|
|
|
|
"`__file__` est le chemin vers le fichier à partir duquel le module a été "
|
|
|
|
|
"chargé, s'il a été chargé depuis un fichier. L'attribut :attr:`__file__` "
|
|
|
|
|
"peut être manquant pour certains types de modules, tels que les modules C "
|
|
|
|
|
"qui sont statiquement liés à l'interpréteur ; pour les modules d'extension "
|
|
|
|
|
"chargés dynamiquement à partir d'une bibliothèque partagée, c'est le chemin "
|
|
|
|
|
"vers le fichier de la bibliothèque partagée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:728
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Special read-only attribute: :attr:`~object.__dict__` is the module's "
|
|
|
|
|
"namespace as a dictionary object."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attribut spécial en lecture seule : :attr:`~object.__dict__` est l'objet "
|
|
|
|
|
"dictionnaire répertoriant l'espace de noms du module."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:733
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Because of the way CPython clears module dictionaries, the module dictionary "
|
|
|
|
|
"will be cleared when the module falls out of scope even if the dictionary "
|
|
|
|
|
"still has live references. To avoid this, copy the dictionary or keep the "
|
|
|
|
|
"module around while using its dictionary directly."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"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 utilisez le dictionnaire directement."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:795
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Custom classes"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Classes déclarées par le développeur"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:739
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Custom class types are typically created by class definitions (see section :"
|
|
|
|
|
"ref:`class`). 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 in the documentation accompanying the 2.3 release at https://www."
|
|
|
|
|
"python.org/download/releases/2.3/mro/."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Le type d'une classe déclarée par le développeur est créé au moment de la "
|
|
|
|
|
"définition de la classe (voir la section :ref:`class`). Une classe possède "
|
|
|
|
|
"un espace de noms implémenté sous la forme d'un objet dictionnaire. Les "
|
|
|
|
|
"références vers les attributs de la classe sont traduits en recherches dans "
|
|
|
|
|
"ce dictionnaire, par exemple ``C.x`` est traduit en ``C.__dict__[\"x\"]`` "
|
|
|
|
|
"(bien qu'il existe un certain nombre de fonctions automatiques qui "
|
|
|
|
|
"permettent de trouver des attributs par d'autres moyens). Si le nom "
|
|
|
|
|
"d'attribut n'est pas trouvé dans ce dictionnaire, la recherche continue dans "
|
|
|
|
|
"les classes de base. Les classes de base sont trouvées en utilisant la "
|
|
|
|
|
"méthode de résolution d'ordre (*method resolution order* en anglais, ou MRO) "
|
|
|
|
|
"C3 qui a un comportement cohérent même en présence d'héritages en \"diamant"
|
|
|
|
|
"\", où différentes branches d'héritages conduisent vers un ancêtre commun. "
|
|
|
|
|
"Vous trouverez plus de détails sur la MRO C3 utilisée par Python dans la "
|
|
|
|
|
"documentation de la version 2.3 disponible sur https://www.python.org/"
|
|
|
|
|
"download/releases/2.3/mro/."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:763
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"When a class attribute reference (for class :class:`C`, say) would yield a "
|
|
|
|
|
"class method object, it is transformed into an instance method object whose :"
|
|
|
|
|
"attr:`__self__` attributes is :class:`C`. When it would yield a static "
|
|
|
|
|
"method object, it is transformed into the object wrapped by the static "
|
|
|
|
|
"method object. See section :ref:`descriptors` for another way in which "
|
|
|
|
|
"attributes retrieved from a class may differ from those actually contained "
|
|
|
|
|
"in its :attr:`~object.__dict__`."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Quand une référence à un attribut de classe (disons la classe :class:`C`) "
|
|
|
|
|
"pointe vers un objet méthode de classe, elle est transformée en objet "
|
|
|
|
|
"méthode d'instance dont l'attribut :attr:`__self__` est :class:`C`. Quand "
|
|
|
|
|
"elle pointe vers un objet méthode statique, elle est transformée en objet "
|
|
|
|
|
"encapsulé par l'objet méthode statique. Reportez-vous à la section :ref:"
|
|
|
|
|
"`descriptors` pour une autre manière dont les attributs d'une classe "
|
|
|
|
|
"diffèrent de ceux réellement contenus dans son :attr:`~objet.__dict__`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:773
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Class attribute assignments update the class's dictionary, never the "
|
|
|
|
|
"dictionary of a base class."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les assignations d'un attribut de classe mettent à jour le dictionnaire de "
|
|
|
|
|
"la classe, jamais le dictionnaire d'une classe de base."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:778
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A class object can be called (see above) to yield a class instance (see "
|
|
|
|
|
"below)."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Un objet classe peut être appelé (voir ci-dessus) pour produire une instance "
|
|
|
|
|
"de classe (voir ci-dessous)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:788
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Special attributes: :attr:`~definition.__name__` is the class name; :attr:"
|
|
|
|
|
"`__module__` is the module name in which the class was defined; :attr:"
|
|
|
|
|
"`~object.__dict__` is the dictionary containing the class's namespace; :attr:"
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"`~class.__bases__` is a tuple containing the base classes, in the order of "
|
|
|
|
|
"their occurrence in the base class list; :attr:`__doc__` is the class's "
|
|
|
|
|
"documentation string, or ``None`` if undefined; :attr:`__annotations__` "
|
|
|
|
|
"(optional) is a dictionary containing :term:`variable annotations <variable "
|
|
|
|
|
"annotation>` collected during class body execution."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs spéciaux : :attr:`~definition.__name__` est le nom de la classe ; :"
|
|
|
|
|
"attr:`__module__` est le nom du module dans lequel la classe est définie ; :"
|
|
|
|
|
"attr:`~object.__dict__` est le dictionnaire contenant l'espace de noms de la "
|
|
|
|
|
"classe ; :attr:`~class.__bases__` est un tuple contenant les classes de "
|
|
|
|
|
"base, dans l'ordre d'apparition dans la liste des classes de base ; :attr:"
|
|
|
|
|
"`__doc__` est la chaîne de documentation de la classe (ou ``None`` si elle "
|
|
|
|
|
"n'existe pas) ; :attr:`__annotations__` (optionnel) est un dictionnaire "
|
|
|
|
|
"contenant les :term:`annotations de variables <variable annotation>` "
|
|
|
|
|
"collectées durant l'exécution du corps de la classe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:838
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Class instances"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Instances de classes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:804
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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 :attr:`__self__` attribute is the instance. Static "
|
|
|
|
|
"method and class method objects are also transformed; see above under "
|
|
|
|
|
"\"Classes\". See section :ref:`descriptors` for another way in which "
|
|
|
|
|
"attributes of a class retrieved via its instances may differ from the "
|
|
|
|
|
"objects actually stored in the class's :attr:`~object.__dict__`. If no "
|
|
|
|
|
"class attribute is found, and the object's class has a :meth:`__getattr__` "
|
|
|
|
|
"method, that is called to satisfy the lookup."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Une instance de classe est créée en appelant un objet classe (voir ci-"
|
|
|
|
|
"dessus). Une instance de classe possède un espace de noms implémenté sous la "
|
|
|
|
|
"forme d'un dictionnaire qui est le premier endroit où sont recherchées les "
|
|
|
|
|
"références aux attributs. Quand un attribut n'est pas trouvé dans ce "
|
|
|
|
|
"dictionnaire et que la classe de l'instance contient un attribut avec ce "
|
|
|
|
|
"nom, la recherche continue avec les attributs de la classe. Si un attribut "
|
|
|
|
|
"de classe est trouvé et que c'est un objet fonction défini par "
|
|
|
|
|
"l'utilisateur, il est transformé en objet méthode d'instance dont "
|
|
|
|
|
"l'attribut :attr:`__self__` est l'instance. Les objets méthodes statiques et "
|
|
|
|
|
"méthodes de classe sont aussi transformés ; reportez-vous ci-dessous à "
|
|
|
|
|
"\"Classes\". Lisez la section :ref:`descriptors` pour une autre façon de "
|
|
|
|
|
"récupérer les attributs d'une classe, où la récupération *via* ses instances "
|
|
|
|
|
"peut différer des objets réellement stockés dans le :attr:`objet.__dict__` "
|
|
|
|
|
"de la classe. Si aucun attribut de classe n'est trouvé et que la classe de "
|
|
|
|
|
"l'objet possède une méthode :meth:`__getattr__`, cette méthode est appelée "
|
|
|
|
|
"pour rechercher une correspondance."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:820
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Attribute assignments and deletions update the instance's dictionary, never "
|
|
|
|
|
"a class's dictionary. If the class has a :meth:`__setattr__` or :meth:"
|
|
|
|
|
"`__delattr__` method, this is called instead of updating the instance "
|
|
|
|
|
"dictionary directly."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les assignations et effacement d'attributs mettent à jour le dictionnaire de "
|
|
|
|
|
"l'instance, jamais le dictionnaire de la classe. Si la classe possède une "
|
|
|
|
|
"méthode :meth:`__setattr__` ou :meth:`__delattr__`, elle est appelée au lieu "
|
|
|
|
|
"de mettre à jour le dictionnaire de l'instance directement."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:830
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Class instances can pretend to be numbers, sequences, or mappings if they "
|
|
|
|
|
"have methods with certain special names. See section :ref:`specialnames`."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les instances de classes peuvent prétendre être des nombres, des séquences "
|
|
|
|
|
"ou des tableaux de correspondance si elles ont des méthodes avec des noms "
|
|
|
|
|
"spéciaux. Voir la section :ref:`specialnames`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:837
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Special attributes: :attr:`~object.__dict__` is the attribute dictionary; :"
|
|
|
|
|
"attr:`~instance.__class__` is the instance's class."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs spéciaux : :attr:`objet.__dict__` est le dictionnaire des "
|
|
|
|
|
"attributs ; :attr:`~instace.__class__` est la classe de l'instance."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:864
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "I/O objects (also known as file objects)"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Objets Entrées-Sorties (ou objets fichiers)"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:854
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A :term:`file object` represents an open file. Various shortcuts are "
|
|
|
|
|
"available to create file objects: the :func:`open` built-in function, and "
|
|
|
|
|
"also :func:`os.popen`, :func:`os.fdopen`, and the :meth:`~socket.socket."
|
|
|
|
|
"makefile` method of socket objects (and perhaps by other functions or "
|
|
|
|
|
"methods provided by extension modules)."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Un :term:`objet fichier` représente un fichier ouvert. Différentes "
|
|
|
|
|
"raccourcis existent pour créer des objets fichiers : la fonction native :"
|
|
|
|
|
"func:`open` et aussi :func:`os.popen`, :func:`os.fdopen` ou la méthode :meth:"
|
|
|
|
|
"`~socket.socket.makefile` des objets sockets (et sûrement d'autres fonctions "
|
|
|
|
|
"ou méthodes fournies par les modules d'extensions)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:860
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The objects ``sys.stdin``, ``sys.stdout`` and ``sys.stderr`` are initialized "
|
|
|
|
|
"to file objects corresponding to the interpreter's standard input, output "
|
|
|
|
|
"and error streams; they are all open in text mode and therefore follow the "
|
|
|
|
|
"interface defined by the :class:`io.TextIOBase` abstract class."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"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 :class:"
|
|
|
|
|
"`io.TextIOBase`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1070
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Internal types"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Types internes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:871
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A few types used internally by the interpreter are exposed to the user. "
|
|
|
|
|
"Their definitions may change with future versions of the interpreter, but "
|
|
|
|
|
"they are mentioned here for completeness."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"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é."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:939
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Code objects"
|
|
|
|
|
msgstr "Objets Code"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:878
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Code objects represent *byte-compiled* executable Python code, or :term:"
|
|
|
|
|
"`bytecode`. The difference between a code object and a function object is "
|
|
|
|
|
"that the function object contains an explicit reference to the function's "
|
|
|
|
|
"globals (the module in which it was defined), while a code object contains "
|
|
|
|
|
"no context; also the default argument values are stored in the function "
|
|
|
|
|
"object, not in the code object (because they represent values calculated at "
|
|
|
|
|
"run-time). Unlike function objects, code objects are immutable and contain "
|
|
|
|
|
"no references (directly or indirectly) to mutable objects."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Un objet code représente le code Python sous sa forme compilée en :term:"
|
|
|
|
|
"`bytecode`. 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 de 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 muables."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:903
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Special read-only attributes: :attr:`co_name` gives the function name; :attr:"
|
|
|
|
|
"`co_argcount` is the number of positional arguments (including arguments "
|
|
|
|
|
"with default values); :attr:`co_nlocals` is the number of local variables "
|
|
|
|
|
"used by the function (including arguments); :attr:`co_varnames` is a tuple "
|
|
|
|
|
"containing the names of the local variables (starting with the argument "
|
|
|
|
|
"names); :attr:`co_cellvars` is a tuple containing the names of local "
|
|
|
|
|
"variables that are referenced by nested functions; :attr:`co_freevars` is a "
|
|
|
|
|
"tuple containing the names of free variables; :attr:`co_code` is a string "
|
|
|
|
|
"representing the sequence of bytecode instructions; :attr:`co_consts` is a "
|
|
|
|
|
"tuple containing the literals used by the bytecode; :attr:`co_names` is a "
|
|
|
|
|
"tuple containing the names used by the bytecode; :attr:`co_filename` is the "
|
|
|
|
|
"filename from which the code was compiled; :attr:`co_firstlineno` is the "
|
|
|
|
|
"first line number of the function; :attr:`co_lnotab` is a string encoding "
|
|
|
|
|
"the mapping from bytecode offsets to line numbers (for details see the "
|
|
|
|
|
"source code of the interpreter); :attr:`co_stacksize` is the required stack "
|
|
|
|
|
"size (including local variables); :attr:`co_flags` is an integer encoding a "
|
|
|
|
|
"number of flags for the interpreter."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs spéciaux en lecture seule : :attr:`co_name` donne le nom de la "
|
|
|
|
|
"fonction ; :attr:`co_argcount` est le nombre d'arguments positionnels (y "
|
|
|
|
|
"compris les arguments avec des valeurs par défaut) ; :attr:`co_nlocals` est "
|
|
|
|
|
"le nombre de variables locales utilisées par la fonction (y compris les "
|
|
|
|
|
"arguments) ; :attr:`co_varnames` est un tuple contenant le nom des variables "
|
|
|
|
|
"locales (en commençant par les noms des arguments) ; :attr:`co_cellvars` est "
|
|
|
|
|
"un tuple contenant les noms des variables locales qui sont référencées par "
|
|
|
|
|
"des fonctions imbriquées ; :attr:`co_freevars` est un tuple contenant les "
|
|
|
|
|
"noms des variables libres ; :attr:`co_code` est une chaîne représentant la "
|
|
|
|
|
"séquence des instructions de *bytecode* ; :attr:`co_consts` est un tuple "
|
|
|
|
|
"contenant les littéraux utilisés par le *bytecode* ; :attr:`co_names` est un "
|
|
|
|
|
"tuple contenant les noms utilisés par le *bytecode* ; :attr:`co_filename` "
|
|
|
|
|
"est le nom de fichier à partir duquel le code a été compilé ; :attr:"
|
|
|
|
|
"`co_firstlineno` est numéro de la première ligne de la fonction ; :attr:"
|
|
|
|
|
"`co_lnotab` est une chaîne qui code la correspondance entre les différents "
|
|
|
|
|
"endroits du *bytecode* et les numéros de lignes (pour les détails, regardez "
|
|
|
|
|
"le code source de l'interpréteur) ; :attr:`co_stacksize` est la taille de "
|
|
|
|
|
"pile nécessaire (y compris pour les variables locales) ; :attr:`co_flags` "
|
|
|
|
|
"est un entier qui code différents drapeaux pour l'interpréteur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:922
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The following flag bits are defined for :attr:`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."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les drapeaux suivants sont codés par des bits dans :attr:`co_flags` : le bit "
|
|
|
|
|
"``0x04`` est positionné à 1 si la fonction utilise la syntaxe ``*arguments`` "
|
|
|
|
|
"pour accepter un nombre arbitraire d'arguments positionnels ; le bit "
|
|
|
|
|
"``0x08`` est positionné à 1 si la fonction utilise la syntaxe ``**keywords`` "
|
|
|
|
|
"pour accepter un nombre arbitraire d'arguments nommés ; bit ``0x20`` est "
|
|
|
|
|
"positionné à 1 si la fonction est un générateur."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:928
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Future feature declarations (``from __future__ import division``) also use "
|
|
|
|
|
"bits in :attr:`co_flags` to indicate whether a code object was compiled with "
|
|
|
|
|
"a particular feature enabled: bit ``0x2000`` is set if the function was "
|
|
|
|
|
"compiled with future division enabled; bits ``0x10`` and ``0x1000`` were "
|
|
|
|
|
"used in earlier versions of Python."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Les déclarations de fonctionnalité future ``from __future__ import "
|
|
|
|
|
"division`` utilisent aussi des bits dans :attr:`co_flags` pour indiquer si "
|
|
|
|
|
"l'objet code a été compilé avec une fonctionnalité future : le bit "
|
|
|
|
|
"``0x2000`` est positionné à 1 si la fonction a été compilée avec la division "
|
|
|
|
|
"future activée ; les bits ``0x10`` et ``0x1000`` étaient utilisés dans les "
|
|
|
|
|
"versions antérieures de Python."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:934
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Other bits in :attr:`co_flags` are reserved for internal use."
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Les autres bits de :attr:`co_flags` sont réservés à un usage interne."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:938
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If a code object represents a function, the first item in :attr:`co_consts` "
|
|
|
|
|
"is the documentation string of the function, or ``None`` if undefined."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Si l'objet code représente une fonction, le premier élément dans :attr:"
|
|
|
|
|
"`co_consts` est la chaîne de documentation de la fonction (ou ``None`` s'il "
|
|
|
|
|
"n'y en a pas)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:988
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Frame objects"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Objets cadres"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:946
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Frame objects represent execution frames. They may occur in traceback "
|
|
|
|
|
"objects (see below)."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Un objet cadre représente le cadre d'exécution. Ils apparaissent dans des "
|
|
|
|
|
"objets traces (voir plus loin)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:957
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Special read-only attributes: :attr:`f_back` is to the previous stack frame "
|
|
|
|
|
"(towards the caller), or ``None`` if this is the bottom stack frame; :attr:"
|
|
|
|
|
"`f_code` is the code object being executed in this frame; :attr:`f_locals` "
|
|
|
|
|
"is the dictionary used to look up local variables; :attr:`f_globals` is used "
|
|
|
|
|
"for global variables; :attr:`f_builtins` is used for built-in (intrinsic) "
|
|
|
|
|
"names; :attr:`f_lasti` gives the precise instruction (this is an index into "
|
|
|
|
|
"the bytecode string of the code object)."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs spéciaux en lecture seule : :attr:`f_back` pointe vers le cadre "
|
|
|
|
|
"précédent (l'appelant) ou ``None`` si c'est le pied de la pile d'appel ; :"
|
|
|
|
|
"attr:`f_code` est l'objet code en cours d'exécution dans ce cadre ; :attr:"
|
|
|
|
|
"`f_locals` est le dictionnaire dans lequel sont cherchées les variables "
|
|
|
|
|
"locales ; :attr:`f_globals` est utilisé pour les variables globales ; :attr:"
|
|
|
|
|
"`f_builtins` est utilisé pour les noms natifs ; :attr:`f_lasti` donne "
|
|
|
|
|
"l'instruction précise (c'est un indice dans la chaîne de *bytecode* de "
|
|
|
|
|
"l'objet code)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:969
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Special writable attributes: :attr:`f_trace`, if not ``None``, is a function "
|
|
|
|
|
"called at the start of each source code line (this is used by the "
|
|
|
|
|
"debugger); :attr:`f_lineno` is 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 f_lineno."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs spéciaux en lecture-écriture : :attr:`f_trace`, s'il ne vaut pas "
|
|
|
|
|
"``None``, est une fonction appelée au début de chaque ligne de code source "
|
|
|
|
|
"(c'est utilisé par le débogueur) ; :attr:`f_lineno` est le numéro de la "
|
|
|
|
|
"ligne courante du cadre --- écrire dedans depuis une fonction trace fait "
|
|
|
|
|
"sauter à la ligne demandée (seulement pour le cadre le plus bas). Un "
|
|
|
|
|
"débogueur peut implémenter une commande \"sauter vers\" en écrivant dans "
|
|
|
|
|
"f_lineno."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:976
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Frame objects support one method:"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Les objets cadres comprennent une méthode :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:980
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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)."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Cette méthode efface toutes les références aux variables locales conservées "
|
|
|
|
|
"dans le cadre. Par ailleurs, si le cadre est celui d'un générateur, le "
|
|
|
|
|
"générateur se termine. Ceci permet de casser des références cycliques qui "
|
|
|
|
|
"incluent des objets cadres (par exemple, lors de la capture d'une exception "
|
|
|
|
|
"et du stockage de la pile d'appels pour une utilisation future)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:986
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":exc:`RuntimeError` is raised if the frame is currently executing."
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr ":exc:`RuntimeError` est levée si le cadre est en cours d'exécution."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1026
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Traceback objects"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Objets traces"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1001
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Traceback objects represent a stack trace of an exception. A traceback "
|
|
|
|
|
"object is created when an exception occurs. 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 :ref:`try`.) It is accessible as the third item of the "
|
|
|
|
|
"tuple returned by ``sys.exc_info()``. 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``."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Un objet trace représente la pile d'appels d'une exception. Il est créé au "
|
|
|
|
|
"moment où l'exception est levée. Quand l'interpréteur recherche un "
|
|
|
|
|
"gestionnaire d'exception en remontant la pile d'exécution, un objet trace "
|
|
|
|
|
"est inséré devant l'objet trace courant à chaque nouveau niveau. Quand il "
|
|
|
|
|
"entre dans le gestionnaire d'exception, la pile d'appels est rendue "
|
|
|
|
|
"accessible au programme (voir la section :ref:`try`). Elle est accessible "
|
|
|
|
|
"par le troisième élément du tuple renvoyé par ``sys.exc_info()``. Quand le "
|
|
|
|
|
"programme ne dispose pas d'un gestionnaire adéquat, la pile d'appels est "
|
|
|
|
|
"écrite (joliment formatée) sur le flux d'erreurs standard ; si "
|
|
|
|
|
"l'interpréteur est interactif, la pile d'appels est rendue accessible à "
|
|
|
|
|
"l'utilisateur en tant que ``sys.last_traceback``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1019
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Special read-only attributes: :attr:`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; :attr:`tb_frame` points to the execution frame of the "
|
|
|
|
|
"current level; :attr:`tb_lineno` gives the line number where the exception "
|
|
|
|
|
"occurred; :attr:`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 :keyword:`try` statement "
|
|
|
|
|
"with no matching except clause or with a finally clause."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs spéciaux en lecture seule : attr:`tb_next` est le prochain niveau "
|
|
|
|
|
"dans la pile d'appels (vers le cadre où l'exception a été levée) ou ``None`` "
|
|
|
|
|
"s'il n'y a pas de prochain niveau ; :attr:`tb_frame` pointe vers le cadre "
|
|
|
|
|
"d'exécution du niveau courant ; :attr:`tb_lineno` donne le numéro de ligne "
|
|
|
|
|
"où l'exception a été levée ; :attr:`tb_lasti` indique l'instruction "
|
|
|
|
|
"précise. Le numéro de ligne et la dernière instruction dans la trace "
|
|
|
|
|
"peuvent différer du numéro de ligne de l'objet cadre si l'exception a eu "
|
|
|
|
|
"lieu dans une instruction :keyword:`try` sans qu'il n'y ait de clause :"
|
|
|
|
|
"keyword:`except` adéquate ou sans clause *finally* ."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1052
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Slice objects"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Objets découpes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1031
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Slice objects are used to represent slices for :meth:`__getitem__` methods. "
|
|
|
|
|
"They are also created by the built-in :func:`slice` function."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Un objet découpe est utilisé pour représenter les découpes des méthodes :"
|
|
|
|
|
"meth:`__getitem__`. Ils sont aussi créés par la fonction native :func:"
|
|
|
|
|
"`slice`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1039
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Special read-only attributes: :attr:`~slice.start` is the lower bound; :attr:"
|
|
|
|
|
"`~slice.stop` is the upper bound; :attr:`~slice.step` is the step value; "
|
|
|
|
|
"each is ``None`` if omitted. These attributes can have any type."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Attributs spéciaux en lecture seule : :attr:`~decoupe.start` est la borne "
|
|
|
|
|
"inférieure ; :attr:`~decoupe.stop` est la borne supérieure ; :attr:`~decoupe."
|
|
|
|
|
"step` est la valeur du pas ; chaque attribut vaut ``None`` s'il est omis. "
|
|
|
|
|
"Ces attributs peuvent être de n'importe quel type."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1043
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Slice objects support one method:"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Les objets découpes comprennent une méthode :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1047
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This method takes a single integer argument *length* and computes "
|
|
|
|
|
"information about the slice that the slice object would describe if applied "
|
|
|
|
|
"to a sequence of *length* items. It returns a tuple of three integers; "
|
|
|
|
|
"respectively these are the *start* and *stop* indices and the *step* or "
|
|
|
|
|
"stride length of the slice. Missing or out-of-bounds indices are handled in "
|
|
|
|
|
"a manner consistent with regular slices."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Cette méthode prend un argument entier *length* et calcule les informations "
|
|
|
|
|
"de la découpe que l'objet découpe décrit s'il est appliqué à une séquence de "
|
|
|
|
|
"*length* éléments. Elle renvoie un tuple de trois 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 "
|
|
|
|
|
"découpes normales."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1062
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Static method objects"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Objets méthodes statiques"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1055
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Static method objects provide a way of defeating the transformation of "
|
|
|
|
|
"function objects to method objects described above. A static method object "
|
|
|
|
|
"is a wrapper around any other object, usually a user-defined method object. "
|
|
|
|
|
"When a static method object is retrieved from a class or a class instance, "
|
|
|
|
|
"the object actually returned is the wrapped object, which is not subject to "
|
|
|
|
|
"any further transformation. Static method objects are not themselves "
|
|
|
|
|
"callable, although the objects they wrap usually are. Static method objects "
|
|
|
|
|
"are created by the built-in :func:`staticmethod` constructor."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"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 ne sont pas appelables en tant que tels, bien que "
|
|
|
|
|
"les objets qu'ils encapsulent le soient souvent. Les objets méthodes "
|
|
|
|
|
"statiques sont créés par le constructeur natif :func:`staticmethod`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1070
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Class method objects"
|
2018-04-09 21:26:29 +00:00
|
|
|
|
msgstr "Objets méthodes de classes"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1065
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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 \"User-defined methods\". Class method "
|
|
|
|
|
"objects are created by the built-in :func:`classmethod` constructor."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"Un objet méthode de classe, comme un objet méthode statique, encapsule un "
|
|
|
|
|
"autre objet afin de modifier la façon dont cet objet est récupéré depuis les "
|
|
|
|
|
"classes et instances de classes. Le comportement des objets méthodes de "
|
|
|
|
|
"classes dans le cas d'une telle récupération est décrit plus haut, dans "
|
|
|
|
|
"\"méthodes définies par l'utilisateur\". Les objets méthodes de classes sont "
|
|
|
|
|
"créés par le constructeur natif :func:`classmethod`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1075
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Special method names"
|
2018-04-14 15:00:52 +00:00
|
|
|
|
msgstr "Méthodes spéciales"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1081
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A class can implement certain operations that are invoked by special syntax "
|
|
|
|
|
"(such as arithmetic operations or subscripting and slicing) by defining "
|
|
|
|
|
"methods with special names. This is Python's approach to :dfn:`operator "
|
|
|
|
|
"overloading`, allowing classes to define their own behavior with respect to "
|
|
|
|
|
"language operators. For instance, if a class defines a method named :meth:"
|
|
|
|
|
"`__getitem__`, and ``x`` is an instance of this class, then ``x[i]`` is "
|
|
|
|
|
"roughly equivalent to ``type(x).__getitem__(x, i)``. Except where "
|
|
|
|
|
"mentioned, attempts to execute an operation raise an exception when no "
|
|
|
|
|
"appropriate method is defined (typically :exc:`AttributeError` or :exc:"
|
|
|
|
|
"`TypeError`)."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"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 "
|
|
|
|
|
"définissant des méthodes aux noms particuliers. C'est l'approche utilisée "
|
|
|
|
|
"par Python pour la :dfn:`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 :meth:`__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 :exc:`AttributeError` ou :exc:"
|
|
|
|
|
"`TypeError`)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1091
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Setting a special method to ``None`` indicates that the corresponding "
|
|
|
|
|
"operation is not available. For example, if a class sets :meth:`__iter__` "
|
|
|
|
|
"to ``None``, the class is not iterable, so calling :func:`iter` on its "
|
|
|
|
|
"instances will raise a :exc:`TypeError` (without falling back to :meth:"
|
|
|
|
|
"`__getitem__`). [#]_"
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"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`` à :meth:`__iter__`, la classe n'est pas itérable et appeler :func:"
|
|
|
|
|
"`iter` sur une instance lève :exc:`TypeError` (sans se replier sur :meth:"
|
|
|
|
|
"`__getitem__`) [#]_."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1097
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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 :class:`~xml.dom.NodeList` interface in "
|
|
|
|
|
"the W3C's Document Object Model.)"
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Lorsque vous implémentez une classe qui émule un type natif, il est "
|
|
|
|
|
"important que cette émulation n'implémente que ce qui fait sens pour l'objet "
|
|
|
|
|
"qui est modélisé. Par exemple, la recherche d'éléments individuels d'une "
|
|
|
|
|
"séquence peut faire sens, mais pas l'extraction d'une tranche (un exemple "
|
|
|
|
|
"est l'interface de :class:`~xml.dom.NodeList` dans le modèle objet des "
|
|
|
|
|
"documents W3C)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1108
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Basic customization"
|
2018-04-14 15:00:52 +00:00
|
|
|
|
msgstr "Personnalisation de base"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1114
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to create a new instance of class *cls*. :meth:`__new__` is a static "
|
|
|
|
|
"method (special-cased so you need not declare it as such) that takes the "
|
|
|
|
|
"class of which an instance was requested as its first argument. The "
|
|
|
|
|
"remaining arguments are those passed to the object constructor expression "
|
|
|
|
|
"(the call to the class). The return value of :meth:`__new__` should be the "
|
|
|
|
|
"new object instance (usually an instance of *cls*)."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Appelée pour créer une nouvelle instance de la classe *cls*. La méthode :"
|
|
|
|
|
"meth:`__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 :meth:`__new__` doit être l'instance du nouvel objet "
|
|
|
|
|
"(classiquement une instance de *cls*)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1121
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Typical implementations create a new instance of the class by invoking the "
|
2017-08-01 11:29:09 +00:00
|
|
|
|
"superclass's :meth:`__new__` method using ``super().__new__(cls[, ...])`` "
|
|
|
|
|
"with appropriate arguments and then modifying the newly-created instance as "
|
|
|
|
|
"necessary before returning it."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Une implémentation typique crée une nouvelle instance de la classe en "
|
|
|
|
|
"invoquant la méthode :meth:`__new__` de la superclasse à l'aide de ``super()."
|
|
|
|
|
"__new__(cls[, ...])`` avec les arguments adéquats, puis modifie l'instance "
|
|
|
|
|
"nouvellement créée en tant que de besoin avant de la renvoyer."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1126
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If :meth:`__new__` returns an instance of *cls*, then the new instance's :"
|
|
|
|
|
"meth:`__init__` method will be invoked like ``__init__(self[, ...])``, where "
|
|
|
|
|
"*self* is the new instance and the remaining arguments are the same as were "
|
|
|
|
|
"passed to :meth:`__new__`."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Si :meth:`__new__` renvoie une instance de *cls*, alors la méthode :meth:"
|
|
|
|
|
"`__init__` de la nouvelle instance sera invoquée avec "
|
|
|
|
|
"``__init__(self[, ...])`` où *self* est la nouvelle instance et les autres "
|
|
|
|
|
"arguments sont les mêmes que ceux passés à :meth:`__new__`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1131
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If :meth:`__new__` does not return an instance of *cls*, then the new "
|
|
|
|
|
"instance's :meth:`__init__` method will not be invoked."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Si :meth:`__new__` ne renvoie pas une instance de *cls*, alors la méthode :"
|
|
|
|
|
"meth:`__init__` de la nouvelle instance ne sera pas invoquée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1134
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`__new__` is intended mainly to allow subclasses of immutable types "
|
|
|
|
|
"(like int, str, or tuple) to customize instance creation. It is also "
|
|
|
|
|
"commonly overridden in custom metaclasses in order to customize class "
|
|
|
|
|
"creation."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"L'objectif de :meth:`__new__` est principalement d'autoriser les sous-"
|
|
|
|
|
"classes de types immuables (comme int, str ou tuple) à particulariser la "
|
|
|
|
|
"création des instances. Elle est aussi souvent surchargée dans les "
|
|
|
|
|
"métaclasses pour particulariser la création des classes."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1143
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called after the instance has been created (by :meth:`__new__`), but before "
|
|
|
|
|
"it is returned to the caller. The arguments are those passed to the class "
|
|
|
|
|
"constructor expression. If a base class has an :meth:`__init__` method, the "
|
|
|
|
|
"derived class's :meth:`__init__` method, if any, must explicitly call it to "
|
|
|
|
|
"ensure proper initialization of the base class part of the instance; for "
|
2017-08-01 11:29:09 +00:00
|
|
|
|
"example: ``super().__init__([args...])``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Appelée après la création de l'instance (par :meth:`__new__`), mais avant le "
|
|
|
|
|
"retour vers l'appelant. Les arguments sont ceux passés à l'expression du "
|
|
|
|
|
"constructeur de classe. Si la classe de base possède une méthode :meth:"
|
|
|
|
|
"`__init__`, la méthode :meth:`__init__` de la classe dérivée, si elle "
|
|
|
|
|
"existe, doit être explicitement appelée pour assurer une initialisation "
|
|
|
|
|
"correcte de la partie classe de base de l'instance ; par exemple : ``super()."
|
|
|
|
|
"__init__([args...])``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1150
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Because :meth:`__new__` and :meth:`__init__` work together in constructing "
|
|
|
|
|
"objects (:meth:`__new__` to create it, and :meth:`__init__` to customize "
|
|
|
|
|
"it), no non-``None`` value may be returned by :meth:`__init__`; doing so "
|
|
|
|
|
"will cause a :exc:`TypeError` to be raised at runtime."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Comme :meth:`__new__` et :meth:`__init__` travaillent ensemble pour créer "
|
|
|
|
|
"des objets (:meth:`__new__` pour le créer, :meth:`__init__` pour le "
|
|
|
|
|
"particulariser), :meth:`__init__` ne doit pas renvoyer de valeur``None`` ; "
|
|
|
|
|
"sinon une exception :exc:`TypeError` est levée à l'exécution."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1163
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called when the instance is about to be destroyed. This is also called a "
|
2018-01-04 14:57:05 +00:00
|
|
|
|
"finalizer or (improperly) a destructor. If a base class has a :meth:"
|
|
|
|
|
"`__del__` method, the derived class's :meth:`__del__` method, if any, must "
|
|
|
|
|
"explicitly call it to ensure proper deletion of the base class part of the "
|
|
|
|
|
"instance."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"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 :meth:`__del__`, la méthode :meth:`__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."
|
2018-01-04 14:57:05 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1169
|
|
|
|
|
msgid ""
|
|
|
|
|
"It is possible (though not recommended!) for the :meth:`__del__` method to "
|
|
|
|
|
"postpone destruction of the instance by creating a new reference to it. "
|
|
|
|
|
"This is called object *resurrection*. It is implementation-dependent "
|
|
|
|
|
"whether :meth:`__del__` is called a second time when a resurrected object is "
|
|
|
|
|
"about to be destroyed; the current :term:`CPython` implementation only calls "
|
|
|
|
|
"it once."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Il est possible (mais pas recommandé) que la méthode :meth:`__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, :meth:`__del__` peut être appelée une deuxième fois au "
|
|
|
|
|
"moment où l'objet ressuscité va être détruit ; l'implémentation actuelle de :"
|
|
|
|
|
"term:`CPython` ne l'appelle qu'une fois."
|
2018-01-04 14:57:05 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1176
|
|
|
|
|
msgid ""
|
|
|
|
|
"It is not guaranteed that :meth:`__del__` methods are called for objects "
|
|
|
|
|
"that still exist when the interpreter exits."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Il n'est pas garanti que soient appelées les méthodes :meth:`__del__` des "
|
|
|
|
|
"objets qui existent toujours quand l'interpréteur termine."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1181
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"``del x`` doesn't directly call ``x.__del__()`` --- the former decrements "
|
|
|
|
|
"the reference count for ``x`` by one, and the latter is only called when "
|
2018-01-04 14:57:05 +00:00
|
|
|
|
"``x``'s reference count reaches zero."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"``del x`` n'appelle pas directement ``x.__del__()`` --- il décrémente le "
|
|
|
|
|
"compteur de références de ``x``. La méthode *del* n'est appelée que quand le "
|
|
|
|
|
"compteur de références de ``x`` atteint zéro."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1196
|
2018-01-04 14:57:05 +00:00
|
|
|
|
msgid "Documentation for the :mod:`gc` module."
|
2018-04-14 15:00:52 +00:00
|
|
|
|
msgstr "Documentation du module :mod:`gc`."
|
2018-01-04 14:57:05 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1200
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Due to the precarious circumstances under which :meth:`__del__` methods are "
|
|
|
|
|
"invoked, exceptions that occur during their execution are ignored, and a "
|
2018-01-04 14:57:05 +00:00
|
|
|
|
"warning is printed to ``sys.stderr`` instead. In particular:"
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"En raison des conditions particulières qui règnent quand :meth:`__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 :"
|
2018-01-04 14:57:05 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1204
|
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`__del__` can be invoked when arbitrary code is being executed, "
|
|
|
|
|
"including from any arbitrary thread. If :meth:`__del__` needs to take a "
|
|
|
|
|
"lock or invoke any other blocking resource, it may deadlock as the resource "
|
|
|
|
|
"may already be taken by the code that gets interrupted to execute :meth:"
|
|
|
|
|
"`__del__`."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
":meth:`__del__` peut être invoquée quand du code arbitraire est en cours "
|
|
|
|
|
"d'exécution, et ce dans n'importe quel thread. Si :meth:`__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 :"
|
|
|
|
|
"meth:`__del__`."
|
2018-01-04 14:57:05 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1210
|
|
|
|
|
msgid ""
|
|
|
|
|
":meth:`__del__` can be executed during interpreter shutdown. As a "
|
|
|
|
|
"consequence, the global variables it needs to access (including other "
|
|
|
|
|
"modules) may already have been deleted or set to ``None``. Python guarantees "
|
|
|
|
|
"that globals whose name begins with a single underscore are deleted from "
|
|
|
|
|
"their module before other globals are deleted; if no other references to "
|
|
|
|
|
"such globals exist, this may help in assuring that imported modules are "
|
|
|
|
|
"still available at the time when the :meth:`__del__` method is called."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
":meth:`__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 :meth:`__del__` "
|
|
|
|
|
"est appelée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1225
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called by the :func:`repr` built-in function to compute the \"official\" "
|
|
|
|
|
"string representation of an object. If at all possible, this should look "
|
|
|
|
|
"like a valid Python expression that could be used to recreate an object with "
|
|
|
|
|
"the same value (given an appropriate environment). If this is not possible, "
|
|
|
|
|
"a string of the form ``<...some useful description...>`` should be returned. "
|
|
|
|
|
"The return value must be a string object. If a class defines :meth:"
|
|
|
|
|
"`__repr__` but not :meth:`__str__`, then :meth:`__repr__` is also used when "
|
|
|
|
|
"an \"informal\" string representation of instances of that class is required."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Appelée par la fonction native :func:`rep` pour calculer la représentation "
|
|
|
|
|
"\"officielle\" en chaîne de caractères d'un objet. Tout est fait pour cela "
|
|
|
|
|
"ressemble à une expression Python valide qui peut ê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 :meth:`__repr__` mais pas :meth:`__str__`, alors :meth:"
|
|
|
|
|
"`__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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1234
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This is typically used for debugging, so it is important that the "
|
|
|
|
|
"representation is information-rich and unambiguous."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Cette fonction est principalement utilisée à fins de débogage, il est donc "
|
|
|
|
|
"important que la représentation donne beaucoup d'informations et ne soit pas "
|
|
|
|
|
"ambigüe."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1245
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called by :func:`str(object) <str>` and the built-in functions :func:"
|
|
|
|
|
"`format` and :func:`print` to compute the \"informal\" or nicely printable "
|
|
|
|
|
"string representation of an object. The return value must be a :ref:`string "
|
|
|
|
|
"<textseq>` object."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Appelée par :func:`str(objet)<str>` ainsi que les fonctions natives :func:"
|
|
|
|
|
"`format` et :func:`print` pour calculer une chaîne de caractères \"informelle"
|
|
|
|
|
"\" ou joliment mise en forme de représentation de l'objet. La valeur "
|
|
|
|
|
"renvoyée doit être un objet :ref:`string <textseq>`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1250
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This method differs from :meth:`object.__repr__` in that there is no "
|
|
|
|
|
"expectation that :meth:`__str__` return a valid Python expression: a more "
|
|
|
|
|
"convenient or concise representation can be used."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Cette méthode diffère de :meth:`object.__repr__` car il n'est pas attendu "
|
|
|
|
|
"que :meth:`__str__` renvoie une expression Python valide : une "
|
|
|
|
|
"représentation plus agréable à lire ou plus concise peut être utilisée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1254
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The default implementation defined by the built-in type :class:`object` "
|
|
|
|
|
"calls :meth:`object.__repr__`."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"C'est l'implémentation par défaut des appels à :meth:`object.__repr__` du "
|
|
|
|
|
"type natif :class:`object`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1264
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2017-08-01 11:29:09 +00:00
|
|
|
|
"Called by :ref:`bytes <func-bytes>` to compute a byte-string representation "
|
|
|
|
|
"of an object. This should return a :class:`bytes` object."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Appelée par :ref:`bytes <func-bytes>` pour calculer une représentation en "
|
|
|
|
|
"chaîne *bytes* d'un objet. Elle doit renvoyer un objet :class:`bytes`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1275
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called by the :func:`format` built-in function, and by extension, evaluation "
|
|
|
|
|
"of :ref:`formatted string literals <f-strings>` and the :meth:`str.format` "
|
|
|
|
|
"method, to produce a \"formatted\" string representation of an object. The "
|
|
|
|
|
"``format_spec`` argument is a string that contains a description of the "
|
|
|
|
|
"formatting options desired. The interpretation of the ``format_spec`` "
|
|
|
|
|
"argument is up to the type implementing :meth:`__format__`, however most "
|
|
|
|
|
"classes will either delegate formatting to one of the built-in types, or use "
|
|
|
|
|
"a similar formatting option syntax."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Appelée par la fonction native :func:`format` et, par extension, lors de "
|
|
|
|
|
"l'évaluation de :ref:`formatted string literals <f-strings>` ou de la "
|
|
|
|
|
"méthode :meth:`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 :meth:`__format__`. Cependant, la plupart des classes délèguent "
|
|
|
|
|
"le formatage aux types natifs ou utilisent une syntaxe similaire d'options "
|
|
|
|
|
"de formatage."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1285
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"See :ref:`formatspec` for a description of the standard formatting syntax."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Lisez :ref:`formatspec` pour une description de la syntaxe standard du "
|
|
|
|
|
"formatage."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1287
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "The return value must be a string object."
|
2018-04-14 15:00:52 +00:00
|
|
|
|
msgstr "La valeur renvoyée doit être un objet chaîne de caractères."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1289
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The __format__ method of ``object`` itself raises a :exc:`TypeError` if "
|
|
|
|
|
"passed any non-empty string."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"La méthode __format__ de ``object`` lui-même lève une :exc:`TypeError` si "
|
|
|
|
|
"vous lui passez une chaîne non vide."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1305
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"These are the so-called \"rich comparison\" methods. The correspondence "
|
|
|
|
|
"between operator symbols and method names is as follows: ``x<y`` calls ``x."
|
|
|
|
|
"__lt__(y)``, ``x<=y`` calls ``x.__le__(y)``, ``x==y`` calls ``x.__eq__(y)``, "
|
|
|
|
|
"``x!=y`` calls ``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` "
|
|
|
|
|
"calls ``x.__ge__(y)``."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"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)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1311
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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 :func:`bool` on the value to determine if the "
|
|
|
|
|
"result is true or false."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Une méthode de comparaison riche peut renvoyer le singleton "
|
|
|
|
|
"``NotImplemented`` si elle n'implémente pas l'opération pour une paire "
|
|
|
|
|
"donnée d'arguments. Par convention, ``False`` et ``True`` sont renvoyées "
|
|
|
|
|
"pour une comparaison qui a réussi. Cependant, ces méthodes peuvent renvoyer "
|
|
|
|
|
"n'importe quelle valeur donc, si l'opérateur de comparaison est utilisé dans "
|
|
|
|
|
"un contexte booléen (par exemple dans une condition d'une instruction "
|
|
|
|
|
"``if``), Python appelle :func:`bool` sur la valeur pour déterminer si le "
|
|
|
|
|
"résultat est faux ou vrai."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1318
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"By default, :meth:`__ne__` delegates to :meth:`__eq__` and inverts the "
|
|
|
|
|
"result unless it is ``NotImplemented``. There are no other implied "
|
|
|
|
|
"relationships among the comparison operators, 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 :func:`functools."
|
|
|
|
|
"total_ordering`."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Par défaut, :meth:`__ne__` délègue à :meth:`__eq__` et renvoie le résultat "
|
|
|
|
|
"inverse, sauf si c'est ``NotImplemented``. Il n'y a pas d'autres relations "
|
|
|
|
|
"implicites pour les opérateurs de comparaison. Par exemple, ``(x<y or "
|
|
|
|
|
"x==y)`` n'implique pas ``x<=y``. Pour obtenir une fonction d'ordre total "
|
|
|
|
|
"automatique à partir d'une seule opération, reportez-vous à :func:`functools."
|
|
|
|
|
"total_ordering`."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1325
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"See the paragraph on :meth:`__hash__` for some important notes on creating :"
|
|
|
|
|
"term:`hashable` objects which support custom comparison operations and are "
|
|
|
|
|
"usable as dictionary keys."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Lisez le paragraphe :meth:`__hash__` pour connaitre certaines notions "
|
|
|
|
|
"importantes relatives à la création d'objets :term:`hashable` qui acceptent "
|
|
|
|
|
"les opérations de comparaison personnalisées et qui sont utilisables en tant "
|
|
|
|
|
"que clés de dictionnaires."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1329
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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, :meth:`__lt__` and :meth:`__gt__` are each other's reflection, :meth:"
|
|
|
|
|
"`__le__` and :meth:`__ge__` are each other's reflection, and :meth:`__eq__` "
|
|
|
|
|
"and :meth:`__ne__` are their own reflection. If the operands are of "
|
|
|
|
|
"different types, and 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."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Il n'y a pas de versions avec les arguments interchangés de ces "
|
|
|
|
|
"méthodes (qui seraient utilisées quand l'argument de gauche ne connaît pas "
|
|
|
|
|
"l'opération alors que l'argument de droite la connaît) ; en lieu et place, :"
|
|
|
|
|
"meth:`__lt__` et :meth:`__gt__` sont la réflexion l'une de l'autre, :meth:"
|
|
|
|
|
"`__le__` et :meth:`__ge__` sont la réflexion l'une de l'autre et :meth:"
|
|
|
|
|
"`__eq__` ainsi que :meth:`__ne__` sont réflexives. Si les opérandes sont de "
|
|
|
|
|
"types différents et que l'opérande de droite est d'un type qui une sous-"
|
|
|
|
|
"classe directe ou indirecte du type de l'opérande de gauche, alors la "
|
|
|
|
|
"méthode réfléchie de l'opérande de droite est prioritaire, sinon c'est la "
|
|
|
|
|
"méthode de l'opérande de droite qui est prioritaire. Les sous-classes "
|
|
|
|
|
"virtuelles ne sont pas prises en compte."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1346
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called by built-in function :func:`hash` and for operations on members of "
|
|
|
|
|
"hashed collections including :class:`set`, :class:`frozenset`, and :class:"
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"`dict`. :meth:`__hash__` should return an integer. The only required "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"property is that objects which compare equal have the same hash value; it is "
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"advised to mix together the hash values of the components of the object that "
|
|
|
|
|
"also play a part in comparison of objects by packing them into a tuple and "
|
|
|
|
|
"hashing the tuple. Example::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Appelée par la fonction native :func:`hash` et par les opérations sur les "
|
|
|
|
|
"membres de collections hachées, ce qui comprend :class:`set`, :class:"
|
|
|
|
|
"`frozenset` et :class:`dict`. :meth:`__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 "
|
|
|
|
|
"de la comparaison des objets, en les plaçant un tuple dont on calcule "
|
|
|
|
|
"l'empreinte. Par exemple ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1359
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":func:`hash` truncates the value returned from an object's custom :meth:"
|
|
|
|
|
"`__hash__` method to the size of a :c:type:`Py_ssize_t`. This is typically "
|
|
|
|
|
"8 bytes on 64-bit builds and 4 bytes on 32-bit builds. If an object's :"
|
|
|
|
|
"meth:`__hash__` must interoperate on builds of different bit sizes, be sure "
|
|
|
|
|
"to check the width on all supported builds. An easy way to do this is with "
|
|
|
|
|
"``python -c \"import sys; print(sys.hash_info.width)\"``."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
":func:`hash` limite la valeur renvoyée d'un objet ayant une méthode :meth:"
|
|
|
|
|
"`__hash__` personnalisée à la taille d'un :c:type:`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 :meth:`__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)\"``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1367
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If a class does not define an :meth:`__eq__` method it should not define a :"
|
|
|
|
|
"meth:`__hash__` operation either; if it defines :meth:`__eq__` but not :meth:"
|
|
|
|
|
"`__hash__`, its instances will not be usable as items in hashable "
|
|
|
|
|
"collections. If a class defines mutable objects and implements an :meth:"
|
|
|
|
|
"`__eq__` method, it should not implement :meth:`__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)."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Si une classe ne définit pas de méthode :meth:`__eq__` , elle ne doit pas "
|
|
|
|
|
"définir l'opération :meth:`__hash__` non plus ; si elle définit :meth:"
|
|
|
|
|
"`__eq__` mais pas :meth:`__hash__`, les instances ne peuvent pas être "
|
|
|
|
|
"utilisées en tant qu'élément dans une collection de hachables. Si une classe "
|
|
|
|
|
"définit des objets mutables et implémente la méthode :meth:`__eq__`, elle ne "
|
|
|
|
|
"doit pas implémenter :meth:`__hash__` puisque l'implémentation des "
|
|
|
|
|
"collections hachables requiert que les clés soient des empreintes immuables "
|
|
|
|
|
"(si l'empreinte d'un objet change, il ne sera plus trouvé correctement dans "
|
|
|
|
|
"le stockage du dictionnaire)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1376
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"User-defined classes have :meth:`__eq__` and :meth:`__hash__` methods by "
|
|
|
|
|
"default; 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)``."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Les classes définies par l'utilisateur possèdent des méthodes :meth:`__eq__` "
|
|
|
|
|
"et :meth:`__hash__` par défaut ; ces méthodes répondent que tous les objets "
|
|
|
|
|
"sont différents (sauf avec eux-mêmes) et ``x.__hash__()`` renvoie une valeur "
|
|
|
|
|
"telle que ``x == y`` implique à la fois ``x is y`` et ``hash(x) == hash(y)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1381
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A class that overrides :meth:`__eq__` and does not define :meth:`__hash__` "
|
|
|
|
|
"will have its :meth:`__hash__` implicitly set to ``None``. When the :meth:"
|
|
|
|
|
"`__hash__` method of a class is ``None``, instances of the class will raise "
|
|
|
|
|
"an appropriate :exc:`TypeError` when a program attempts to retrieve their "
|
|
|
|
|
"hash value, and will also be correctly identified as unhashable when "
|
|
|
|
|
"checking ``isinstance(obj, collections.Hashable)``."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Une classe qui surcharge :meth:`__eq__` et qui ne définit pas :meth:"
|
|
|
|
|
"`__hash__` a sa méthode :meth:`__hash__` implicitement assignée à ``None``. "
|
|
|
|
|
"Quand la méthode :meth:`__hash__` d'une classe est ``None``, une instance de "
|
|
|
|
|
"cette classe lève :exc:`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.Hashable)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1388
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If a class that overrides :meth:`__eq__` needs to retain the implementation "
|
|
|
|
|
"of :meth:`__hash__` from a parent class, the interpreter must be told this "
|
|
|
|
|
"explicitly by setting ``__hash__ = <ParentClass>.__hash__``."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Si une classe qui surcharge :meth:`__eq__` a besoin de conserver "
|
|
|
|
|
"l'implémentation de :meth:`__hash__` de la classe parente, vous devez "
|
|
|
|
|
"l'indiquer explicitement à l'interpréteur en définissant ``__hash__ = "
|
|
|
|
|
"<ClasseParente>.__hash__``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1392
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If a class that does not override :meth:`__eq__` wishes to suppress hash "
|
|
|
|
|
"support, it should include ``__hash__ = None`` in the class definition. A "
|
|
|
|
|
"class which defines its own :meth:`__hash__` that explicitly raises a :exc:"
|
|
|
|
|
"`TypeError` would be incorrectly identified as hashable by an "
|
|
|
|
|
"``isinstance(obj, collections.Hashable)`` call."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Si une classe ne surcharge pas :meth:`__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 :meth:`__hash__` qui "
|
|
|
|
|
"lève une :exc:`TypeError` serait incorrectement identifiée comme hachable "
|
|
|
|
|
"par un appel à ``isinstance(obj, collections.Hashable)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1401
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"By default, the :meth:`__hash__` values of str, bytes and datetime objects "
|
|
|
|
|
"are \"salted\" with an unpredictable random value. Although they remain "
|
|
|
|
|
"constant within an individual Python process, they are not predictable "
|
|
|
|
|
"between repeated invocations of Python."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Par défaut, les valeurs renvoyées par :meth:`__hash__` pour les chaînes, "
|
|
|
|
|
"*bytes* et objets datetime 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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1406
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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(n^2) complexity. See http://www.ocert.org/advisories/"
|
|
|
|
|
"ocert-2011-003.html for details."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"C'est un comportement voulu pour se protéger contre un déni de service qui "
|
|
|
|
|
"utiliserait des entrées malicieusement choisies pour effectuer des "
|
|
|
|
|
"insertions dans le dictionnaire dans le pire cas, avec une complexité en "
|
|
|
|
|
"O(n^2). Lisez http://www.ocert.org/advisories/ocert-2011-003.html pour en "
|
|
|
|
|
"obtenir les détails."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1411
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Changing hash values affects the iteration order of dicts, sets and other "
|
|
|
|
|
"mappings. Python has never made guarantees about this ordering (and it "
|
|
|
|
|
"typically varies between 32-bit and 64-bit builds)."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Modifier les empreintes obtenues par hachage modifie l'ordre d'itération sur "
|
|
|
|
|
"les dictionnaires, les ensembles et les autres tableaux de correspondances. "
|
|
|
|
|
"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)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1415
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "See also :envvar:`PYTHONHASHSEED`."
|
|
|
|
|
msgstr "Voir aussi :envvar:`PYTHONHASHSEED`."
|
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1417
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Hash randomization is enabled by default."
|
2018-04-14 15:00:52 +00:00
|
|
|
|
msgstr "la randomisation des empreintes est activée par défaut."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1425
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement truth value testing and the built-in operation "
|
|
|
|
|
"``bool()``; should return ``False`` or ``True``. When this method is not "
|
|
|
|
|
"defined, :meth:`__len__` is called, if it is defined, and the object is "
|
|
|
|
|
"considered true if its result is nonzero. If a class defines neither :meth:"
|
|
|
|
|
"`__len__` nor :meth:`__bool__`, all its instances are considered true."
|
|
|
|
|
msgstr ""
|
2018-04-14 15:00:52 +00:00
|
|
|
|
"Appelée pour implémenter le test de vérité et l'opération native "
|
|
|
|
|
"``bool()`` ; elle doit renvoyer ``False`` ou ``True``. Quand cette méthode "
|
|
|
|
|
"n'est pas définie, :meth:`__len__` est appelée, si elle est définie, et "
|
|
|
|
|
"l'objet est considéré vrai si le résultat est non nul. Si une classe ne "
|
|
|
|
|
"définit ni :meth:`__len__` ni :meth:`__bool__`, toutes ses instances sont "
|
|
|
|
|
"considérées comme vraies."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1436
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Customizing attribute access"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1438
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The following methods can be defined to customize the meaning of attribute "
|
|
|
|
|
"access (use of, assignment to, or deletion of ``x.name``) for class "
|
|
|
|
|
"instances."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1446
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2018-02-08 09:02:29 +00:00
|
|
|
|
"Called when the default attribute access fails with an :exc:`AttributeError` "
|
|
|
|
|
"(either :meth:`__getattribute__` raises an :exc:`AttributeError` because "
|
|
|
|
|
"*name* is not an instance attribute or an attribute in the class tree for "
|
|
|
|
|
"``self``; or :meth:`__get__` of a *name* property raises :exc:"
|
|
|
|
|
"`AttributeError`). This method should either return the (computed) "
|
|
|
|
|
"attribute value or raise an :exc:`AttributeError` exception."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1453
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Note that if the attribute is found through the normal mechanism, :meth:"
|
|
|
|
|
"`__getattr__` is not called. (This is an intentional asymmetry between :"
|
|
|
|
|
"meth:`__getattr__` and :meth:`__setattr__`.) This is done both for "
|
|
|
|
|
"efficiency reasons and because otherwise :meth:`__getattr__` would have no "
|
|
|
|
|
"way to access other attributes of the instance. Note that at least for "
|
|
|
|
|
"instance variables, you can fake total control by not inserting any values "
|
|
|
|
|
"in the instance attribute dictionary (but instead inserting them in another "
|
|
|
|
|
"object). See the :meth:`__getattribute__` method below for a way to "
|
|
|
|
|
"actually get total control over attribute access."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1466
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called unconditionally to implement attribute accesses for instances of the "
|
|
|
|
|
"class. If the class also defines :meth:`__getattr__`, the latter will not be "
|
|
|
|
|
"called unless :meth:`__getattribute__` either calls it explicitly or raises "
|
|
|
|
|
"an :exc:`AttributeError`. This method should return the (computed) attribute "
|
|
|
|
|
"value or raise an :exc:`AttributeError` exception. In order to avoid "
|
|
|
|
|
"infinite recursion in this method, its implementation should always call the "
|
|
|
|
|
"base class method with the same name to access any attributes it needs, for "
|
|
|
|
|
"example, ``object.__getattribute__(self, name)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1477
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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 :ref:`special-lookup`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1484
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called when an attribute assignment is attempted. This is called instead of "
|
|
|
|
|
"the normal mechanism (i.e. store the value in the instance dictionary). "
|
|
|
|
|
"*name* is the attribute name, *value* is the value to be assigned to it."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1488
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If :meth:`__setattr__` wants to assign to an instance attribute, it should "
|
|
|
|
|
"call the base class method with the same name, for example, ``object."
|
|
|
|
|
"__setattr__(self, name, value)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1495
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Like :meth:`__setattr__` but for attribute deletion instead of assignment. "
|
|
|
|
|
"This should only be implemented if ``del obj.name`` is meaningful for the "
|
|
|
|
|
"object."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1501
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called when :func:`dir` is called on the object. A sequence must be "
|
|
|
|
|
"returned. :func:`dir` converts the returned sequence to a list and sorts it."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-01-04 14:57:05 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1506
|
2018-02-08 09:02:29 +00:00
|
|
|
|
msgid "Customizing module attribute access"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1511
|
|
|
|
|
msgid ""
|
|
|
|
|
"For a more fine grained customization of the module behavior (setting "
|
|
|
|
|
"attributes, properties, etc.), one can set the ``__class__`` attribute of a "
|
|
|
|
|
"module object to a subclass of :class:`types.ModuleType`. For example::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1529
|
|
|
|
|
msgid ""
|
|
|
|
|
"Setting module ``__class__`` only affects lookups made using the attribute "
|
|
|
|
|
"access syntax -- directly accessing the module globals (whether by code "
|
|
|
|
|
"within the module, or via a reference to the module's globals dictionary) is "
|
|
|
|
|
"unaffected."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1534
|
|
|
|
|
msgid "``__class__`` module attribute is now writable."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1541
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Implementing Descriptors"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1543
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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' :attr:`~object.__dict__`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1553
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to get the attribute of the owner class (class attribute access) or "
|
|
|
|
|
"of an instance of that class (instance attribute access). *owner* is always "
|
|
|
|
|
"the owner class, while *instance* is the instance that the attribute was "
|
|
|
|
|
"accessed through, or ``None`` when the attribute is accessed through the "
|
|
|
|
|
"*owner*. This method should return the (computed) attribute value or raise "
|
|
|
|
|
"an :exc:`AttributeError` exception."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1563
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to set the attribute on an instance *instance* of the owner class to "
|
|
|
|
|
"a new value, *value*."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1569
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to delete the attribute on an instance *instance* of the owner class."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1574
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called at the time the owning class *owner* is created. The descriptor has "
|
|
|
|
|
"been assigned to *name*."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1580
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The attribute :attr:`__objclass__` is interpreted by the :mod:`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)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1591
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Invoking Descriptors"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1593
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In general, a descriptor is an object attribute with \"binding behavior\", "
|
|
|
|
|
"one whose attribute access has been overridden by methods in the descriptor "
|
|
|
|
|
"protocol: :meth:`__get__`, :meth:`__set__`, and :meth:`__delete__`. If any "
|
|
|
|
|
"of those methods are defined for an object, it is said to be a descriptor."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1598
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The default behavior for attribute access is to get, set, or delete the "
|
|
|
|
|
"attribute from an object's dictionary. For instance, ``a.x`` has a lookup "
|
|
|
|
|
"chain starting with ``a.__dict__['x']``, then ``type(a).__dict__['x']``, and "
|
|
|
|
|
"continuing through the base classes of ``type(a)`` excluding metaclasses."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1603
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"However, if the looked-up value is an object defining one of the descriptor "
|
|
|
|
|
"methods, then Python may override the default behavior and invoke the "
|
|
|
|
|
"descriptor method instead. Where this occurs in the precedence chain "
|
|
|
|
|
"depends on which descriptor methods were defined and how they were called."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1608
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The starting point for descriptor invocation is a binding, ``a.x``. How the "
|
|
|
|
|
"arguments are assembled depends on ``a``:"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1613
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Direct Call"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1612
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The simplest and least common call is when user code directly invokes a "
|
|
|
|
|
"descriptor method: ``x.__get__(a)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1617
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Instance Binding"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1616
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If binding to an object instance, ``a.x`` is transformed into the call: "
|
|
|
|
|
"``type(a).__dict__['x'].__get__(a, type(a))``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1621
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Class Binding"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1620
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If binding to a class, ``A.x`` is transformed into the call: ``A."
|
|
|
|
|
"__dict__['x'].__get__(None, A)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1627
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Super Binding"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1624
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If ``a`` is an instance of :class:`super`, then the binding ``super(B, obj)."
|
|
|
|
|
"m()`` searches ``obj.__class__.__mro__`` for the base class ``A`` "
|
|
|
|
|
"immediately preceding ``B`` and then invokes the descriptor with the call: "
|
|
|
|
|
"``A.__dict__['m'].__get__(obj, obj.__class__)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1629
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For instance bindings, the precedence of descriptor invocation depends on "
|
|
|
|
|
"the which descriptor methods are defined. A descriptor can define any "
|
|
|
|
|
"combination of :meth:`__get__`, :meth:`__set__` and :meth:`__delete__`. If "
|
|
|
|
|
"it does not define :meth:`__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 :meth:`__set__` and/or :meth:"
|
|
|
|
|
"`__delete__`, it is a data descriptor; if it defines neither, it is a non-"
|
|
|
|
|
"data descriptor. Normally, data descriptors define both :meth:`__get__` "
|
|
|
|
|
"and :meth:`__set__`, while non-data descriptors have just the :meth:"
|
|
|
|
|
"`__get__` method. Data descriptors with :meth:`__set__` and :meth:`__get__` "
|
|
|
|
|
"defined always override a redefinition in an instance dictionary. In "
|
|
|
|
|
"contrast, non-data descriptors can be overridden by instances."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1642
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Python methods (including :func:`staticmethod` and :func:`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."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1647
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :func:`property` function is implemented as a data descriptor. "
|
|
|
|
|
"Accordingly, instances cannot override the behavior of a property."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1654
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "__slots__"
|
|
|
|
|
msgstr "__slots__"
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1656
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2018-03-23 08:57:03 +00:00
|
|
|
|
"*__slots__* allow us to explicitly declare data members (like properties) "
|
|
|
|
|
"and deny the creation of *__dict__* and *__weakref__* (unless explicitly "
|
|
|
|
|
"declared in *__slots__* or available in a parent.)"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-02-08 09:02:29 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1660
|
2018-03-23 08:57:03 +00:00
|
|
|
|
msgid "The space saved over using *__dict__* can be significant."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1664
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This class variable can be assigned a string, iterable, or sequence of "
|
|
|
|
|
"strings with variable names used by instances. *__slots__* reserves space "
|
|
|
|
|
"for the declared variables and prevents the automatic creation of *__dict__* "
|
|
|
|
|
"and *__weakref__* for each instance."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1671
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Notes on using *__slots__*"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1673
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2018-03-23 08:57:03 +00:00
|
|
|
|
"When inheriting from a class without *__slots__*, the *__dict__* and "
|
|
|
|
|
"*__weakref__* attribute of the instances will always be accessible."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1676
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Without a *__dict__* variable, instances cannot be assigned new variables "
|
|
|
|
|
"not listed in the *__slots__* definition. Attempts to assign to an unlisted "
|
|
|
|
|
"variable name raises :exc:`AttributeError`. If dynamic assignment of new "
|
|
|
|
|
"variables is desired, then add ``'__dict__'`` to the sequence of strings in "
|
|
|
|
|
"the *__slots__* declaration."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1682
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Without a *__weakref__* variable for each instance, classes defining "
|
|
|
|
|
"*__slots__* do not support weak references to its instances. If weak "
|
|
|
|
|
"reference support is needed, then add ``'__weakref__'`` to the sequence of "
|
|
|
|
|
"strings in the *__slots__* declaration."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1687
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"*__slots__* are implemented at the class level by creating descriptors (:ref:"
|
|
|
|
|
"`descriptors`) for each variable name. As a result, class attributes cannot "
|
|
|
|
|
"be used to set default values for instance variables defined by *__slots__*; "
|
|
|
|
|
"otherwise, the class attribute would overwrite the descriptor assignment."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1693
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2018-03-23 08:57:03 +00:00
|
|
|
|
"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, child subclasses will get a *__dict__* and *__weakref__* unless "
|
|
|
|
|
"they also define *__slots__* (which should only contain names of any "
|
|
|
|
|
"*additional* slots)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1699
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If a class defines a slot also defined in a base class, the instance "
|
|
|
|
|
"variable defined by the base class slot is inaccessible (except by "
|
|
|
|
|
"retrieving its descriptor directly from the base class). This renders the "
|
|
|
|
|
"meaning of the program undefined. In the future, a check may be added to "
|
|
|
|
|
"prevent this."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1704
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Nonempty *__slots__* does not work for classes derived from \"variable-length"
|
|
|
|
|
"\" built-in types such as :class:`int`, :class:`bytes` and :class:`tuple`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1707
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Any non-string iterable may be assigned to *__slots__*. Mappings may also be "
|
|
|
|
|
"used; however, in the future, special meaning may be assigned to the values "
|
|
|
|
|
"corresponding to each key."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1711
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"*__class__* assignment works only if both classes have the same *__slots__*."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1713
|
|
|
|
|
msgid ""
|
|
|
|
|
"Multiple inheritance with multiple slotted parent classes can be used, but "
|
|
|
|
|
"only one parent is allowed to have attributes created by slots (the other "
|
|
|
|
|
"bases must have empty slot layouts) - violations raise :exc:`TypeError`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:1721
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Customizing class creation"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1723
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Whenever a class inherits from another class, *__init_subclass__* is called "
|
|
|
|
|
"on that class. This way, it is possible to write classes which change the "
|
|
|
|
|
"behavior of subclasses. This is closely related to class decorators, but "
|
|
|
|
|
"where class decorators only affect the specific class they're applied to, "
|
|
|
|
|
"``__init_subclass__`` solely applies to future subclasses of the class "
|
|
|
|
|
"defining the method."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1732
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This method is called whenever the containing class is subclassed. *cls* is "
|
|
|
|
|
"then the new subclass. If defined as a normal instance method, this method "
|
|
|
|
|
"is implicitly converted to a class method."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1736
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Keyword arguments which are given to a new class are passed to the parent's "
|
|
|
|
|
"class ``__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::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1750
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The default implementation ``object.__init_subclass__`` does nothing, but "
|
|
|
|
|
"raises an error if it is called with any arguments."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1755
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The metaclass hint ``metaclass`` is consumed by the rest of the type "
|
|
|
|
|
"machinery, and is never passed to ``__init_subclass__`` implementations. The "
|
|
|
|
|
"actual metaclass (rather than the explicit hint) can be accessed as "
|
|
|
|
|
"``type(cls)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1766
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Metaclasses"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1772
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"By default, classes are constructed using :func:`type`. The class body is "
|
|
|
|
|
"executed in a new namespace and the class name is bound locally to the "
|
|
|
|
|
"result of ``type(name, bases, namespace)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1776
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The class creation process can be customized by passing the ``metaclass`` "
|
|
|
|
|
"keyword argument in the class definition line, or by inheriting from an "
|
|
|
|
|
"existing class that included such an argument. In the following example, "
|
|
|
|
|
"both ``MyClass`` and ``MySubclass`` are instances of ``Meta``::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1790
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Any other keyword arguments that are specified in the class definition are "
|
|
|
|
|
"passed through to all metaclass operations described below."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1793
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "When a class definition is executed, the following steps occur:"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1795
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "the appropriate metaclass is determined"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1796
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "the class namespace is prepared"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1797
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "the class body is executed"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1798
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "the class object is created"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1801
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Determining the appropriate metaclass"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1805
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The appropriate metaclass for a class definition is determined as follows:"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1807
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"if no bases and no explicit metaclass are given, then :func:`type` is used"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1808
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"if an explicit metaclass is given and it is *not* an instance of :func:"
|
|
|
|
|
"`type`, then it is used directly as the metaclass"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1810
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"if an instance of :func:`type` is given as the explicit metaclass, or bases "
|
|
|
|
|
"are defined, then the most derived metaclass is used"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1813
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The most derived metaclass is selected from the explicitly specified "
|
|
|
|
|
"metaclass (if any) and the metaclasses (i.e. ``type(cls)``) of all specified "
|
|
|
|
|
"base classes. The most derived metaclass is one which is a subtype of *all* "
|
|
|
|
|
"of these candidate metaclasses. If none of the candidate metaclasses meets "
|
|
|
|
|
"that criterion, then the class definition will fail with ``TypeError``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1823
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Preparing the class namespace"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1828
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Once the appropriate metaclass has been identified, then the class namespace "
|
|
|
|
|
"is prepared. If the metaclass has a ``__prepare__`` attribute, it is called "
|
|
|
|
|
"as ``namespace = metaclass.__prepare__(name, bases, **kwds)`` (where the "
|
|
|
|
|
"additional keyword arguments, if any, come from the class definition)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1833
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If the metaclass has no ``__prepare__`` attribute, then the class namespace "
|
|
|
|
|
"is initialised as an empty ordered mapping."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1838
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":pep:`3115` - Metaclasses in Python 3000"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1839
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Introduced the ``__prepare__`` namespace hook"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1843
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Executing the class body"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1848
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The class body is executed (approximately) as ``exec(body, globals(), "
|
|
|
|
|
"namespace)``. The key difference from a normal call to :func:`exec` is that "
|
|
|
|
|
"lexical scoping allows the class body (including any methods) to reference "
|
|
|
|
|
"names from the current and outer scopes when the class definition occurs "
|
|
|
|
|
"inside a function."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1854
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"However, even when the class definition occurs inside the function, methods "
|
|
|
|
|
"defined inside the class still cannot see names defined at the class scope. "
|
|
|
|
|
"Class variables must be accessed through the first parameter of instance or "
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"class methods, or through the implicit lexically scoped ``__class__`` "
|
|
|
|
|
"reference described in the next section."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1863
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Creating the class object"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1870
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Once the class namespace has been populated by executing the class body, the "
|
|
|
|
|
"class object is created by calling ``metaclass(name, bases, namespace, "
|
|
|
|
|
"**kwds)`` (the additional keywords passed here are the same as those passed "
|
|
|
|
|
"to ``__prepare__``)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1875
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This class object is the one that will be referenced by the zero-argument "
|
|
|
|
|
"form of :func:`super`. ``__class__`` is an implicit closure reference "
|
|
|
|
|
"created by the compiler if any methods in a class body refer to either "
|
|
|
|
|
"``__class__`` or ``super``. This allows the zero argument form of :func:"
|
|
|
|
|
"`super` to correctly identify the class being defined based on lexical "
|
|
|
|
|
"scoping, while the class or instance that was used to make the current call "
|
|
|
|
|
"is identified based on the first argument passed to the method."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1885
|
2017-04-02 20:14:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In CPython 3.6 and later, the ``__class__`` cell is passed to the metaclass "
|
|
|
|
|
"as a ``__classcell__`` entry in the class namespace. If present, this must "
|
|
|
|
|
"be propagated up to the ``type.__new__`` call in order for the class to be "
|
|
|
|
|
"initialised correctly. Failing to do so will result in a :exc:"
|
|
|
|
|
"`DeprecationWarning` in Python 3.6, and a :exc:`RuntimeWarning` in the "
|
|
|
|
|
"future."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1892
|
2017-04-02 20:14:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"When using the default metaclass :class:`type`, or any metaclass that "
|
|
|
|
|
"ultimately calls ``type.__new__``, the following additional customisation "
|
|
|
|
|
"steps are invoked after creating the class object:"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1896
|
2017-04-02 20:14:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"first, ``type.__new__`` collects all of the descriptors in the class "
|
|
|
|
|
"namespace that define a :meth:`~object.__set_name__` method;"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1898
|
2017-04-02 20:14:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"second, all of these ``__set_name__`` methods are called with the class "
|
|
|
|
|
"being defined and the assigned name of that particular descriptor; and"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1900
|
2017-04-02 20:14:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"finally, the :meth:`~object.__init_subclass__` hook is called on the "
|
|
|
|
|
"immediate parent of the new class in its method resolution order."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1903
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"After the class object is created, it is passed to the class decorators "
|
|
|
|
|
"included in the class definition (if any) and the resulting object is bound "
|
|
|
|
|
"in the local namespace as the defined class."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1907
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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 :attr:`~object.__dict__` attribute of the class object."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1914
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":pep:`3135` - New super"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1915
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Describes the implicit ``__class__`` closure reference"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1919
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Metaclass example"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1921
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The potential uses for metaclasses are boundless. Some ideas that have been "
|
2017-09-21 07:23:18 +00:00
|
|
|
|
"explored include enum, logging, interface checking, automatic delegation, "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"automatic property creation, proxies, frameworks, and automatic resource "
|
|
|
|
|
"locking/synchronization."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1926
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Here is an example of a metaclass that uses an :class:`collections."
|
|
|
|
|
"OrderedDict` to remember the order that class variables are defined::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1949
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"When the class definition for *A* gets executed, the process begins with "
|
|
|
|
|
"calling the metaclass's :meth:`__prepare__` method which returns an empty :"
|
|
|
|
|
"class:`collections.OrderedDict`. That mapping records the methods and "
|
|
|
|
|
"attributes of *A* as they are defined within the body of the class "
|
|
|
|
|
"statement. Once those definitions are executed, the ordered dictionary is "
|
|
|
|
|
"fully populated and the metaclass's :meth:`__new__` method gets invoked. "
|
|
|
|
|
"That method builds the new type and it saves the ordered dictionary keys in "
|
|
|
|
|
"an attribute called ``members``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1960
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Customizing instance and subclass checks"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1962
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The following methods are used to override the default behavior of the :func:"
|
|
|
|
|
"`isinstance` and :func:`issubclass` built-in functions."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1965
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In particular, the metaclass :class:`abc.ABCMeta` implements these methods "
|
|
|
|
|
"in order to allow the addition of Abstract Base Classes (ABCs) as \"virtual "
|
|
|
|
|
"base classes\" to any class or type (including built-in types), including "
|
|
|
|
|
"other ABCs."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1972
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return true if *instance* should be considered a (direct or indirect) "
|
|
|
|
|
"instance of *class*. If defined, called to implement ``isinstance(instance, "
|
|
|
|
|
"class)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1979
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Return true if *subclass* should be considered a (direct or indirect) "
|
|
|
|
|
"subclass of *class*. If defined, called to implement ``issubclass(subclass, "
|
|
|
|
|
"class)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1984
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Note that these methods are looked up on the type (metaclass) of a class. "
|
|
|
|
|
"They cannot be defined as class methods in the actual class. This is "
|
|
|
|
|
"consistent with the lookup of special methods that are called on instances, "
|
|
|
|
|
"only in this case the instance is itself a class."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1995
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":pep:`3119` - Introducing Abstract Base Classes"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:1992
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Includes the specification for customizing :func:`isinstance` and :func:"
|
|
|
|
|
"`issubclass` behavior through :meth:`~class.__instancecheck__` and :meth:"
|
|
|
|
|
"`~class.__subclasscheck__`, with motivation for this functionality in the "
|
|
|
|
|
"context of adding Abstract Base Classes (see the :mod:`abc` module) to the "
|
|
|
|
|
"language."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2002
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Emulating callable objects"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2009
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called when the instance is \"called\" as a function; if this method is "
|
|
|
|
|
"defined, ``x(arg1, arg2, ...)`` is a shorthand for ``x.__call__(arg1, "
|
|
|
|
|
"arg2, ...)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2016
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Emulating container types"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2018
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The following methods can be defined to implement container objects. "
|
|
|
|
|
"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 :meth:`keys`, :meth:`values`, :meth:`items`, :"
|
|
|
|
|
"meth:`get`, :meth:`clear`, :meth:`setdefault`, :meth:`pop`, :meth:"
|
|
|
|
|
"`popitem`, :meth:`!copy`, and :meth:`update` behaving similar to those for "
|
|
|
|
|
"Python's standard dictionary objects. The :mod:`collections` module "
|
|
|
|
|
"provides a :class:`~collections.abc.MutableMapping` abstract base class to "
|
|
|
|
|
"help create those methods from a base set of :meth:`__getitem__`, :meth:"
|
|
|
|
|
"`__setitem__`, :meth:`__delitem__`, and :meth:`keys`. Mutable sequences "
|
|
|
|
|
"should provide methods :meth:`append`, :meth:`count`, :meth:`index`, :meth:"
|
|
|
|
|
"`extend`, :meth:`insert`, :meth:`pop`, :meth:`remove`, :meth:`reverse` and :"
|
|
|
|
|
"meth:`sort`, like Python standard list objects. Finally, sequence types "
|
|
|
|
|
"should implement addition (meaning concatenation) and multiplication "
|
|
|
|
|
"(meaning repetition) by defining the methods :meth:`__add__`, :meth:"
|
|
|
|
|
"`__radd__`, :meth:`__iadd__`, :meth:`__mul__`, :meth:`__rmul__` and :meth:"
|
|
|
|
|
"`__imul__` described below; they should not define other numerical "
|
|
|
|
|
"operators. It is recommended that both mappings and sequences implement "
|
|
|
|
|
"the :meth:`__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 :meth:`__iter__` method to "
|
|
|
|
|
"allow efficient iteration through the container; for mappings, :meth:"
|
|
|
|
|
"`__iter__` should be the same as :meth:`keys`; for sequences, it should "
|
|
|
|
|
"iterate through the values."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2053
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement the built-in function :func:`len`. Should return the "
|
|
|
|
|
"length of the object, an integer ``>=`` 0. Also, an object that doesn't "
|
|
|
|
|
"define a :meth:`__bool__` method and whose :meth:`__len__` method returns "
|
|
|
|
|
"zero is considered to be false in a Boolean context."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2060
|
2017-05-27 17:46:38 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In CPython, the length is required to be at most :attr:`sys.maxsize`. If the "
|
|
|
|
|
"length is larger than :attr:`!sys.maxsize` some features (such as :func:"
|
|
|
|
|
"`len`) may raise :exc:`OverflowError`. To prevent raising :exc:`!"
|
|
|
|
|
"OverflowError` by truth value testing, an object must define a :meth:"
|
|
|
|
|
"`__bool__` method."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2069
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement :func:`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. This method is purely an "
|
|
|
|
|
"optimization and is never required for correctness."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2079
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Slicing is done exclusively with the following three methods. A call like ::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2083
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "is translated to ::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2087
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "and so forth. Missing slice items are always filled in with ``None``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2094
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement evaluation of ``self[key]``. For sequence types, the "
|
|
|
|
|
"accepted keys should be integers and slice objects. Note that the special "
|
|
|
|
|
"interpretation of negative indexes (if the class wishes to emulate a "
|
|
|
|
|
"sequence type) is up to the :meth:`__getitem__` method. If *key* is of an "
|
|
|
|
|
"inappropriate type, :exc:`TypeError` may be raised; if of a value outside "
|
|
|
|
|
"the set of indexes for the sequence (after any special interpretation of "
|
|
|
|
|
"negative values), :exc:`IndexError` should be raised. For mapping types, if "
|
|
|
|
|
"*key* is missing (not in the container), :exc:`KeyError` should be raised."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2105
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":keyword:`for` loops expect that an :exc:`IndexError` will be raised for "
|
|
|
|
|
"illegal indexes to allow proper detection of the end of the sequence."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2111
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called by :class:`dict`\\ .\\ :meth:`__getitem__` to implement ``self[key]`` "
|
|
|
|
|
"for dict subclasses when key is not in the dictionary."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2117
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement assignment to ``self[key]``. Same note as for :meth:"
|
|
|
|
|
"`__getitem__`. This should only be implemented for mappings if the objects "
|
|
|
|
|
"support changes to the values for keys, or if new keys can be added, or for "
|
|
|
|
|
"sequences if elements can be replaced. The same exceptions should be raised "
|
|
|
|
|
"for improper *key* values as for the :meth:`__getitem__` method."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2126
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement deletion of ``self[key]``. Same note as for :meth:"
|
|
|
|
|
"`__getitem__`. This should only be implemented for mappings if the objects "
|
|
|
|
|
"support removal of keys, or for sequences if elements can be removed from "
|
|
|
|
|
"the sequence. The same exceptions should be raised for improper *key* "
|
|
|
|
|
"values as for the :meth:`__getitem__` method."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2135
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This method is called when an iterator is required for a container. This "
|
|
|
|
|
"method should return a new iterator object that can iterate over all the "
|
|
|
|
|
"objects in the container. For mappings, it should iterate over the keys of "
|
|
|
|
|
"the container."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2139
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Iterator objects also need to implement this method; they are required to "
|
|
|
|
|
"return themselves. For more information on iterator objects, see :ref:"
|
|
|
|
|
"`typeiter`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2145
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called (if present) by the :func:`reversed` built-in to implement reverse "
|
|
|
|
|
"iteration. It should return a new iterator object that iterates over all "
|
|
|
|
|
"the objects in the container in reverse order."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2149
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If the :meth:`__reversed__` method is not provided, the :func:`reversed` "
|
|
|
|
|
"built-in will fall back to using the sequence protocol (:meth:`__len__` and :"
|
|
|
|
|
"meth:`__getitem__`). Objects that support the sequence protocol should only "
|
|
|
|
|
"provide :meth:`__reversed__` if they can provide an implementation that is "
|
|
|
|
|
"more efficient than the one provided by :func:`reversed`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2156
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The membership test operators (:keyword:`in` and :keyword:`not in`) are "
|
|
|
|
|
"normally implemented as an iteration through a sequence. However, container "
|
|
|
|
|
"objects can supply the following special method with a more efficient "
|
|
|
|
|
"implementation, which also does not require the object be a sequence."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2163
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement membership test operators. Should return true if *item* "
|
|
|
|
|
"is in *self*, false otherwise. For mapping objects, this should consider "
|
|
|
|
|
"the keys of the mapping rather than the values or the key-item pairs."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2167
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For objects that don't define :meth:`__contains__`, the membership test "
|
|
|
|
|
"first tries iteration via :meth:`__iter__`, then the old sequence iteration "
|
|
|
|
|
"protocol via :meth:`__getitem__`, see :ref:`this section in the language "
|
|
|
|
|
"reference <membership-test-details>`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2176
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Emulating numeric types"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2178
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The following methods can be defined to emulate numeric objects. Methods "
|
|
|
|
|
"corresponding to operations that are not supported by the particular kind of "
|
|
|
|
|
"number implemented (e.g., bitwise operations for non-integral numbers) "
|
|
|
|
|
"should be left undefined."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2204
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"These methods are called to implement the binary arithmetic operations (``"
|
|
|
|
|
"+``, ``-``, ``*``, ``@``, ``/``, ``//``, ``%``, :func:`divmod`, :func:`pow`, "
|
|
|
|
|
"``**``, ``<<``, ``>>``, ``&``, ``^``, ``|``). For instance, to evaluate the "
|
|
|
|
|
"expression ``x + y``, where *x* is an instance of a class that has an :meth:"
|
|
|
|
|
"`__add__` method, ``x.__add__(y)`` is called. The :meth:`__divmod__` method "
|
|
|
|
|
"should be the equivalent to using :meth:`__floordiv__` and :meth:`__mod__`; "
|
|
|
|
|
"it should not be related to :meth:`__truediv__`. Note that :meth:`__pow__` "
|
|
|
|
|
"should be defined to accept an optional third argument if the ternary "
|
|
|
|
|
"version of the built-in :func:`pow` function is to be supported."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2215
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If one of those methods does not support the operation with the supplied "
|
|
|
|
|
"arguments, it should return ``NotImplemented``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2238
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"These methods are called to implement the binary arithmetic operations (``"
|
|
|
|
|
"+``, ``-``, ``*``, ``@``, ``/``, ``//``, ``%``, :func:`divmod`, :func:`pow`, "
|
|
|
|
|
"``**``, ``<<``, ``>>``, ``&``, ``^``, ``|``) with reflected (swapped) "
|
|
|
|
|
"operands. These functions are only called if the left operand does not "
|
|
|
|
|
"support the corresponding operation [#]_ and the operands are of different "
|
|
|
|
|
"types. [#]_ For instance, to evaluate the expression ``x - y``, where *y* is "
|
|
|
|
|
"an instance of a class that has an :meth:`__rsub__` method, ``y."
|
|
|
|
|
"__rsub__(x)`` is called if ``x.__sub__(y)`` returns *NotImplemented*."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2249
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Note that ternary :func:`pow` will not try calling :meth:`__rpow__` (the "
|
|
|
|
|
"coercion rules would become too complicated)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2254
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If the right operand's type is a subclass of the left operand's type and "
|
|
|
|
|
"that subclass provides the reflected method for the operation, this method "
|
|
|
|
|
"will be called before the left operand's non-reflected method. This "
|
|
|
|
|
"behavior allows subclasses to override their ancestors' operations."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2274
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"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, the "
|
|
|
|
|
"augmented assignment falls back to the normal methods. For instance, if *x* "
|
|
|
|
|
"is an instance of a class with an :meth:`__iadd__` method, ``x += y`` is "
|
|
|
|
|
"equivalent to ``x = x.__iadd__(y)`` . Otherwise, ``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 :ref:`faq-augmented-assignment-tuple-error`), but this behavior is in "
|
|
|
|
|
"fact part of the data model."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2295
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement the unary arithmetic operations (``-``, ``+``, :func:"
|
|
|
|
|
"`abs` and ``~``)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2308
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2018-03-23 08:57:03 +00:00
|
|
|
|
"Called to implement the built-in functions :func:`complex`, :func:`int` and :"
|
|
|
|
|
"func:`float`. Should return a value of the appropriate type."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2315
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement :func:`operator.index`, and whenever Python needs to "
|
|
|
|
|
"losslessly convert the numeric object to an integer object (such as in "
|
|
|
|
|
"slicing, or in the built-in :func:`bin`, :func:`hex` and :func:`oct` "
|
|
|
|
|
"functions). Presence of this method indicates that the numeric object is an "
|
|
|
|
|
"integer type. Must return an integer."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2323
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In order to have a coherent integer type class, when :meth:`__index__` is "
|
|
|
|
|
"defined :meth:`__int__` should also be defined, and both should return the "
|
|
|
|
|
"same value."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2335
|
|
|
|
|
msgid ""
|
|
|
|
|
"Called to implement the built-in function :func:`round` and :mod:`math` "
|
|
|
|
|
"functions :func:`~math.trunc`, :func:`~math.floor` and :func:`~math.ceil`. "
|
|
|
|
|
"Unless *ndigits* is passed to :meth:`!__round__` all these methods should "
|
|
|
|
|
"return the value of the object truncated to an :class:`~numbers.Integral` "
|
|
|
|
|
"(typically an :class:`int`)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:2341
|
|
|
|
|
msgid ""
|
|
|
|
|
"If :meth:`__int__` is not defined then the built-in function :func:`int` "
|
|
|
|
|
"falls back to :meth:`__trunc__`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
|
|
#: ../Doc/reference/datamodel.rst:2348
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "With Statement Context Managers"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2350
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A :dfn:`context manager` is an object that defines the runtime context to be "
|
|
|
|
|
"established when executing a :keyword:`with` statement. The context manager "
|
|
|
|
|
"handles the entry into, and the exit from, the desired runtime context for "
|
|
|
|
|
"the execution of the block of code. Context managers are normally invoked "
|
|
|
|
|
"using the :keyword:`with` statement (described in section :ref:`with`), but "
|
|
|
|
|
"can also be used by directly invoking their methods."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2361
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Typical uses of context managers include saving and restoring various kinds "
|
|
|
|
|
"of global state, locking and unlocking resources, closing opened files, etc."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2364
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For more information on context managers, see :ref:`typecontextmanager`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2369
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Enter the runtime context related to this object. The :keyword:`with` "
|
|
|
|
|
"statement will bind this method's return value to the target(s) specified in "
|
|
|
|
|
"the :keyword:`as` clause of the statement, if any."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2376
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Exit the runtime context related to this object. The parameters describe the "
|
|
|
|
|
"exception that caused the context to be exited. If the context was exited "
|
|
|
|
|
"without an exception, all three arguments will be :const:`None`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2380
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If an exception is supplied, and the method wishes to suppress the exception "
|
|
|
|
|
"(i.e., prevent it from being propagated), it should return a true value. "
|
|
|
|
|
"Otherwise, the exception will be processed normally upon exit from this "
|
|
|
|
|
"method."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2384
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Note that :meth:`__exit__` methods should not reraise the passed-in "
|
|
|
|
|
"exception; this is the caller's responsibility."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2391
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":pep:`343` - The \"with\" statement"
|
2017-08-10 05:17:13 +00:00
|
|
|
|
msgstr ":pep:`343` - The \"with\" statement"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2391
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The specification, background, and examples for the Python :keyword:`with` "
|
|
|
|
|
"statement."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2398
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Special method lookup"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2400
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For custom classes, implicit invocations of special methods are only "
|
|
|
|
|
"guaranteed to work correctly if defined on an object's type, not in the "
|
|
|
|
|
"object's instance dictionary. That behaviour is the reason why the "
|
|
|
|
|
"following code raises an exception::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2415
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The rationale behind this behaviour lies with a number of special methods "
|
|
|
|
|
"such as :meth:`__hash__` and :meth:`__repr__` that are implemented by all "
|
|
|
|
|
"objects, including type objects. If the implicit lookup of these methods "
|
|
|
|
|
"used the conventional lookup process, they would fail when invoked on the "
|
|
|
|
|
"type object itself::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2428
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Incorrectly attempting to invoke an unbound method of a class in this way is "
|
|
|
|
|
"sometimes referred to as 'metaclass confusion', and is avoided by bypassing "
|
|
|
|
|
"the instance when looking up special methods::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2437
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In addition to bypassing any instance attributes in the interest of "
|
|
|
|
|
"correctness, implicit special method lookup generally also bypasses the :"
|
|
|
|
|
"meth:`__getattribute__` method even of the object's metaclass::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2463
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Bypassing the :meth:`__getattribute__` machinery in this fashion provides "
|
|
|
|
|
"significant scope for speed optimisations within the interpreter, at the "
|
|
|
|
|
"cost of some flexibility in the handling of special methods (the special "
|
|
|
|
|
"method *must* be set on the class object itself in order to be consistently "
|
|
|
|
|
"invoked by the interpreter)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2474
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Coroutines"
|
|
|
|
|
msgstr "Coroutines"
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2478
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Awaitable Objects"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2480
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An :term:`awaitable` object generally implements an :meth:`__await__` "
|
|
|
|
|
"method. :term:`Coroutine` objects returned from :keyword:`async def` "
|
|
|
|
|
"functions are awaitable."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2486
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :term:`generator iterator` objects returned from generators decorated "
|
|
|
|
|
"with :func:`types.coroutine` or :func:`asyncio.coroutine` are also "
|
|
|
|
|
"awaitable, but they do not implement :meth:`__await__`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2492
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Must return an :term:`iterator`. Should be used to implement :term:"
|
|
|
|
|
"`awaitable` objects. For instance, :class:`asyncio.Future` implements this "
|
|
|
|
|
"method to be compatible with the :keyword:`await` expression."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2498
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ":pep:`492` for additional information about awaitable objects."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2504
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Coroutine Objects"
|
2018-02-15 00:01:41 +00:00
|
|
|
|
msgstr "Objets coroutines"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2506
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":term:`Coroutine` objects are :term:`awaitable` objects. A coroutine's "
|
|
|
|
|
"execution can be controlled by calling :meth:`__await__` and iterating over "
|
|
|
|
|
"the result. When the coroutine has finished executing and returns, the "
|
|
|
|
|
"iterator raises :exc:`StopIteration`, and the exception's :attr:"
|
|
|
|
|
"`~StopIteration.value` attribute holds the return value. If the coroutine "
|
|
|
|
|
"raises an exception, it is propagated by the iterator. Coroutines should "
|
|
|
|
|
"not directly raise unhandled :exc:`StopIteration` exceptions."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2514
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Coroutines also have the methods listed below, which are analogous to those "
|
|
|
|
|
"of generators (see :ref:`generator-methods`). However, unlike generators, "
|
|
|
|
|
"coroutines do not directly support iteration."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2518
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "It is a :exc:`RuntimeError` to await on a coroutine more than once."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2524
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Starts or resumes execution of the coroutine. If *value* is ``None``, this "
|
|
|
|
|
"is equivalent to advancing the iterator returned by :meth:`__await__`. If "
|
|
|
|
|
"*value* is not ``None``, this method delegates to the :meth:`~generator."
|
|
|
|
|
"send` method of the iterator that caused the coroutine to suspend. The "
|
|
|
|
|
"result (return value, :exc:`StopIteration`, or other exception) is the same "
|
|
|
|
|
"as when iterating over the :meth:`__await__` return value, described above."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2534
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Raises the specified exception in the coroutine. This method delegates to "
|
|
|
|
|
"the :meth:`~generator.throw` method of the iterator that caused the "
|
|
|
|
|
"coroutine to suspend, if it has such a method. Otherwise, the exception is "
|
|
|
|
|
"raised at the suspension point. The result (return value, :exc:"
|
|
|
|
|
"`StopIteration`, or other exception) is the same as when iterating over the :"
|
|
|
|
|
"meth:`__await__` return value, described above. If the exception is not "
|
|
|
|
|
"caught in the coroutine, it propagates back to the caller."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2545
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Causes the coroutine to clean itself up and exit. If the coroutine is "
|
|
|
|
|
"suspended, this method first delegates to the :meth:`~generator.close` "
|
|
|
|
|
"method of the iterator that caused the coroutine to suspend, if it has such "
|
|
|
|
|
"a method. Then it raises :exc:`GeneratorExit` at the suspension point, "
|
|
|
|
|
"causing the coroutine to immediately clean itself up. Finally, the coroutine "
|
|
|
|
|
"is marked as having finished executing, even if it was never started."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2553
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Coroutine objects are automatically closed using the above process when they "
|
|
|
|
|
"are about to be destroyed."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2559
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Asynchronous Iterators"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2561
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An *asynchronous iterable* is able to call asynchronous code in its "
|
|
|
|
|
"``__aiter__`` implementation, and an *asynchronous iterator* can call "
|
|
|
|
|
"asynchronous code in its ``__anext__`` method."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2565
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Asynchronous iterators can be used in an :keyword:`async for` statement."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2569
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Must return an *asynchronous iterator* object."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2573
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Must return an *awaitable* resulting in a next value of the iterator. "
|
|
|
|
|
"Should raise a :exc:`StopAsyncIteration` error when the iteration is over."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2576
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "An example of an asynchronous iterable object::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2595
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Starting with CPython 3.5.2, ``__aiter__`` can directly return :term:"
|
|
|
|
|
"`asynchronous iterators <asynchronous iterator>`. Returning an :term:"
|
|
|
|
|
"`awaitable` object will result in a :exc:`PendingDeprecationWarning`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2601
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The recommended way of writing backwards compatible code in CPython 3.5.x is "
|
|
|
|
|
"to continue returning awaitables from ``__aiter__``. If you want to avoid "
|
|
|
|
|
"the PendingDeprecationWarning and keep the code backwards compatible, the "
|
|
|
|
|
"following decorator can be used::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2620
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Example::"
|
|
|
|
|
msgstr "Exemples ::"
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2631
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Starting with CPython 3.6, the :exc:`PendingDeprecationWarning` will be "
|
|
|
|
|
"replaced with the :exc:`DeprecationWarning`. In CPython 3.7, returning an "
|
|
|
|
|
"awaitable from ``__aiter__`` will result in a :exc:`RuntimeError`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2638
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Asynchronous Context Managers"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2640
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An *asynchronous context manager* is a *context manager* that is able to "
|
|
|
|
|
"suspend execution in its ``__aenter__`` and ``__aexit__`` methods."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2643
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Asynchronous context managers can be used in an :keyword:`async with` "
|
|
|
|
|
"statement."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2647
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This method is semantically similar to the :meth:`__enter__`, with only "
|
|
|
|
|
"difference that it must return an *awaitable*."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2652
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This method is semantically similar to the :meth:`__exit__`, with only "
|
|
|
|
|
"difference that it must return an *awaitable*."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2655
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "An example of an asynchronous context manager class::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2668
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Footnotes"
|
|
|
|
|
msgstr "Notes"
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2669
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"It *is* possible in some cases to change an object's type, under certain "
|
|
|
|
|
"controlled conditions. It generally isn't a good idea though, since it can "
|
|
|
|
|
"lead to some very strange behaviour if it is handled incorrectly."
|
|
|
|
|
msgstr ""
|
2018-04-09 21:26:29 +00:00
|
|
|
|
"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."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2673
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :meth:`__hash__`, :meth:`__iter__`, :meth:`__reversed__`, and :meth:"
|
|
|
|
|
"`__contains__` methods have special handling for this; others will still "
|
|
|
|
|
"raise a :exc:`TypeError`, but may do so by relying on the behavior that "
|
|
|
|
|
"``None`` is not callable."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2678
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"\"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 "
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"want to force fallback to the right operand's reflected method—that will "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"instead have the opposite effect of explicitly *blocking* such fallback."
|
|
|
|
|
msgstr ""
|
|
|
|
|
|
2018-03-23 08:57:03 +00:00
|
|
|
|
#: ../Doc/reference/datamodel.rst:2684
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For operands of the same type, it is assumed that if the non-reflected "
|
|
|
|
|
"method (such as :meth:`__add__`) fails the operation is not supported, which "
|
|
|
|
|
"is why the reflected method is not called."
|
|
|
|
|
msgstr ""
|