diff --git a/reference/datamodel.po b/reference/datamodel.po index cbe6be7a..4a12d6ea 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -3,27 +3,27 @@ # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # -#, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-03-23 09:03+0100\n" -"PO-Revision-Date: 2018-02-15 00:51+0100\n" -"Last-Translator: FULL NAME \n" -"Language-Team: LANGUAGE \n" +"PO-Revision-Date: 2018-05-01 18:54+0200\n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" +"Last-Translator: \n" +"Language-Team: \n" +"X-Generator: Poedit 2.0.2\n" #: ../Doc/reference/datamodel.rst:6 msgid "Data model" -msgstr "" +msgstr "Modèle de données" #: ../Doc/reference/datamodel.rst:12 msgid "Objects, values and types" -msgstr "" +msgstr "Objets, valeurs et types" #: ../Doc/reference/datamodel.rst:18 msgid "" @@ -32,6 +32,11 @@ msgid "" "sense, and in conformance to Von Neumann's model of a \"stored program " "computer,\" code is also represented by objects.)" msgstr "" +"En Python, les données sont représentées sous forme :dfn:`d'objets`. Toutes " +"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 " +"le modèle de Von Neumann \"d'ordinateur à programme enregistré\", le code " +"est aussi représenté par des objets)." #: ../Doc/reference/datamodel.rst:35 msgid "" @@ -41,10 +46,15 @@ msgid "" "two objects; the :func:`id` function returns an integer representing its " "identity." msgstr "" +"Chaque objet possède un identifiant, un type et une valeur. *L'identifiant* " +"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." #: ../Doc/reference/datamodel.rst:42 msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored." -msgstr "" +msgstr "en CPython, ``id(x)`` est l'adresse mémoire où est stocké ``x``." #: ../Doc/reference/datamodel.rst:44 msgid "" @@ -54,6 +64,11 @@ msgid "" "an object itself). Like its identity, an object's :dfn:`type` is also " "unchangeable. [#]_" msgstr "" +"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é [#]_." #: ../Doc/reference/datamodel.rst:50 msgid "" @@ -68,6 +83,18 @@ msgid "" "instance, numbers, strings and tuples are immutable, while dictionaries and " "lists are mutable." msgstr "" +"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 " +"objet est définie par son type ; par exemple, les nombres, les chaînes de " +"caractères et les tuples sont immuables alors que les dictionnaires et les " +"listes sont muables." #: ../Doc/reference/datamodel.rst:65 msgid "" @@ -77,6 +104,12 @@ msgid "" "implementation quality how garbage collection is implemented, as long as no " "objects are collected that are still reachable." msgstr "" +"Un objet n'est jamais explicitement détruit ; cependant, lorsqu'il ne peut " +"plus être atteint, il a vocation à être supprimé par le ramasse-miettes " +"(*garbage-collector* en anglais). L'implémentation peut retarder cette " +"opération ou même ne pas la faire du tout --- la façon dont fonctionne le " +"ramasse-miette est particulière à chaque implémentation, l'important étant " +"qu'il ne supprime pas d'objet qui peut encore être atteint." #: ../Doc/reference/datamodel.rst:73 msgid "" @@ -89,6 +122,15 @@ msgid "" "on immediate finalization of objects when they become unreachable (so you " "should always close files explicitly)." msgstr "" +"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)." #: ../Doc/reference/datamodel.rst:82 msgid "" @@ -97,6 +139,11 @@ msgid "" "catching an exception with a ':keyword:`try`...\\ :keyword:`except`' " "statement may keep objects alive." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:87 msgid "" @@ -109,6 +156,14 @@ msgid "" "`finally`' statement and the ':keyword:`with`' statement provide convenient " "ways to do this." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:97 msgid "" @@ -121,6 +176,16 @@ msgid "" "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 "" +"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 des " +"identifiants des objets contenus ; cependant, lorsque nous parlons de la " +"muabilité d'un conteneur, seuls les identifiants des objets immédiatement " +"contenus sont concernés. Ainsi, si un conteneur immuable (comme un tuple) " +"contient une référence à un objet muable, sa valeur change si cet objet " +"muable est modifié." #: ../Doc/reference/datamodel.rst:106 msgid "" @@ -134,10 +199,20 @@ msgid "" "different, unique, newly created empty lists. (Note that ``c = d = []`` " "assigns the same object to both ``c`` and ``d``.)" msgstr "" +"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 " +"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 " +"référence à deux listes vides distinctes nouvellement créées. Notez que ``c " +"= d = []`` attribue le même objet à ``c`` et ``d``." #: ../Doc/reference/datamodel.rst:120 msgid "The standard type hierarchy" -msgstr "" +msgstr "Hiérarchie des types standards" #: ../Doc/reference/datamodel.rst:129 msgid "" @@ -148,6 +223,12 @@ msgid "" "integers, etc.), although such additions will often be provided via the " "standard library instead." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:140 msgid "" @@ -156,10 +237,14 @@ msgid "" "and are not intended for general use. Their definition may change in the " "future." msgstr "" +"Quelques descriptions des types ci-dessous contiennent un paragraphe listant " +"des \"attributs spéciaux\". Ces attributs donnent accès à l'implémentation " +"et n'ont, en général, pas vocation à être utilisés. Leur définition peut " +"changer dans le futur." #: ../Doc/reference/datamodel.rst:150 msgid "None" -msgstr "*None*" +msgstr "None" #: ../Doc/reference/datamodel.rst:147 msgid "" @@ -168,6 +253,11 @@ msgid "" "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 "" +"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." #: ../Doc/reference/datamodel.rst:165 msgid "NotImplemented" @@ -182,14 +272,23 @@ msgid "" "will then try the reflected operation, or some other fallback, depending on " "the operator.) Its truth value is true." msgstr "" +"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 " +"valeur si elles n'implémentent pas l'opération pour les opérandes fournis " +"(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." #: ../Doc/reference/datamodel.rst:162 msgid "See :ref:`implementing-the-arithmetic-operations` for more details." msgstr "" +"Consultez :ref:`implementing-the-arithmetic-operations` pour davantage de " +"details." #: ../Doc/reference/datamodel.rst:172 msgid "Ellipsis" -msgstr "" +msgstr "Ellipse" #: ../Doc/reference/datamodel.rst:170 msgid "" @@ -197,6 +296,9 @@ msgid "" "This object is accessed through the literal ``...`` or the built-in name " "``Ellipsis``. Its truth value is true." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:242 msgid ":class:`numbers.Number`" @@ -210,12 +312,20 @@ msgid "" "strongly related to mathematical numbers, but subject to the limitations of " "numerical representation in computers." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:183 msgid "" "Python distinguishes between integers, floating point numbers, and complex " "numbers:" msgstr "" +"Python distingue les entiers, les nombres à virgule flottante et les nombres " +"complexes :" #: ../Doc/reference/datamodel.rst:217 msgid ":class:`numbers.Integral`" @@ -226,14 +336,16 @@ msgid "" "These represent elements from the mathematical set of integers (positive and " "negative)." msgstr "" +"Ils représentent des éléments de l'ensemble mathématique des entiers " +"(positifs ou négatifs)." #: ../Doc/reference/datamodel.rst:192 msgid "There are two types of integers:" -msgstr "" +msgstr "Il existe deux types d'entiers :" #: ../Doc/reference/datamodel.rst:194 msgid "Integers (:class:`int`)" -msgstr "" +msgstr "Entiers (:class:`int`)" #: ../Doc/reference/datamodel.rst:196 msgid "" @@ -243,10 +355,16 @@ msgid "" "variant of 2's complement which gives the illusion of an infinite string of " "sign bits extending to the left." msgstr "" +"Ils représentent les nombres, sans limite de taille, sous réserve de pouvoir " +"être stockés en mémoire (virtuelle). Afin de pouvoir effectuer des décalages " +"et appliquer des masques, on considère qu'ils ont une représentation " +"binaire. Les nombres négatifs sont représentés comme une variante du " +"complément à 2, qui donne l'illusion d'une chaîne infinie de bits de signe " +"s'étendant vers la gauche." #: ../Doc/reference/datamodel.rst:212 msgid "Booleans (:class:`bool`)" -msgstr "" +msgstr "Booléens (:class:`bool`)" #: ../Doc/reference/datamodel.rst:208 msgid "" @@ -257,6 +375,12 @@ msgid "" "being that when converted to a string, the strings ``\"False\"`` or ``\"True" "\"`` are returned, respectively." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:216 msgid "" @@ -264,10 +388,13 @@ msgid "" "meaningful interpretation of shift and mask operations involving negative " "integers." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:232 msgid ":class:`numbers.Real` (:class:`float`)" -msgstr "" +msgstr ":class:`numbers.Real` (:class:`float`)" #: ../Doc/reference/datamodel.rst:226 msgid "" @@ -279,10 +406,19 @@ msgid "" "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 "" +"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." #: ../Doc/reference/datamodel.rst:242 msgid ":class:`numbers.Complex` (:class:`complex`)" -msgstr "" +msgstr ":class:`numbers.Complex` (:class:`complex`)" #: ../Doc/reference/datamodel.rst:239 msgid "" @@ -291,10 +427,16 @@ msgid "" "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 "" +"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``." #: ../Doc/reference/datamodel.rst:359 msgid "Sequences" -msgstr "" +msgstr "Séquences" #: ../Doc/reference/datamodel.rst:252 msgid "" @@ -303,6 +445,11 @@ msgid "" "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 "" +"Ils représentent des ensembles de taille finie indicés par des entiers " +"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*, " +"l'ensemble des indices contient les entiers 0, 1 ..., *n*-1. On accède à " +"l'élément d'indice *i* de la séquence *a* par ``a[i]``." #: ../Doc/reference/datamodel.rst:259 msgid "" @@ -311,6 +458,11 @@ msgid "" "a sequence of the same type. This implies that the index set is renumbered " "so that it starts at 0." msgstr "" +"Les séquences peuvent aussi être découpées en tranches (*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 de " +"la tranche est renuméroté de manière à partir de 0." #: ../Doc/reference/datamodel.rst:264 msgid "" @@ -318,14 +470,18 @@ msgid "" "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 "" +"Quelques séquences gèrent le \"découpage étendu\" (*extended slicing* en " +"anglais) avec un troisième paramètre : ``a[i:j:k]`` sélectionne tous les " +"éléments de *a* d'indice *x* où ``x = i + n*k``, avec *n* ``>=`` ``0`` et " +"*i* ``<=`` *x* ``<`` *j*." #: ../Doc/reference/datamodel.rst:268 msgid "Sequences are distinguished according to their mutability:" -msgstr "" +msgstr "Les séquences se différencient en fonction de leur muabilité :" #: ../Doc/reference/datamodel.rst:325 msgid "Immutable sequences" -msgstr "" +msgstr "Séquences immuables" #: ../Doc/reference/datamodel.rst:275 msgid "" @@ -334,14 +490,19 @@ msgid "" "be mutable and may be changed; however, the collection of objects directly " "referenced by an immutable object cannot change.)" msgstr "" +"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 " +"objets directement référencés par un objet immuable ne peuvent pas être " +"modifiés." #: ../Doc/reference/datamodel.rst:280 msgid "The following types are immutable sequences:" -msgstr "" +msgstr "Les types suivants sont des séquences immuables :" #: ../Doc/reference/datamodel.rst:303 msgid "Strings" -msgstr "Les chaînes de caractères" +msgstr "Chaînes de caractères" #: ../Doc/reference/datamodel.rst:293 msgid "" @@ -356,6 +517,18 @@ msgid "" "`bytes` using the given text encoding, and :meth:`bytes.decode` can be used " "to achieve the opposite." msgstr "" +"Une chaîne de caractères (*string* en anglais) est une séquence de valeurs " +"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 " +"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." #: ../Doc/reference/datamodel.rst:316 msgid "Tuples" @@ -370,6 +543,13 @@ msgid "" "usable for grouping of expressions). An empty tuple can be formed by an " "empty pair of parentheses." msgstr "" +"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 vide." #: ../Doc/reference/datamodel.rst:325 msgid "Bytes" @@ -383,10 +563,16 @@ msgid "" "create bytes objects. Also, bytes objects can be decoded to strings via " "the :meth:`~bytes.decode` method." msgstr "" +"Les objets *bytes* sont des tableaux immuables. Les éléments sont des octets " +"(donc composés de 8 bits), représentés par des entiers dans l'intervalle 0 à " +"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`." #: ../Doc/reference/datamodel.rst:359 msgid "Mutable sequences" -msgstr "" +msgstr "Séquences muables" #: ../Doc/reference/datamodel.rst:335 msgid "" @@ -394,14 +580,18 @@ msgid "" "and slicing notations can be used as the target of assignment and :keyword:" "`del` (delete) statements." msgstr "" +"Les séquences muables peuvent être modifiées après leur création. Les " +"notations de tranches et de sous-ensembles peuvent être utilisées en tant " +"que cibles d'une assignation ou de l'instruction :keyword:`del` " +"(suppression)." #: ../Doc/reference/datamodel.rst:339 msgid "There are currently two intrinsic mutable sequence types:" -msgstr "" +msgstr "Il existe aujourd'hui deux types intrinsèques de séquences muables :" #: ../Doc/reference/datamodel.rst:346 msgid "Lists" -msgstr "Les listes" +msgstr "Listes" #: ../Doc/reference/datamodel.rst:344 msgid "" @@ -409,10 +599,14 @@ msgid "" "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 "" +"N'importe quel objet Python peut être élément d'une liste. Les listes sont " +"créées en plaçant entre crochets une liste d'expressions dont les éléments " +"sont séparés par des virgules (notez que les listes de longueur 0 ou 1 ne " +"sont pas des cas particuliers)." #: ../Doc/reference/datamodel.rst:354 msgid "Byte Arrays" -msgstr "" +msgstr "Tableaux d'octets" #: ../Doc/reference/datamodel.rst:351 msgid "" @@ -421,16 +615,23 @@ msgid "" "unhashable), byte arrays otherwise provide the same interface and " "functionality as immutable :class:`bytes` objects." msgstr "" +"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 " +"donc de ne pas pouvoir calculer son empreinte par hachage), un tableau " +"d'octets possède la même interface et les mêmes fonctionnalités qu'un objet " +"immuable :class:`bytes`." #: ../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 "" +"Le module d'extension :mod:`array` fournit un autre exemple de type de " +"séquence muable, de même que le module :mod:`collections`." #: ../Doc/reference/datamodel.rst:393 msgid "Set types" -msgstr "" +msgstr "Ensembles" #: ../Doc/reference/datamodel.rst:366 msgid "" @@ -441,6 +642,13 @@ msgid "" "from a sequence, and computing mathematical operations such as intersection, " "union, difference, and symmetric difference." msgstr "" +"Ils représentent les ensembles d'objets, non ordonnés, finis et dont les " +"éléments sont uniques. Tels quels, ils ne peuvent pas être indicés. " +"Cependant, il est possible d'itérer dessus et la fonction native :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." #: ../Doc/reference/datamodel.rst:373 msgid "" @@ -449,14 +657,19 @@ msgid "" "numbers compare equal (e.g., ``1`` and ``1.0``), only one of them can be " "contained in a set." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:378 msgid "There are currently two intrinsic set types:" -msgstr "" +msgstr "Actuellement, il existe deux types d'ensembles natifs :" #: ../Doc/reference/datamodel.rst:385 msgid "Sets" -msgstr "Les ensembles" +msgstr "Ensembles" #: ../Doc/reference/datamodel.rst:383 msgid "" @@ -464,10 +677,13 @@ msgid "" "constructor and can be modified afterwards by several methods, such as :meth:" "`~set.add`." msgstr "" +"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`." #: ../Doc/reference/datamodel.rst:393 msgid "Frozen sets" -msgstr "" +msgstr "Ensembles gelés" #: ../Doc/reference/datamodel.rst:390 msgid "" @@ -475,10 +691,14 @@ msgid "" "`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 "" +"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." #: ../Doc/reference/datamodel.rst:430 msgid "Mappings" -msgstr "" +msgstr "Tableaux de correspondances" #: ../Doc/reference/datamodel.rst:401 msgid "" @@ -488,10 +708,18 @@ msgid "" "assignments or :keyword:`del` statements. The built-in function :func:`len` " "returns the number of items in a mapping." msgstr "" +"Ils représentent les ensembles finis d'objets indicés par des ensembles " +"index arbitraires. La notation ``a[k]`` sélectionne l'élément indicé par " +"``k`` dans le tableau de 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 " +"du tableau de correspondances." #: ../Doc/reference/datamodel.rst:407 msgid "There is currently a single intrinsic mapping type:" msgstr "" +"Il n'existe actuellement qu'un seul type natif pour les tableaux de " +"correspondances :" #: ../Doc/reference/datamodel.rst:430 msgid "Dictionaries" @@ -508,32 +736,49 @@ msgid "" "numbers compare equal (e.g., ``1`` and ``1.0``) then they can be used " "interchangeably to index the same dictionary entry." msgstr "" +"Ils représentent les ensembles finis d'objets indicés par des valeurs " +"presqu'arbitraires. Les seuls types de valeurs non reconnus comme clés sont " +"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 " +"dictionnaire requiert que l'empreinte par hachage des clés reste constante " +"dans le temps. Les types numériques obéissent aux règles normales pour les " +"comparaisons numériques : si deux nombres sont égaux pour l'opération de " +"comparaison, par exemple ``1`` et ``1.0``, alors ces deux nombres peuvent " +"être utilisés indifféremment pour désigner la même entrée du dictionnaire." #: ../Doc/reference/datamodel.rst:421 msgid "" "Dictionaries are mutable; they can be created by the ``{...}`` notation (see " "section :ref:`dict`)." msgstr "" +"Les dictionnaires sont muables : ils peuvent être créés par la notation " +"``{...}`` (reportez-vous à la section :ref:`dict`)." #: ../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 "" +"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`." #: ../Doc/reference/datamodel.rst:686 msgid "Callable types" -msgstr "" +msgstr "Types appelables" #: ../Doc/reference/datamodel.rst:439 msgid "" "These are the types to which the function call operation (see section :ref:" "`calls`) can be applied:" msgstr "" +"Ce sont les types sur lesquels on peut faire un appel de fonction (lisez la " +"section :ref:`calls`) :" #: ../Doc/reference/datamodel.rst:534 msgid "User-defined functions" -msgstr "" +msgstr "Fonctions définies par l'utilisateur" #: ../Doc/reference/datamodel.rst:448 msgid "" @@ -541,10 +786,14 @@ msgid "" "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 "" +"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." #: ../Doc/reference/datamodel.rst:453 msgid "Special attributes:" -msgstr "" +msgstr "Attributs spéciaux :" #: ../Doc/reference/datamodel.rst:471 msgid "Attribute" @@ -563,6 +812,8 @@ msgid "" "The function's documentation string, or ``None`` if unavailable; not " "inherited by subclasses" msgstr "" +"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" #: ../Doc/reference/datamodel.rst:473 ../Doc/reference/datamodel.rst:478 #: ../Doc/reference/datamodel.rst:481 ../Doc/reference/datamodel.rst:486 @@ -570,7 +821,7 @@ msgstr "" #: ../Doc/reference/datamodel.rst:506 ../Doc/reference/datamodel.rst:514 #: ../Doc/reference/datamodel.rst:521 msgid "Writable" -msgstr "" +msgstr "Accessible en écriture" #: ../Doc/reference/datamodel.rst:478 msgid ":attr:`~definition.\\ __name__`" @@ -578,7 +829,7 @@ msgstr "" #: ../Doc/reference/datamodel.rst:478 msgid "The function's name" -msgstr "" +msgstr "Nom de la fonction" #: ../Doc/reference/datamodel.rst:481 msgid ":attr:`~definition.\\ __qualname__`" @@ -586,7 +837,7 @@ msgstr "" #: ../Doc/reference/datamodel.rst:481 msgid "The function's :term:`qualified name`" -msgstr "" +msgstr ":term:`qualified name` de la fonction" #: ../Doc/reference/datamodel.rst:486 msgid ":attr:`__module__`" @@ -597,6 +848,8 @@ msgid "" "The name of the module the function was defined in, or ``None`` if " "unavailable." msgstr "" +"Nom du module où la fonction est définie ou ``None`` si ce nom n'est pas " +"disponible." #: ../Doc/reference/datamodel.rst:490 msgid ":attr:`__defaults__`" @@ -607,6 +860,8 @@ msgid "" "A tuple containing default argument values for those arguments that have " "defaults, or ``None`` if no arguments have a default value" msgstr "" +"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." #: ../Doc/reference/datamodel.rst:496 msgid ":attr:`__code__`" @@ -614,7 +869,7 @@ msgstr "" #: ../Doc/reference/datamodel.rst:496 msgid "The code object representing the compiled function body." -msgstr "" +msgstr "Objet code représentant le corps de la fonction compilée." #: ../Doc/reference/datamodel.rst:499 msgid ":attr:`__globals__`" @@ -625,10 +880,13 @@ 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 "" +"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." #: ../Doc/reference/datamodel.rst:499 ../Doc/reference/datamodel.rst:510 msgid "Read-only" -msgstr "" +msgstr "Accessible en lecture seule" #: ../Doc/reference/datamodel.rst:506 msgid ":attr:`~object.__dict__`" @@ -636,7 +894,7 @@ msgstr "" #: ../Doc/reference/datamodel.rst:506 msgid "The namespace supporting arbitrary function attributes." -msgstr "" +msgstr "Espace de noms accueillant les attributs de la fonction." #: ../Doc/reference/datamodel.rst:510 msgid ":attr:`__closure__`" @@ -647,6 +905,8 @@ msgid "" "``None`` or a tuple of cells that contain bindings for the function's free " "variables." msgstr "" +"``None`` ou tuple de cellules qui contient un lien pour chaque variable " +"libre de la fonction." #: ../Doc/reference/datamodel.rst:514 msgid ":attr:`__annotations__`" @@ -657,6 +917,11 @@ 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 "" +"Dictionnaire contenant les annotations des paramètres. Les clés du " +"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." #: ../Doc/reference/datamodel.rst:521 msgid ":attr:`__kwdefaults__`" @@ -665,12 +930,16 @@ msgstr "" #: ../Doc/reference/datamodel.rst:521 msgid "A dict containing defaults for keyword-only parameters." msgstr "" +"Dictionnaire contenant les valeurs par défaut pour les paramètres passés par " +"mot-clé." #: ../Doc/reference/datamodel.rst:525 msgid "" "Most of the attributes labelled \"Writable\" check the type of the assigned " "value." msgstr "" +"La plupart des attributs étiquetés \"Accessible en écriture\" vérifient le " +"type de la valeur qu'on leur assigne." #: ../Doc/reference/datamodel.rst:527 msgid "" @@ -681,22 +950,33 @@ msgid "" "functions. Function attributes on built-in functions may be supported in the " "future.*" msgstr "" +"Les objets fonctions acceptent également l'assignation et la lecture " +"d'attributs arbitraires. Vous pouvez utiliser cette fonctionnalité pour, par " +"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.*" #: ../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 "" +"Vous trouvez davantage d'informations sur la définition de fonctions dans le " +"code de cet objet ; la description des types internes est donnée plus bas." #: ../Doc/reference/datamodel.rst:603 msgid "Instance methods" -msgstr "" +msgstr "Méthodes d'instances" #: ../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 "" +"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)." #: ../Doc/reference/datamodel.rst:552 msgid "" @@ -707,12 +987,20 @@ msgid "" "`__module__` is the name of the module the method was defined in, or " "``None`` if unavailable." msgstr "" +"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__." +"__name__``) ; :attr:`__module__` est le nom du module où la méthode est " +"définie ou ``None`` s'il n'est pas disponible." #: ../Doc/reference/datamodel.rst:558 msgid "" "Methods also support accessing (but not setting) the arbitrary function " "attributes on the underlying function object." msgstr "" +"Les méthodes savent aussi accéder (mais pas modifier) les attributs de la " +"fonction de l'objet fonction sous-jacent." #: ../Doc/reference/datamodel.rst:561 msgid "" @@ -720,6 +1008,10 @@ msgid "" "class (perhaps via an instance of that class), if that attribute is a user-" "defined function object or a class method object." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:565 msgid "" @@ -728,6 +1020,10 @@ msgid "" "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 "" +"Quand un objet méthode d'instance est créé à partir d'un objet fonction " +"définie 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." #: ../Doc/reference/datamodel.rst:571 msgid "" @@ -736,6 +1032,11 @@ msgid "" "object, except that the :attr:`__func__` attribute of the new instance is " "not the original method object but its :attr:`__func__` attribute." msgstr "" +"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__`." #: ../Doc/reference/datamodel.rst:577 msgid "" @@ -744,6 +1045,10 @@ msgid "" "itself, and its :attr:`__func__` attribute is the function object underlying " "the class method." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:582 msgid "" @@ -753,6 +1058,12 @@ msgid "" "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 "" +"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)``." #: ../Doc/reference/datamodel.rst:589 msgid "" @@ -761,6 +1072,10 @@ msgid "" "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 "" +"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." #: ../Doc/reference/datamodel.rst:594 msgid "" @@ -774,10 +1089,20 @@ msgid "" "class instance are not converted to bound methods; this *only* happens when " "the function is an attribute of the class." msgstr "" +"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 noter 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." #: ../Doc/reference/datamodel.rst:618 msgid "Generator functions" -msgstr "" +msgstr "Fonctions générateurs" #: ../Doc/reference/datamodel.rst:610 msgid "" @@ -791,10 +1116,19 @@ msgid "" "raised and the iterator will have reached the end of the set of values to be " "returned." msgstr "" +"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 renvoyer." #: ../Doc/reference/datamodel.rst:628 msgid "Coroutine functions" -msgstr "" +msgstr "Fonctions coroutines" #: ../Doc/reference/datamodel.rst:624 msgid "" @@ -804,10 +1138,15 @@ msgid "" "as :keyword:`async with` and :keyword:`async for` statements. See also the :" "ref:`coroutine-objects` section." msgstr "" +"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`." #: ../Doc/reference/datamodel.rst:647 msgid "Asynchronous generator functions" -msgstr "" +msgstr "Fonctions générateurs asynchrones" #: ../Doc/reference/datamodel.rst:635 msgid "" @@ -817,6 +1156,11 @@ msgid "" "object which can be used in an :keyword:`async for` statement to execute the " "body of the function." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:641 msgid "" @@ -827,6 +1171,13 @@ msgid "" "`StopAsyncIteration` exception is raised and the asynchronous iterator will " "have reached the end of the set of values to be yielded." msgstr "" +"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 :keyword:`return` (sans valeur) 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." #: ../Doc/reference/datamodel.rst:662 msgid "Built-in functions" @@ -843,10 +1194,19 @@ msgid "" "``None`` (but see the next item); :attr:`__module__` is the name of the " "module the function was defined in or ``None`` if unavailable." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:674 msgid "Built-in methods" -msgstr "" +msgstr "Méthodes natives" #: ../Doc/reference/datamodel.rst:670 msgid "" @@ -856,6 +1216,11 @@ msgid "" "*alist* is a list object. In this case, the special read-only attribute :" "attr:`__self__` is set to the object denoted by *alist*." msgstr "" +"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 seule :attr:`__self__` est défini " +"à l'objet *une_liste*." #: ../Doc/reference/datamodel.rst:681 msgid "Classes" @@ -869,16 +1234,23 @@ msgid "" "`__new__` and, in the typical case, to :meth:`__init__` to initialize the " "new instance." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:686 msgid "Class Instances" -msgstr "" +msgstr "Instances de classe" #: ../Doc/reference/datamodel.rst:684 msgid "" "Instances of arbitrary classes can be made callable by defining a :meth:" "`__call__` method in their class." msgstr "" +"Les instances d'une classe peuvent devenir des appelables si vous définissez " +"la méthode :meth:`__call__` de leur classe." #: ../Doc/reference/datamodel.rst:736 msgid "Modules" @@ -897,12 +1269,25 @@ msgid "" "object does not contain the code object used to initialize the module (since " "it isn't needed once the initialization is done)." msgstr "" +"Les modules constituent l'organisation de base du code Python et sont créés " +"par le :ref:`mécanisme d'import ` 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)." #: ../Doc/reference/datamodel.rst:705 msgid "" "Attribute assignment updates the module's namespace dictionary, e.g., ``m.x " "= 1`` is equivalent to ``m.__dict__[\"x\"] = 1``." msgstr "" +"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``." #: ../Doc/reference/datamodel.rst:715 msgid "" @@ -917,12 +1302,25 @@ msgid "" "loaded dynamically from a shared library, it is the pathname of the shared " "library file." msgstr "" +"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 :term:`annotations de variables ` 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." #: ../Doc/reference/datamodel.rst:728 msgid "" "Special read-only attribute: :attr:`~object.__dict__` is the module's " "namespace as a dictionary object." msgstr "" +"Attribut spécial en lecture seule : :attr:`~object.__dict__` est l'objet " +"dictionnaire répertoriant l'espace de noms du module." #: ../Doc/reference/datamodel.rst:733 msgid "" @@ -931,10 +1329,15 @@ msgid "" "still has live references. To avoid this, copy the dictionary or keep the " "module around while using its dictionary directly." msgstr "" +"en raison de la manière dont CPython nettoie les dictionnaires de modules, " +"le dictionnaire du module est effacé quand le module n'est plus visible, " +"même si le dictionnaire possède encore des références actives. Pour éviter " +"ceci, copiez le dictionnaire ou gardez le module dans votre champ de " +"visibilité tant que vous souhaitez utiliser le dictionnaire directement." #: ../Doc/reference/datamodel.rst:795 msgid "Custom classes" -msgstr "" +msgstr "Classes déclarées par le développeur" #: ../Doc/reference/datamodel.rst:739 msgid "" @@ -951,6 +1354,21 @@ msgid "" "found in the documentation accompanying the 2.3 release at https://www." "python.org/download/releases/2.3/mro/." msgstr "" +"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 l'ordre " +"de résolution des méthodes (*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 l'ordre de résolution des méthodes MRO C3 " +"utilisé par Python dans la documentation de la version 2.3 disponible sur " +"https://www.python.org/download/releases/2.3/mro/." #: ../Doc/reference/datamodel.rst:763 msgid "" @@ -962,18 +1380,29 @@ msgid "" "attributes retrieved from a class may differ from those actually contained " "in its :attr:`~object.__dict__`." msgstr "" +"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__`." #: ../Doc/reference/datamodel.rst:773 msgid "" "Class attribute assignments update the class's dictionary, never the " "dictionary of a base class." msgstr "" +"Les assignations d'un attribut de classe mettent à jour le dictionnaire de " +"la classe, jamais le dictionnaire d'une classe de base." #: ../Doc/reference/datamodel.rst:778 msgid "" "A class object can be called (see above) to yield a class instance (see " "below)." msgstr "" +"Un objet classe peut être appelé (voir ci-dessus) pour produire une instance " +"de classe (voir ci-dessous)." #: ../Doc/reference/datamodel.rst:788 msgid "" @@ -986,10 +1415,19 @@ msgid "" "(optional) is a dictionary containing :term:`variable annotations ` collected during class body execution." msgstr "" +"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 ` " +"collectées durant l'exécution du corps de la classe." #: ../Doc/reference/datamodel.rst:838 msgid "Class instances" -msgstr "" +msgstr "Instances de classes" #: ../Doc/reference/datamodel.rst:804 msgid "" @@ -1007,6 +1445,22 @@ msgid "" "class attribute is found, and the object's class has a :meth:`__getattr__` " "method, that is called to satisfy the lookup." msgstr "" +"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éfinie 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:`~object.__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." #: ../Doc/reference/datamodel.rst:820 msgid "" @@ -1015,22 +1469,31 @@ msgid "" "`__delattr__` method, this is called instead of updating the instance " "dictionary directly." msgstr "" +"Les assignations et suppressions d'attributs mettent à jour le dictionnaire " +"de l'instance, jamais le dictionnaire de la classe. Si la classe possède une " +"méthode :meth:`__setattr__` ou :meth:`__delattr__`, elle est appelée au lieu " +"de mettre à jour le dictionnaire de l'instance directement." #: ../Doc/reference/datamodel.rst:830 msgid "" "Class instances can pretend to be numbers, sequences, or mappings if they " "have methods with certain special names. See section :ref:`specialnames`." msgstr "" +"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`." #: ../Doc/reference/datamodel.rst:837 msgid "" "Special attributes: :attr:`~object.__dict__` is the attribute dictionary; :" "attr:`~instance.__class__` is the instance's class." msgstr "" +"Attributs spéciaux : :attr:`~object.__dict__` est le dictionnaire des " +"attributs ; :attr:`~instance.__class__` est la classe de l'instance." #: ../Doc/reference/datamodel.rst:864 msgid "I/O objects (also known as file objects)" -msgstr "" +msgstr "Objets Entrées-Sorties (ou objets fichiers)" #: ../Doc/reference/datamodel.rst:854 msgid "" @@ -1040,6 +1503,11 @@ msgid "" "makefile` method of socket objects (and perhaps by other functions or " "methods provided by extension modules)." msgstr "" +"Un :term:`objet fichier` représente un fichier ouvert. Différents 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)." #: ../Doc/reference/datamodel.rst:860 msgid "" @@ -1048,10 +1516,15 @@ msgid "" "and error streams; they are all open in text mode and therefore follow the " "interface defined by the :class:`io.TextIOBase` abstract class." msgstr "" +"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`." #: ../Doc/reference/datamodel.rst:1070 msgid "Internal types" -msgstr "" +msgstr "Types internes" #: ../Doc/reference/datamodel.rst:871 msgid "" @@ -1059,6 +1532,9 @@ msgid "" "Their definitions may change with future versions of the interpreter, but " "they are mentioned here for completeness." msgstr "" +"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é." #: ../Doc/reference/datamodel.rst:939 msgid "Code objects" @@ -1075,6 +1551,15 @@ msgid "" "run-time). Unlike function objects, code objects are immutable and contain " "no references (directly or indirectly) to mutable objects." msgstr "" +"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 dans l'objet code (parce que ce " +"sont des valeurs calculées au moment de l'exécution). Contrairement aux " +"objets fonctions, les objets codes sont immuables et ne contiennent aucune " +"référence (directe ou indirecte) à des objets muables." #: ../Doc/reference/datamodel.rst:903 msgid "" @@ -1096,6 +1581,25 @@ msgid "" "size (including local variables); :attr:`co_flags` is an integer encoding a " "number of flags for the interpreter." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:922 msgid "" @@ -1105,6 +1609,12 @@ msgid "" "``**keywords`` syntax to accept arbitrary keyword arguments; bit ``0x20`` is " "set if the function is a generator." msgstr "" +"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 ; le bit ``0x20`` est " +"positionné à 1 si la fonction est un générateur." #: ../Doc/reference/datamodel.rst:928 msgid "" @@ -1114,26 +1624,37 @@ msgid "" "compiled with future division enabled; bits ``0x10`` and ``0x1000`` were " "used in earlier versions of Python." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:934 msgid "Other bits in :attr:`co_flags` are reserved for internal use." -msgstr "" +msgstr "Les autres bits de :attr:`co_flags` sont réservés à un usage interne." #: ../Doc/reference/datamodel.rst:938 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 "" +"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)." #: ../Doc/reference/datamodel.rst:988 msgid "Frame objects" -msgstr "" +msgstr "Objets cadres" #: ../Doc/reference/datamodel.rst:946 msgid "" "Frame objects represent execution frames. They may occur in traceback " "objects (see below)." msgstr "" +"Un objet cadre représente le cadre d'exécution. Ils apparaissent dans des " +"objets traces (voir plus loin)." #: ../Doc/reference/datamodel.rst:957 msgid "" @@ -1145,6 +1666,14 @@ msgid "" "names; :attr:`f_lasti` gives the precise instruction (this is an index into " "the bytecode string of the code object)." msgstr "" +"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)." #: ../Doc/reference/datamodel.rst:969 msgid "" @@ -1155,10 +1684,17 @@ msgid "" "for the bottom-most frame). A debugger can implement a Jump command (aka " "Set Next Statement) by writing to f_lineno." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:976 msgid "Frame objects support one method:" -msgstr "" +msgstr "Les objets cadres comprennent une méthode :" #: ../Doc/reference/datamodel.rst:980 msgid "" @@ -1167,14 +1703,19 @@ msgid "" "This helps break reference cycles involving frame objects (for example when " "catching an exception and storing its traceback for later use)." msgstr "" +"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)." #: ../Doc/reference/datamodel.rst:986 msgid ":exc:`RuntimeError` is raised if the frame is currently executing." -msgstr "" +msgstr ":exc:`RuntimeError` est levée si le cadre est en cours d'exécution." #: ../Doc/reference/datamodel.rst:1026 msgid "Traceback objects" -msgstr "" +msgstr "Objets traces" #: ../Doc/reference/datamodel.rst:1001 msgid "" @@ -1189,6 +1730,17 @@ msgid "" "stream; if the interpreter is interactive, it is also made available to the " "user as ``sys.last_traceback``." msgstr "" +"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``." #: ../Doc/reference/datamodel.rst:1019 msgid "" @@ -1201,16 +1753,28 @@ msgid "" "of its frame object if the exception occurred in a :keyword:`try` statement " "with no matching except clause or with a finally clause." msgstr "" +"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 :keyword:`!finally`." #: ../Doc/reference/datamodel.rst:1052 msgid "Slice objects" -msgstr "" +msgstr "Objets tranches" #: ../Doc/reference/datamodel.rst:1031 msgid "" "Slice objects are used to represent slices for :meth:`__getitem__` methods. " "They are also created by the built-in :func:`slice` function." msgstr "" +"Un objet tranche est utilisé pour représenter des découpes des méthodes :" +"meth:`__getitem__`. Ils sont aussi créés par la fonction native :func:" +"`slice`." #: ../Doc/reference/datamodel.rst:1039 msgid "" @@ -1218,10 +1782,14 @@ msgid "" "`~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 "" +"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." #: ../Doc/reference/datamodel.rst:1043 msgid "Slice objects support one method:" -msgstr "" +msgstr "Les objets tranches comprennent une méthode :" #: ../Doc/reference/datamodel.rst:1047 msgid "" @@ -1232,10 +1800,16 @@ msgid "" "stride length of the slice. Missing or out-of-bounds indices are handled in " "a manner consistent with regular slices." msgstr "" +"Cette méthode prend un argument entier *length* et calcule les informations " +"de la tranche 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 " +"tranches normales." #: ../Doc/reference/datamodel.rst:1062 msgid "Static method objects" -msgstr "" +msgstr "Objets méthodes statiques" #: ../Doc/reference/datamodel.rst:1055 msgid "" @@ -1248,10 +1822,19 @@ msgid "" "callable, although the objects they wrap usually are. Static method objects " "are created by the built-in :func:`staticmethod` constructor." msgstr "" +"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`." #: ../Doc/reference/datamodel.rst:1070 msgid "Class method objects" -msgstr "" +msgstr "Objets méthodes de classes" #: ../Doc/reference/datamodel.rst:1065 msgid "" @@ -1261,10 +1844,16 @@ msgid "" "retrieval is described above, under \"User-defined methods\". Class method " "objects are created by the built-in :func:`classmethod` constructor." msgstr "" +"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`." #: ../Doc/reference/datamodel.rst:1075 msgid "Special method names" -msgstr "" +msgstr "Méthodes spéciales" #: ../Doc/reference/datamodel.rst:1081 msgid "" @@ -1279,6 +1868,17 @@ msgid "" "appropriate method is defined (typically :exc:`AttributeError` or :exc:" "`TypeError`)." msgstr "" +"Une classe peut implémenter certaines opérations que l'on invoque par une " +"syntaxe spéciale (telles que les opérations arithmétiques ou la découpe en " +"tranches) en définissant des méthodes aux noms particuliers. C'est " +"l'approche utilisée par Python pour la :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`)." #: ../Doc/reference/datamodel.rst:1091 msgid "" @@ -1288,6 +1888,11 @@ msgid "" "instances will raise a :exc:`TypeError` (without falling back to :meth:" "`__getitem__`). [#]_" msgstr "" +"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__`, vous ne pouvez pas itérer sur la classe et " +"appeler :func:`iter` sur une instance lève :exc:`TypeError` (sans se replier " +"sur :meth:`__getitem__`) [#]_." #: ../Doc/reference/datamodel.rst:1097 msgid "" @@ -1298,10 +1903,16 @@ msgid "" "sense. (One example of this is the :class:`~xml.dom.NodeList` interface in " "the W3C's Document Object Model.)" msgstr "" +"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)." #: ../Doc/reference/datamodel.rst:1108 msgid "Basic customization" -msgstr "" +msgstr "Personnalisation de base" #: ../Doc/reference/datamodel.rst:1114 msgid "" @@ -1312,6 +1923,13 @@ msgid "" "(the call to the class). The return value of :meth:`__new__` should be the " "new object instance (usually an instance of *cls*)." msgstr "" +"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*)." #: ../Doc/reference/datamodel.rst:1121 msgid "" @@ -1320,6 +1938,10 @@ msgid "" "with appropriate arguments and then modifying the newly-created instance as " "necessary before returning it." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:1126 msgid "" @@ -1328,12 +1950,18 @@ msgid "" "*self* is the new instance and the remaining arguments are the same as were " "passed to :meth:`__new__`." msgstr "" +"Si :meth:`__new__` renvoie une instance de *cls*, alors la méthode :meth:" +"`__init__` de la nouvelle instance est invoquée avec " +"``__init__(self[, ...])`` où *self* est la nouvelle instance et les autres " +"arguments sont les mêmes que ceux passés à :meth:`__new__`." #: ../Doc/reference/datamodel.rst:1131 msgid "" "If :meth:`__new__` does not return an instance of *cls*, then the new " "instance's :meth:`__init__` method will not be invoked." msgstr "" +"Si :meth:`__new__` ne renvoie pas une instance de *cls*, alors la méthode :" +"meth:`__init__` de la nouvelle instance n'est pas invoquée." #: ../Doc/reference/datamodel.rst:1134 msgid "" @@ -1342,6 +1970,10 @@ msgid "" "commonly overridden in custom metaclasses in order to customize class " "creation." msgstr "" +"L'objectif de :meth:`__new__` est principalement, pour les sous-classes de " +"types immuables (comme int, str ou tuple), d'autoriser la création sur " +"mesure des instances. Elle est aussi souvent surchargée dans les méta-" +"classes pour particulariser la création des classes." #: ../Doc/reference/datamodel.rst:1143 msgid "" @@ -1352,6 +1984,13 @@ msgid "" "ensure proper initialization of the base class part of the instance; for " "example: ``super().__init__([args...])``." msgstr "" +"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 une 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 explicitement appeler cette méthode pour assurer une " +"initialisation correcte de la partie classe de base de l'instance ; par " +"exemple : ``super().__init__([args...])``." #: ../Doc/reference/datamodel.rst:1150 msgid "" @@ -1360,6 +1999,10 @@ msgid "" "it), no non-``None`` value may be returned by :meth:`__init__`; doing so " "will cause a :exc:`TypeError` to be raised at runtime." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:1163 msgid "" @@ -1369,6 +2012,11 @@ msgid "" "explicitly call it to ensure proper deletion of the base class part of the " "instance." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:1169 msgid "" @@ -1379,12 +2027,20 @@ msgid "" "about to be destroyed; the current :term:`CPython` implementation only calls " "it once." msgstr "" +"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." #: ../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." msgstr "" +"Il n'est pas garanti que soient appelées les méthodes :meth:`__del__` des " +"objets qui existent toujours quand l'interpréteur termine." #: ../Doc/reference/datamodel.rst:1181 msgid "" @@ -1392,10 +2048,13 @@ msgid "" "the reference count for ``x`` by one, and the latter is only called when " "``x``'s reference count reaches zero." msgstr "" +"``del x`` n'appelle pas directement ``x.__del__()`` --- la première " +"décrémente le compteur de références de ``x``. La seconde n'est appelée que " +"quand le compteur de références de ``x`` atteint zéro." #: ../Doc/reference/datamodel.rst:1196 msgid "Documentation for the :mod:`gc` module." -msgstr "" +msgstr "Documentation du module :mod:`gc`." #: ../Doc/reference/datamodel.rst:1200 msgid "" @@ -1403,6 +2062,9 @@ msgid "" "invoked, exceptions that occur during their execution are ignored, and a " "warning is printed to ``sys.stderr`` instead. In particular:" msgstr "" +"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 :" #: ../Doc/reference/datamodel.rst:1204 msgid "" @@ -1412,6 +2074,12 @@ msgid "" "may already be taken by the code that gets interrupted to execute :meth:" "`__del__`." msgstr "" +":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__`." #: ../Doc/reference/datamodel.rst:1210 msgid "" @@ -1423,6 +2091,15 @@ msgid "" "such globals exist, this may help in assuring that imported modules are " "still available at the time when the :meth:`__del__` method is called." msgstr "" +":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." #: ../Doc/reference/datamodel.rst:1225 msgid "" @@ -1435,12 +2112,24 @@ msgid "" "`__repr__` but not :meth:`__str__`, then :meth:`__repr__` is also used when " "an \"informal\" string representation of instances of that class is required." msgstr "" +"Appelée par la fonction native :func:`repr` pour calculer la représentation " +"\"officielle\" en chaîne de caractères d'un objet. Tout est fait pour que " +"celle-ci ressemble à une expression Python valide pouvant être utilisée pour " +"recréer un objet avec la même valeur (dans un environnement donné). Si ce " +"n'est pas possible, une chaîne de la forme ``<...une description utile...>`` " +"est renvoyée. La valeur renvoyée doit être un objet chaîne de caractères. Si " +"une classe définit :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." #: ../Doc/reference/datamodel.rst:1234 msgid "" "This is typically used for debugging, so it is important that the " "representation is information-rich and unambiguous." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:1245 msgid "" @@ -1449,6 +2138,10 @@ msgid "" "string representation of an object. The return value must be a :ref:`string " "` object." msgstr "" +"Appelée par :func:`str(objet)` 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 `." #: ../Doc/reference/datamodel.rst:1250 msgid "" @@ -1456,18 +2149,25 @@ msgid "" "expectation that :meth:`__str__` return a valid Python expression: a more " "convenient or concise representation can be used." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:1254 msgid "" "The default implementation defined by the built-in type :class:`object` " "calls :meth:`object.__repr__`." msgstr "" +"C'est l'implémentation par défaut des appels à :meth:`object.__repr__` du " +"type natif :class:`object`." #: ../Doc/reference/datamodel.rst:1264 msgid "" "Called by :ref:`bytes ` to compute a byte-string representation " "of an object. This should return a :class:`bytes` object." msgstr "" +"Appelée par :ref:`bytes ` pour calculer une représentation en " +"chaîne *bytes* d'un objet. Elle doit renvoyer un objet :class:`bytes`." #: ../Doc/reference/datamodel.rst:1275 msgid "" @@ -1480,21 +2180,34 @@ msgid "" "classes will either delegate formatting to one of the built-in types, or use " "a similar formatting option syntax." msgstr "" +"Appelée par la fonction native :func:`format` et, par extension, lors de " +"l'évaluation de :ref:`formatted string literals ` 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." #: ../Doc/reference/datamodel.rst:1285 msgid "" "See :ref:`formatspec` for a description of the standard formatting syntax." msgstr "" +"Lisez :ref:`formatspec` pour une description de la syntaxe standard du " +"formatage." #: ../Doc/reference/datamodel.rst:1287 msgid "The return value must be a string object." -msgstr "" +msgstr "La valeur renvoyée doit être un objet chaîne de caractères." #: ../Doc/reference/datamodel.rst:1289 msgid "" "The __format__ method of ``object`` itself raises a :exc:`TypeError` if " "passed any non-empty string." msgstr "" +"La méthode __format__ de ``object`` lui-même lève une :exc:`TypeError` si " +"vous lui passez une chaîne non vide." #: ../Doc/reference/datamodel.rst:1305 msgid "" @@ -1504,6 +2217,11 @@ msgid "" "``x!=y`` calls ``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` " "calls ``x.__ge__(y)``." msgstr "" +"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 : " +"``xy`` appelle " +"``x.__gt__(y)`` et ``x>=y`` appelle ``x.__ge__(y)``." #: ../Doc/reference/datamodel.rst:1311 msgid "" @@ -1515,6 +2233,14 @@ msgid "" "statement), Python will call :func:`bool` on the value to determine if the " "result is true or false." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:1318 msgid "" @@ -1525,6 +2251,12 @@ msgid "" "ordering operations from a single root operation, see :func:`functools." "total_ordering`." msgstr "" +"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.__hash__``." msgstr "" +"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__ = " +".__hash__``." #: ../Doc/reference/datamodel.rst:1392 msgid "" @@ -1612,6 +2398,11 @@ msgid "" "`TypeError` would be incorrectly identified as hashable by an " "``isinstance(obj, collections.Hashable)`` call." msgstr "" +"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 explicitement :exc:`TypeError` serait incorrectement identifiée comme " +"hachable par un appel à ``isinstance(obj, collections.Hashable)``." #: ../Doc/reference/datamodel.rst:1401 msgid "" @@ -1620,6 +2411,11 @@ msgid "" "constant within an individual Python process, they are not predictable " "between repeated invocations of Python." msgstr "" +"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." #: ../Doc/reference/datamodel.rst:1406 msgid "" @@ -1628,6 +2424,11 @@ msgid "" "insertion, O(n^2) complexity. See http://www.ocert.org/advisories/" "ocert-2011-003.html for details." msgstr "" +"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 (article en anglais)." #: ../Doc/reference/datamodel.rst:1411 msgid "" @@ -1635,6 +2436,10 @@ msgid "" "mappings. Python has never made guarantees about this ordering (and it " "typically varies between 32-bit and 64-bit builds)." msgstr "" +"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)." #: ../Doc/reference/datamodel.rst:1415 msgid "See also :envvar:`PYTHONHASHSEED`." @@ -1642,7 +2447,7 @@ msgstr "Voir aussi :envvar:`PYTHONHASHSEED`." #: ../Doc/reference/datamodel.rst:1417 msgid "Hash randomization is enabled by default." -msgstr "" +msgstr "la randomisation des empreintes est activée par défaut." #: ../Doc/reference/datamodel.rst:1425 msgid "" @@ -1652,10 +2457,16 @@ msgid "" "considered true if its result is nonzero. If a class defines neither :meth:" "`__len__` nor :meth:`__bool__`, all its instances are considered true." msgstr "" +"Appelée pour implémenter les tests booléens 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." #: ../Doc/reference/datamodel.rst:1436 msgid "Customizing attribute access" -msgstr "" +msgstr "Personnalisation de l'accès aux attributs" #: ../Doc/reference/datamodel.rst:1438 msgid "" @@ -1663,6 +2474,9 @@ msgid "" "access (use of, assignment to, or deletion of ``x.name``) for class " "instances." msgstr "" +"Les méthodes suivantes peuvent être définies pour personnaliser l'accès aux " +"attributs (utilisation, assignation, suppression de ``x.name``) pour les " +"instances de classes." #: ../Doc/reference/datamodel.rst:1446 msgid "" @@ -1673,6 +2487,13 @@ msgid "" "`AttributeError`). This method should either return the (computed) " "attribute value or raise an :exc:`AttributeError` exception." msgstr "" +"Appelée lorsque l'accès par défaut à l'attribut échoue en levant :exc:" +"`AttributeError` (soit :meth:`__getattribute__` lève :exc:`AttributeError` " +"car *name* n'est pas un attribut de l'instance ou un attribut dans " +"l'arborescence de la classe de ``self`` ; ou :meth:`__get__` de la propriété " +"*name* lève :exc:`AttributeError`). Cette méthode doit retourner soit la " +"valeur (calculée) de l'attribut, soit lever une exception :exc:" +"`AttributeError`." #: ../Doc/reference/datamodel.rst:1453 msgid "" @@ -1686,6 +2507,16 @@ msgid "" "object). See the :meth:`__getattribute__` method below for a way to " "actually get total control over attribute access." msgstr "" +"Notez que si l'attribut est trouvé par le mécanisme normal, :meth:" +"`__getattr__` n'est pas appelée (c'est une asymétrie voulue entre :meth:" +"`__getattr__` et :meth:`__setattr__`). Ce comportement est adopté à la fois " +"pour des raisons de performance et parce que, sinon, :meth:`__getattr__` " +"n'aurait aucun moyen d'accéder aux autres attributs de l'instance. Notez " +"que, au moins pour ce qui concerne les variables d'instance, vous pouvez " +"simuler un contrôle total en n'insérant aucune valeur dans le dictionnaire " +"des attributs de l'instance (mais en les insérant dans un autre objet à la " +"place). Lisez la partie relative à la méthode :meth:`__getattribute__` ci-" +"dessous pour obtenir un contrôle total effectif sur l'accès aux attributs." #: ../Doc/reference/datamodel.rst:1466 msgid "" @@ -1698,6 +2529,16 @@ msgid "" "base class method with the same name to access any attributes it needs, for " "example, ``object.__getattribute__(self, name)``." msgstr "" +"Appelée de manière inconditionnelle pour implémenter l'accès aux attributs " +"des instances de la classe. Si la classe définit également :meth:" +"`__getattr__`, cette dernière n'est pas appelée à moins que :meth:" +"`__getattribute__` ne l'appelle explicitement ou ne lève une exception :exc:" +"`AttributeError`. Cette méthode doit renvoyer la valeur (calculée) de " +"l'attribut ou lever une exception :exc:`AttributeError`. Afin d'éviter une " +"récursion infinie sur cette méthode, son implémentation doit toujours " +"appeler la méthode de la classe de base avec le même paramètre *name* pour " +"accéder à n'importe quel attribut dont elle a besoin. Par exemple, ``object." +"__getattribute__(self, name)``." #: ../Doc/reference/datamodel.rst:1477 msgid "" @@ -1705,6 +2546,9 @@ msgid "" "result of implicit invocation via language syntax or built-in functions. " "See :ref:`special-lookup`." msgstr "" +"Cette méthode peut être shuntée lorsque la recherche porte sur les méthodes " +"spéciales en tant que résultat d'une invocation implicite *via* la syntaxe " +"du langage ou les fonctions natives. Lisez :ref:`special-lookup`." #: ../Doc/reference/datamodel.rst:1484 msgid "" @@ -1712,6 +2556,10 @@ msgid "" "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 "" +"Appelée lors d'une assignation d'attribut. Elle est appelée à la place du " +"mécanisme normal (c'est-à-dire stocker la valeur dans le dictionnaire de " +"l'instance). *name* est le nom de l'attribut, *value* est la valeur à " +"assigner à cet attribut." #: ../Doc/reference/datamodel.rst:1488 msgid "" @@ -1719,6 +2567,9 @@ msgid "" "call the base class method with the same name, for example, ``object." "__setattr__(self, name, value)``." msgstr "" +"Si :meth:`__setattr__` veut assigner un attribut d'instance, elle doit " +"appeler la méthode de la classe de base avec le même nom, par exemple " +"``object.__setattr__(self, name, value)``." #: ../Doc/reference/datamodel.rst:1495 msgid "" @@ -1726,16 +2577,22 @@ msgid "" "This should only be implemented if ``del obj.name`` is meaningful for the " "object." msgstr "" +"Comme :meth:`__setattr__` mais pour supprimer un attribut au lieu de " +"l'assigner. Elle ne doit être implémentée que si ``del obj.name`` a du sens " +"pour cet objet." #: ../Doc/reference/datamodel.rst:1501 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 "" +"Appelée quand :func:`dir` est appelée sur l'objet. Elle doit renvoyer une " +"séquence. :func:`dir` convertit la séquence renvoyée en liste et effectue le " +"classement." #: ../Doc/reference/datamodel.rst:1506 msgid "Customizing module attribute access" -msgstr "" +msgstr "Personnalisation de l'accès aux attributs d'un module" #: ../Doc/reference/datamodel.rst:1511 msgid "" @@ -1743,6 +2600,10 @@ msgid "" "attributes, properties, etc.), one can set the ``__class__`` attribute of a " "module object to a subclass of :class:`types.ModuleType`. For example::" msgstr "" +"Pour une personnalisation plus fine du comportement d'un module (assignation " +"des attributs, propriétés, etc.), vous pouvez assigner l'attribut " +"``__class__`` d'un objet module à une sous-classe de :class:`types." +"ModuleType`. Par exemple ::" #: ../Doc/reference/datamodel.rst:1529 msgid "" @@ -1751,14 +2612,19 @@ msgid "" "within the module, or via a reference to the module's globals dictionary) is " "unaffected." msgstr "" +"Définir ``__class__`` pour le module affecte uniquement les recherches qui " +"utilisent la syntaxe d'accès aux attributs -- accéder directement aux " +"globales d'un module (soit par le code dans le module, soit *via* une " +"référence au dictionnaire des variables globales du module) fonctionne " +"toujours de la même façon." #: ../Doc/reference/datamodel.rst:1534 msgid "``__class__`` module attribute is now writable." -msgstr "" +msgstr "l'attribut ``__class__`` du module est maintenant en lecture-écriture." #: ../Doc/reference/datamodel.rst:1541 msgid "Implementing Descriptors" -msgstr "" +msgstr "Implémentation de descripteurs" #: ../Doc/reference/datamodel.rst:1543 msgid "" @@ -1769,6 +2635,13 @@ msgid "" "\" refers to the attribute whose name is the key of the property in the " "owner class' :attr:`~object.__dict__`." msgstr "" +"Les méthodes qui suivent s'appliquent seulement quand une instance de la " +"classe (dite classe *descripteur*) contenant la méthode apparaît dans une " +"classe *propriétaire* (*owner* en anglais) ; la classe descripteur doit " +"figurer dans le dictionnaire de la classe propriétaire ou dans le " +"dictionnaire de la classe d'un des parents. Dans les exemples ci-dessous, " +"\"l'attribut\" fait référence à l'attribut dont le nom est une clé du :attr:" +"`~object.__dict__` de la classe propriétaire." #: ../Doc/reference/datamodel.rst:1553 msgid "" @@ -1779,23 +2652,35 @@ msgid "" "*owner*. This method should return the (computed) attribute value or raise " "an :exc:`AttributeError` exception." msgstr "" +"Appelée pour obtenir l'attribut de la classe propriétaire (accès à un " +"attribut de classe) ou d'une instance de cette classe (accès à un attribut " +"d'instance). *owner* est toujours la classe propriétaire alors que " +"*instance* est l'instance par laquelle on accède à l'attribut ou ``None`` " +"lorsque l'on accède par la classe *owner*. Cette méthode doit renvoyer la " +"valeur (calculée) de l'attribut ou lever une exception :exc:`AttributeError`." #: ../Doc/reference/datamodel.rst:1563 msgid "" "Called to set the attribute on an instance *instance* of the owner class to " "a new value, *value*." msgstr "" +"Appelée pour définir l'attribut d'une instance *instance* de la classe " +"propriétaire à la nouvelle valeur *value*." #: ../Doc/reference/datamodel.rst:1569 msgid "" "Called to delete the attribute on an instance *instance* of the owner class." msgstr "" +"Appelée pour supprimer l'attribut de l'instance *instance* de la classe " +"propriétaire." #: ../Doc/reference/datamodel.rst:1574 msgid "" "Called at the time the owning class *owner* is created. The descriptor has " "been assigned to *name*." msgstr "" +"Appelée au moment où la classe propriétaire *owner* est créée. La classe " +"descripteur a été assignée à *name*." #: ../Doc/reference/datamodel.rst:1580 msgid "" @@ -1807,10 +2692,17 @@ msgid "" "argument (for example, CPython sets this attribute for unbound methods that " "are implemented in C)." msgstr "" +"L'attribut :attr:`__objclass__` est interprété par le module :mod:`inspect` " +"comme spécifiant la classe où cet objet a été défini (le définir " +"correctement peut vous aider dans l'introspection des classes dynamiques à " +"l'exécution). Pour les appelables, cela peut indiquer qu'une instance d'un " +"certain type (ou d'une certaine sous-classe) est attendue ou requise comme " +"premier argument positionnel (par exemple, CPython définit cet attribut pour " +"les méthodes non liées qui sont implémentées en C)." #: ../Doc/reference/datamodel.rst:1591 msgid "Invoking Descriptors" -msgstr "" +msgstr "Invocation des descripteurs" #: ../Doc/reference/datamodel.rst:1593 msgid "" @@ -1819,6 +2711,12 @@ msgid "" "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 "" +"En général, un descripteur est un attribut d'objet dont le comportement est " +"\"lié\" (*binding dehavior* en anglais), c'est-à-dire que les accès aux " +"attributs ont été surchargés par des méthodes conformes au protocole des " +"descripteurs : :meth:`__get__`, :meth:`__set__` et :meth:`__delete__`. Si " +"l'une de ces méthodes est définie pour un objet, il est réputé être un " +"descripteur." #: ../Doc/reference/datamodel.rst:1598 msgid "" @@ -1827,6 +2725,11 @@ msgid "" "chain starting with ``a.__dict__['x']``, then ``type(a).__dict__['x']``, and " "continuing through the base classes of ``type(a)`` excluding metaclasses." msgstr "" +"Le comportement par défaut pour la gestion d'un attribut est de définir, " +"obtenir et supprimer cet attribut du dictionnaire de l'objet. Par exemple, " +"pour ``a.x`` Python commence d'abord par rechercher ``a.__dict__['x']``, " +"puis ``type(a).__dict__['x']`` ; ensuite Python continue en remontant les " +"classes de base de ``type(a)``, en excluant les méta-classes." #: ../Doc/reference/datamodel.rst:1603 msgid "" @@ -1835,46 +2738,59 @@ msgid "" "descriptor method instead. Where this occurs in the precedence chain " "depends on which descriptor methods were defined and how they were called." msgstr "" +"Cependant, si la valeur cherchée est un objet qui définit une des méthodes " +"de descripteur, alors Python modifie son comportement et invoque la méthode " +"du descripteur à la place. Le moment où cela intervient dans la recherche " +"citée ci-dessus dépend de l'endroit où a été définie la méthode de " +"descripteur et comment elle a été appelée." #: ../Doc/reference/datamodel.rst:1608 msgid "" "The starting point for descriptor invocation is a binding, ``a.x``. How the " "arguments are assembled depends on ``a``:" msgstr "" +"Le point de départ pour une invocation de descripteur est la liaison ``a." +"x``. La façon dont les arguments sont assemblés dépend de ``a`` :" #: ../Doc/reference/datamodel.rst:1613 msgid "Direct Call" -msgstr "" +msgstr "Appel direct" #: ../Doc/reference/datamodel.rst:1612 msgid "" "The simplest and least common call is when user code directly invokes a " "descriptor method: ``x.__get__(a)``." msgstr "" +"Le plus simple et le plus rare des appels est quand l'utilisateur code " +"directement l'appel à la méthode du descripteur : ``x.__get__(a)``." #: ../Doc/reference/datamodel.rst:1617 msgid "Instance Binding" -msgstr "" +msgstr "Liaison avec une instance" #: ../Doc/reference/datamodel.rst:1616 msgid "" "If binding to an object instance, ``a.x`` is transformed into the call: " "``type(a).__dict__['x'].__get__(a, type(a))``." msgstr "" +"Si elle est liée à un objet instance, ``a.x`` est transformé en l'appel " +"suivant : ``type(a).__dict__['x'].__get__(a, type(a))``." #: ../Doc/reference/datamodel.rst:1621 msgid "Class Binding" -msgstr "" +msgstr "Liaison avec une classe" #: ../Doc/reference/datamodel.rst:1620 msgid "" "If binding to a class, ``A.x`` is transformed into the call: ``A." "__dict__['x'].__get__(None, A)``." msgstr "" +"Si elle est liée à une classe, ``A.x`` est transformé en l'appel suivant : " +"``A.__dict__['x'].__get__(None, A)``." #: ../Doc/reference/datamodel.rst:1627 msgid "Super Binding" -msgstr "" +msgstr "Liaison super" #: ../Doc/reference/datamodel.rst:1624 msgid "" @@ -1883,6 +2799,10 @@ msgid "" "immediately preceding ``B`` and then invokes the descriptor with the call: " "``A.__dict__['m'].__get__(obj, obj.__class__)``." msgstr "" +"Si ``a`` est une instance de :class:`super`, alors ``super(B, obj).m()`` " +"recherche ``obj.__class__.__mro__`` pour la classe de base ``A`` " +"immédiatement avant ``B`` puis invoque le descripteur avec l'appel suivant : " +"``A.__dict__['m'].__get__(obj, obj.__class__)``." #: ../Doc/reference/datamodel.rst:1629 msgid "" @@ -1899,6 +2819,21 @@ msgid "" "defined always override a redefinition in an instance dictionary. In " "contrast, non-data descriptors can be overridden by instances." msgstr "" +"Pour des liaisons avec des instances, la priorité à l'invocation du " +"descripteur dépend des méthodes que le descripteur a définies. Un " +"descripteur peut définir n'importe quelle combinaison de :meth:`__get__`, :" +"meth:`__set__` et :meth:`__delete__`. S'il ne définit pas :meth:`__get__`, " +"alors accéder à l'attribut retourne l'objet descripteur lui-même sauf s'il " +"existe une valeur dans le dictionnaire de l'objet instance. Si le " +"descripteur définit :meth:`__set__` ou :meth:`__delete__`, c'est un " +"descripteur de données ; s'il ne définit aucune méthode, c'est un " +"descripteur hors-donnée. Normalement, les descripteurs de données " +"définissent à la fois :meth:`__get__` et :meth:`__set__`, alors que les " +"descripteurs hors-données définissent seulement la méthode :meth:`__get__`. " +"Les descripteurs de données qui définissent :meth:`__set__` et :meth:" +"`__get__` sont toujours prioritaires face à une redéfinition du dictionnaire " +"de l'instance. En revanche, les descripteurs hors-données peuvent être " +"shuntés par les instances." #: ../Doc/reference/datamodel.rst:1642 msgid "" @@ -1907,12 +2842,20 @@ msgid "" "and override methods. This allows individual instances to acquire behaviors " "that differ from other instances of the same class." msgstr "" +"Les méthodes Python (y compris :func:`staticmethod` et :func:`classmethod`) " +"sont implémentées comme des descripteurs hors-donnée. De la même manière, " +"les instances peuvent redéfinir et surcharger les méthodes. Ceci permet à " +"chaque instance d'avoir un comportement qui diffère des autres instances de " +"la même classe." #: ../Doc/reference/datamodel.rst:1647 msgid "" "The :func:`property` function is implemented as a data descriptor. " "Accordingly, instances cannot override the behavior of a property." msgstr "" +"La fonction :func:`property` est implémentée en tant que descripteur de " +"données. Ainsi, les instances ne peuvent pas surcharger le comportement " +"d'une propriété." #: ../Doc/reference/datamodel.rst:1654 msgid "__slots__" @@ -1924,10 +2867,16 @@ msgid "" "and deny the creation of *__dict__* and *__weakref__* (unless explicitly " "declared in *__slots__* or available in a parent.)" msgstr "" +"Les *__slots__* vous permettent de déclarer des membres d'une donnée (comme " +"une propriété) et d'interdire la création de *__dict__* ou de *__weakref__* " +"(à moins qu'ils ne soient explicitement déclarés dans le *__slots__* ou " +"présent dans le parent)." #: ../Doc/reference/datamodel.rst:1660 msgid "The space saved over using *__dict__* can be significant." msgstr "" +"L'espace gagné par rapport à l'utilisation d'un *__dict__* peut être " +"significatif." #: ../Doc/reference/datamodel.rst:1664 msgid "" @@ -1936,16 +2885,23 @@ msgid "" "for the declared variables and prevents the automatic creation of *__dict__* " "and *__weakref__* for each instance." msgstr "" +"Cette variable de classe peut être assignée avec une chaîne, un itérable ou " +"une séquence de chaînes avec les noms de variables utilisés par les " +"instances. *__slots__* réserve de la place pour ces variables déclarées et " +"interdit la création automatique de *__dict__* et *__weakref__* pour chaque " +"instance." #: ../Doc/reference/datamodel.rst:1671 msgid "Notes on using *__slots__*" -msgstr "" +msgstr "Note sur l'utilisation de *__slots__*" #: ../Doc/reference/datamodel.rst:1673 msgid "" "When inheriting from a class without *__slots__*, the *__dict__* and " "*__weakref__* attribute of the instances will always be accessible." msgstr "" +"Lorsque vous héritez d'une classe sans *__slots__*, les attributs *__dict__* " +"et *__weakref__* des instances sont toujours accessibles." #: ../Doc/reference/datamodel.rst:1676 msgid "" @@ -1955,6 +2911,11 @@ msgid "" "variables is desired, then add ``'__dict__'`` to the sequence of strings in " "the *__slots__* declaration." msgstr "" +"Sans variable *__dict__*, les instances ne peuvent pas assigner de nouvelles " +"variables (non listées dans la définition de *__slots__*). Les tentatives " +"d'assignation sur un nom de variable non listé lève :exc:`AttributeError`. " +"Si l'assignation dynamique de nouvelles variables est nécessaire, ajoutez " +"``'__dict__'`` à la séquence de chaînes dans la déclaration *__slots__*." #: ../Doc/reference/datamodel.rst:1682 msgid "" @@ -1963,6 +2924,11 @@ msgid "" "reference support is needed, then add ``'__weakref__'`` to the sequence of " "strings in the *__slots__* declaration." msgstr "" +"Sans variable *__weakref__* pour chaque instance, les classes qui " +"définissent *__slots__* ne gèrent pas les références faibles vers leurs " +"instances. Si vous avez besoin de gérer des références faibles, ajoutez " +"``'__weakref__'`` à la séquence de chaînes dans la déclaration de " +"*__slots__*." #: ../Doc/reference/datamodel.rst:1687 msgid "" @@ -1971,6 +2937,11 @@ msgid "" "be used to set default values for instance variables defined by *__slots__*; " "otherwise, the class attribute would overwrite the descriptor assignment." msgstr "" +"Les *__slots__* sont implémentés au niveau de la classe en créant des " +"descripteurs (:ref:`descriptors`) pour chaque nom de variable. Ainsi, les " +"attributs de classe ne peuvent pas être utilisés pour des valeurs par défaut " +"aux variables d'instances définies par *__slots__* ; sinon, l'attribut de " +"classe surchargerait l'assignation par descripteur." #: ../Doc/reference/datamodel.rst:1693 msgid "" @@ -1980,6 +2951,11 @@ msgid "" "they also define *__slots__* (which should only contain names of any " "*additional* slots)." msgstr "" +"L'action de la déclaration du *__slots__* ne se limite pas à la classe où il " +"est défini. Les *__slots__* déclarés par les parents sont disponibles dans " +"les classes enfants. Cependant, les sous-classes enfants ont un *__dict__* " +"et un *__weakref__* à moins qu'elles ne définissent aussi un *__slots__* " +"(qui ne doit contenir alors que les noms *supplémentaires* du slot)." #: ../Doc/reference/datamodel.rst:1699 msgid "" @@ -1989,12 +2965,20 @@ msgid "" "meaning of the program undefined. In the future, a check may be added to " "prevent this." msgstr "" +"Si une classe définit un slot aussi défini dans une classe de base, la " +"variable d'instance définie par la classe de base est inaccessible (sauf à " +"utiliser le descripteur de la classe de base directement). Cela rend la " +"signification du programme indéfinie. Dans le futur, une vérification sera " +"ajoutée pour empêcher cela." #: ../Doc/reference/datamodel.rst:1704 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 "" +"Un *__slot__* non vide ne fonctionne pas pour les classes dérivées des types " +"natifs à longueur variable tels que :class:`int`, :class:`bytes` et :class:" +"`tuple`." #: ../Doc/reference/datamodel.rst:1707 msgid "" @@ -2002,11 +2986,17 @@ msgid "" "used; however, in the future, special meaning may be assigned to the values " "corresponding to each key." msgstr "" +"Tout itérable qui n'est pas une chaîne peut être assigné à un *__slots__*. " +"Les tableaux de correspondance peuvent aussi être utilisés ; cependant, dans " +"le futur, des significations spéciales pourraient être associées à chacune " +"des clés." #: ../Doc/reference/datamodel.rst:1711 msgid "" "*__class__* assignment works only if both classes have the same *__slots__*." msgstr "" +"Les assignations de *__class__* ne fonctionnent que si les deux classes ont " +"le même *__slots__*." #: ../Doc/reference/datamodel.rst:1713 msgid "" @@ -2014,10 +3004,14 @@ msgid "" "only one parent is allowed to have attributes created by slots (the other " "bases must have empty slot layouts) - violations raise :exc:`TypeError`." msgstr "" +"L'héritage multiple avec plusieurs classes parentes qui ont des *__slots__* " +"est possible, mais seul un parent peut avoir des attributs créés par " +"*__slots__* (les autres classes parentes doivent avoir des *__slots__* " +"vides). La violation de cette règle lève :exc:`TypeError`." #: ../Doc/reference/datamodel.rst:1721 msgid "Customizing class creation" -msgstr "" +msgstr "Personnalisation de la création de classes" #: ../Doc/reference/datamodel.rst:1723 msgid "" @@ -2028,6 +3022,13 @@ msgid "" "``__init_subclass__`` solely applies to future subclasses of the class " "defining the method." msgstr "" +"Quand une classe hérite d'une classe parente, *__init_subclass__* de la " +"classe parente est appelée. Ainsi, il est possible d'écrire des classes qui " +"modifient le comportement des sous-classes. Ce comportement est corrélé aux " +"décorateurs de classes mais, alors que les décorateurs de classes agissent " +"seulement sur la classe qu'ils décorent, ``__init_subclass__`` agit " +"uniquement sur les futures sous-classes de la classe qui définit cette " +"méthode." #: ../Doc/reference/datamodel.rst:1732 msgid "" @@ -2035,6 +3036,9 @@ msgid "" "then the new subclass. If defined as a normal instance method, this method " "is implicitly converted to a class method." msgstr "" +"Cette méthode est appelée quand la classe est sous-classée. *cls* est alors " +"la nouvelle sous-classe. Si elle est définie en tant que méthode d'instance " +"normale, cette méthode est implicitement convertie en méthode de classe." #: ../Doc/reference/datamodel.rst:1736 msgid "" @@ -2043,12 +3047,19 @@ msgid "" "``__init_subclass__``, one should take out the needed keyword arguments and " "pass the others over to the base class, as in::" msgstr "" +"Les arguments nommés qui sont donnés à la nouvelle classe sont passés à " +"``__init_subclass__`` de la classe parente. Par souci de compatibilité avec " +"les autres classes qui utilisent ``__init_subclass__``, vous devez enlevez " +"les arguments nommés dont vous avez besoin et passer les autres à la classe " +"de base, comme ci-dessous ::" #: ../Doc/reference/datamodel.rst:1750 msgid "" "The default implementation ``object.__init_subclass__`` does nothing, but " "raises an error if it is called with any arguments." msgstr "" +"L'implémentation par défaut ``object.__init_subclass__`` ne fait rien mais " +"lève une erreur si elle est appelée avec un argument." #: ../Doc/reference/datamodel.rst:1755 msgid "" @@ -2057,10 +3068,14 @@ msgid "" "actual metaclass (rather than the explicit hint) can be accessed as " "``type(cls)``." msgstr "" +"L'indication de méta-classe ``metaclass`` est absorbée par le reste du " +"mécanisme de types et n'est jamais passée à l'implémentation de " +"``__init_subclass__``. La méta-classe réelle (plutôt que l'indication " +"explicite) peut être récupérée par ``type(cls)``." #: ../Doc/reference/datamodel.rst:1766 msgid "Metaclasses" -msgstr "" +msgstr "Méta-classes" #: ../Doc/reference/datamodel.rst:1772 msgid "" @@ -2068,6 +3083,9 @@ msgid "" "executed in a new namespace and the class name is bound locally to the " "result of ``type(name, bases, namespace)``." msgstr "" +"Par défaut, les classes sont construites en utilisant :func:`type`. Le corps " +"de la classe est exécuté dans un nouvel espace de noms et le nom de la " +"classe est lié localement au résultat de `type(name, bases, namespace)``." #: ../Doc/reference/datamodel.rst:1776 msgid "" @@ -2076,58 +3094,76 @@ msgid "" "existing class that included such an argument. In the following example, " "both ``MyClass`` and ``MySubclass`` are instances of ``Meta``::" msgstr "" +"Le déroulement de création de la classe peut être personnalisé en passant " +"l'argument nommé ``metaclass`` dans la ligne de définition de la classe ou " +"en héritant d'une classe existante qui comporte déjà un tel argument. Dans " +"l'exemple qui suit, ``MyClass`` et ``MySubclass`` sont des instances de " +"``Meta`` ::" #: ../Doc/reference/datamodel.rst:1790 msgid "" "Any other keyword arguments that are specified in the class definition are " "passed through to all metaclass operations described below." msgstr "" +"Tout autre argument nommé spécifié dans la définition de la classe est passé " +"aux opérations de méta-classes décrites auparavant." #: ../Doc/reference/datamodel.rst:1793 msgid "When a class definition is executed, the following steps occur:" msgstr "" +"Quand la définition d'une classe est exécutée, les différentes étapes " +"suivies sont :" #: ../Doc/reference/datamodel.rst:1795 msgid "the appropriate metaclass is determined" -msgstr "" +msgstr "la méta-classe appropriée est déterminée ;" #: ../Doc/reference/datamodel.rst:1796 msgid "the class namespace is prepared" -msgstr "" +msgstr "l'espace de noms de la classe est préparé ;" #: ../Doc/reference/datamodel.rst:1797 msgid "the class body is executed" -msgstr "" +msgstr "le corps de la classe est exécuté ;" #: ../Doc/reference/datamodel.rst:1798 msgid "the class object is created" -msgstr "" +msgstr "l'objet classe est crée." #: ../Doc/reference/datamodel.rst:1801 msgid "Determining the appropriate metaclass" -msgstr "" +msgstr "Détermination de la méta-classe appropriée" #: ../Doc/reference/datamodel.rst:1805 msgid "" "The appropriate metaclass for a class definition is determined as follows:" msgstr "" +"La méta-classe appropriée pour une définition de classe est déterminée de la " +"manière suivante :" #: ../Doc/reference/datamodel.rst:1807 msgid "" "if no bases and no explicit metaclass are given, then :func:`type` is used" msgstr "" +"si aucune classe et aucune méta-classe n'est donnée, alors :func:`type` est " +"utilisée ;" #: ../Doc/reference/datamodel.rst:1808 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 "" +"si une méta-classe explicite est donnée et que *ce n'est pas* une instance " +"de :func:`type`, alors elle est utilisée directement en tant que méta-" +"classe ;" #: ../Doc/reference/datamodel.rst:1810 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 "" +"Si une instance de :func:`type` est donnée comme méta-classe explicite ou si " +"*bases* est définie, alors la méta-classe la plus dérivée est utilisée." #: ../Doc/reference/datamodel.rst:1813 msgid "" @@ -2137,10 +3173,16 @@ msgid "" "of these candidate metaclasses. If none of the candidate metaclasses meets " "that criterion, then the class definition will fail with ``TypeError``." msgstr "" +"La méta-classe la plus dérivée est choisie à partir des méta-classes " +"explicitement spécifiées (s'il y en a) et les méta-classes (c'est-à-dire les " +"``type(cls)``) de toutes les classes de base spécifiées. La méta-classe la " +"plus dérivée est celle qui est un sous-type de *toutes* ces méta-classes " +"candidates. Si aucune des méta-classes candidates ne remplit ce critère, " +"alors la définition de la classe échoue en levant ``TypeError``." #: ../Doc/reference/datamodel.rst:1823 msgid "Preparing the class namespace" -msgstr "" +msgstr "Préparation de l'espace de noms de la classe" #: ../Doc/reference/datamodel.rst:1828 msgid "" @@ -2149,24 +3191,33 @@ msgid "" "as ``namespace = metaclass.__prepare__(name, bases, **kwds)`` (where the " "additional keyword arguments, if any, come from the class definition)." msgstr "" +"Une fois que la méta-classe appropriée est identifiée, l'espace de noms de " +"la classe est préparé. Si la méta-classe possède un attribut " +"``__prepare__``, il est appelé avec ``namespace = metaclass." +"__prepare__(name, bases, **kwds)`` (où les arguments nommés supplémentaires, " +"s'il y en a, viennent de la définition de la classe)." #: ../Doc/reference/datamodel.rst:1833 msgid "" "If the metaclass has no ``__prepare__`` attribute, then the class namespace " "is initialised as an empty ordered mapping." msgstr "" +"Si la méta-classe ne possède pas d'attribut ``__prepare__``, alors l'espace " +"de noms de la classe est initialisé en tant que tableau de correspondances " +"ordonné." #: ../Doc/reference/datamodel.rst:1838 msgid ":pep:`3115` - Metaclasses in Python 3000" -msgstr "" +msgstr ":pep:`3115` - Méta-classes dans Python 3000" #: ../Doc/reference/datamodel.rst:1839 msgid "Introduced the ``__prepare__`` namespace hook" msgstr "" +"introduction de la fonction automatique ``__prepare__`` de l'espace de noms" #: ../Doc/reference/datamodel.rst:1843 msgid "Executing the class body" -msgstr "" +msgstr "Exécution du corps de la classe" #: ../Doc/reference/datamodel.rst:1848 msgid "" @@ -2176,6 +3227,12 @@ msgid "" "names from the current and outer scopes when the class definition occurs " "inside a function." msgstr "" +"Le corps de la classe est exécuté (approximativement) avec ``exec(body, " +"globals(), namespace)``. La principale différence avec un appel normal à :" +"func:`exec` est que la portée lexicale autorise le corps de la classe (y " +"compris les méthodes) à faire référence aux noms de la portée courante et " +"des portées externes lorsque la définition de classe a lieu dans une " +"fonction." #: ../Doc/reference/datamodel.rst:1854 msgid "" @@ -2185,10 +3242,16 @@ msgid "" "class methods, or through the implicit lexically scoped ``__class__`` " "reference described in the next section." msgstr "" +"Cependant, même quand une définition de classe intervient dans une fonction, " +"les méthodes définies à l'intérieur de la classe ne peuvent pas voir les " +"noms définis en dehors de la portée de la classe. On accède aux variables de " +"la classe *via* le premier paramètre des méthodes d'instance ou de classe, " +"ou *via* la référence implicite ``__class__`` incluse dans la portée " +"lexicale et décrite dans la section suivante." #: ../Doc/reference/datamodel.rst:1863 msgid "Creating the class object" -msgstr "" +msgstr "Création de l'objet classe" #: ../Doc/reference/datamodel.rst:1870 msgid "" @@ -2197,6 +3260,10 @@ msgid "" "**kwds)`` (the additional keywords passed here are the same as those passed " "to ``__prepare__``)." msgstr "" +"Quand l'espace de noms a été rempli en exécutant le corps de la classe, " +"l'objet classe est créé en appelant ``metaclass(name, bases, namespace, " +"**kwds)`` (les arguments nommés supplémentaires passés ici sont les mêmes " +"que ceux passés à ``__prepare__``)." #: ../Doc/reference/datamodel.rst:1875 msgid "" @@ -2208,6 +3275,14 @@ msgid "" "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 "" +"Cet objet classe est celui qui est référencé par la forme sans argument de :" +"func:`super`. ``__class__`` est une référence implicite créée par le " +"compilateur si une méthode du corps de la classe fait référence soit à " +"``__class__``, soit à ``super``. Ceci permet que la forme sans argument de :" +"func:`super` identifie la classe en cours de définition en fonction de la " +"portée lexicale, tandis que la classe ou l'instance utilisée pour effectuer " +"l'appel en cours est identifiée en fonction du premier argument transmis à " +"la méthode." #: ../Doc/reference/datamodel.rst:1885 msgid "" @@ -2218,6 +3293,12 @@ msgid "" "`DeprecationWarning` in Python 3.6, and a :exc:`RuntimeWarning` in the " "future." msgstr "" +"Dans CPython 3.6 et suivants, la cellule ``__class__`` est passée à la méta-" +"classe en tant qu'entrée ``__classcell__`` dans l'espace de noms de la " +"classe. Si elle est présente, elle doit être propagée à l'appel ``type .__ " +"new__`` pour que la classe soit correctement initialisée. Ne pas le faire se " +"traduit par un avertissement :exc:`DeprecationWarning` dans Python 3.6 et " +"un :exc:`RuntimeWarning` dans le futur." #: ../Doc/reference/datamodel.rst:1892 msgid "" @@ -2225,24 +3306,35 @@ msgid "" "ultimately calls ``type.__new__``, the following additional customisation " "steps are invoked after creating the class object:" msgstr "" +"Quand vous utilisez la méta-classe par défaut :class:`type` ou toute autre " +"méta-classe qui finit par appeler ``type.__new__``, les étapes de " +"personnalisation supplémentaires suivantes sont suivies après la création de " +"l'objet classe :" #: ../Doc/reference/datamodel.rst:1896 msgid "" "first, ``type.__new__`` collects all of the descriptors in the class " "namespace that define a :meth:`~object.__set_name__` method;" msgstr "" +"d'abord, ``type.__new__`` récupère, dans l'espace de noms de la classe, tous " +"les descripteurs qui définissent une méthode :meth:`~object.__set_name__` ;" #: ../Doc/reference/datamodel.rst:1898 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 "" +"ensuite, toutes ces méthodes ``__set_name__`` sont appelées avec la classe " +"en cours de définition et le nom assigné à chaque descripteur ;" #: ../Doc/reference/datamodel.rst:1900 msgid "" "finally, the :meth:`~object.__init_subclass__` hook is called on the " "immediate parent of the new class in its method resolution order." msgstr "" +"finalement, la méthode automatique :meth:`~object.__init_subclass__` est " +"appelée sur le parent immédiat de la nouvelle classe en utilisant l'ordre de " +"résolution des méthodes." #: ../Doc/reference/datamodel.rst:1903 msgid "" @@ -2250,6 +3342,10 @@ msgid "" "included in the class definition (if any) and the resulting object is bound " "in the local namespace as the defined class." msgstr "" +"Après la création de l'objet classe, il est passé aux décorateurs de la " +"classe, y compris ceux inclus dans la définition de la classe (s'il y en a) " +"et l'objet résultant est lié à l'espace de noms local en tant que classe " +"définie." #: ../Doc/reference/datamodel.rst:1907 msgid "" @@ -2258,18 +3354,25 @@ msgid "" "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 "" +"Quand une nouvelle classe est créée *via* ``type.__new__``, l'objet fourni " +"en tant que paramètre d'espace de noms est copié vers un nouveau tableau de " +"correspondances ordonné et l'objet original est laissé de côté. La nouvelle " +"copie est encapsulée dans un mandataire en lecture seule qui devient " +"l'attribut :attr:`~object.__dict__` de l'objet classe." #: ../Doc/reference/datamodel.rst:1914 msgid ":pep:`3135` - New super" -msgstr "" +msgstr ":pep:`3135` - nouvelle méthode super" #: ../Doc/reference/datamodel.rst:1915 msgid "Describes the implicit ``__class__`` closure reference" msgstr "" +"Décrit la référence à la fermeture (*closure* en anglais) de la " +"``__class__`` implicite" #: ../Doc/reference/datamodel.rst:1919 msgid "Metaclass example" -msgstr "" +msgstr "Exemple de méta-classe" #: ../Doc/reference/datamodel.rst:1921 msgid "" @@ -2278,12 +3381,20 @@ msgid "" "automatic property creation, proxies, frameworks, and automatic resource " "locking/synchronization." msgstr "" +"Les utilisations possibles des méta-classes sont immenses. Quelques pistes " +"ont déjà été explorées comme l'énumération, la gestion des traces, le " +"contrôle des interfaces, la délégation automatique, la création automatique " +"de propriétés, les mandataires, les cadriciels (*frameworks* en anglais) " +"ainsi que le verrouillage ou la synchronisation automatique de ressources." #: ../Doc/reference/datamodel.rst:1926 msgid "" "Here is an example of a metaclass that uses an :class:`collections." "OrderedDict` to remember the order that class variables are defined::" msgstr "" +"Voici un exemple de méta-classe qui utilise une :class:`collections." +"OrderedDict` pour mémoriser l'ordre dans lequel les variables de classe sont " +"définies ::" #: ../Doc/reference/datamodel.rst:1949 msgid "" @@ -2296,16 +3407,27 @@ msgid "" "That method builds the new type and it saves the ordered dictionary keys in " "an attribute called ``members``." msgstr "" +"Quand la définition de la classe *A* s'exécute, le processus commence par " +"appeler la méthode :meth:`__prepare__` de la méta-classe qui renvoie un :" +"class:`collections.OrderedDict` vide. Ce tableau de correspondances " +"enregistre les méthodes et attributs de *A* au fur et à mesure de leurs " +"définitions dans les instructions du corps de la classe. Une fois que ces " +"définitions ont été exécutées, le dictionnaire ordonné est complètement " +"peuplé et la méthode :meth:`__new__` de la méta-classe est appelée. Cette " +"méthode construit un nouveau type et sauve les clés du dictionnaire ordonné " +"dans un attribut appelé ``members``." #: ../Doc/reference/datamodel.rst:1960 msgid "Customizing instance and subclass checks" -msgstr "" +msgstr "Personnalisation des instances et vérification des sous-classes" #: ../Doc/reference/datamodel.rst:1962 msgid "" "The following methods are used to override the default behavior of the :func:" "`isinstance` and :func:`issubclass` built-in functions." msgstr "" +"Les méthodes suivantes sont utilisées pour surcharger le comportement par " +"défaut des fonctions natives :func:`isinstance` et :func:`issubclass`." #: ../Doc/reference/datamodel.rst:1965 msgid "" @@ -2314,6 +3436,10 @@ msgid "" "base classes\" to any class or type (including built-in types), including " "other ABCs." msgstr "" +"En particulier, la méta-classe :class:`abc.ABCMeta` implemente ces méthodes " +"pour autoriser l'ajout de classes de base abstraites (ABC pour *Abstract " +"Base Classes* en anglais) en tant que \"classes de base virtuelles\" pour " +"toute classe ou type (y compris les types natifs)." #: ../Doc/reference/datamodel.rst:1972 msgid "" @@ -2321,6 +3447,9 @@ msgid "" "instance of *class*. If defined, called to implement ``isinstance(instance, " "class)``." msgstr "" +"Renvoie ``True`` si *instance* doit être considérée comme une instance " +"(directe ou indirecte) de *class*. Si elle est définie, est elle appelée " +"pour implémenter ``isinstance(instance, class)``." #: ../Doc/reference/datamodel.rst:1979 msgid "" @@ -2328,6 +3457,9 @@ msgid "" "subclass of *class*. If defined, called to implement ``issubclass(subclass, " "class)``." msgstr "" +"Renvoie ``True`` si *subclass* doit être considérée comme une sous-classe " +"(directe ou indirecte) de *class*. Si elle est définie, appelée pour " +"implémenter ``issubclass(subclass, class)``." #: ../Doc/reference/datamodel.rst:1984 msgid "" @@ -2336,10 +3468,15 @@ msgid "" "consistent with the lookup of special methods that are called on instances, " "only in this case the instance is itself a class." msgstr "" +"Notez que ces méthodes sont recherchées dans le type (la méta-classe) d'une " +"classe. Elles ne peuvent pas être définies en tant que méthodes de classe " +"dans la classe réelle. C'est cohérent avec la recherche des méthodes " +"spéciales qui sont appelées pour les instances, sauf qu'ici l'instance est " +"elle-même une classe." #: ../Doc/reference/datamodel.rst:1995 msgid ":pep:`3119` - Introducing Abstract Base Classes" -msgstr "" +msgstr ":pep:`3119` - Introduction aux classes de bases abstraites" #: ../Doc/reference/datamodel.rst:1992 msgid "" @@ -2349,10 +3486,15 @@ msgid "" "context of adding Abstract Base Classes (see the :mod:`abc` module) to the " "language." msgstr "" +"Inclut la spécification pour la personnalisation du comportement de :func:" +"`isinstance` et :func:`issubclass` à travers :meth:`~class." +"__instancecheck__` et :meth:`~class.__subclasscheck__`, avec comme " +"motivation pour cette fonctionnalité l'ajout les classes de base abstraites " +"(voir le module :mod:`abc`) au langage." #: ../Doc/reference/datamodel.rst:2002 msgid "Emulating callable objects" -msgstr "" +msgstr "Émulation d'objets appelables" #: ../Doc/reference/datamodel.rst:2009 msgid "" @@ -2360,10 +3502,13 @@ msgid "" "defined, ``x(arg1, arg2, ...)`` is a shorthand for ``x.__call__(arg1, " "arg2, ...)``." msgstr "" +"Appelée quand l'instance est \"appelée\" en tant que fonction ; si la " +"méthode est définie, ``x(arg1, arg2, ...)`` est un raccourci pour ``x." +"__call__(arg1, arg2, ...)``." #: ../Doc/reference/datamodel.rst:2016 msgid "Emulating container types" -msgstr "" +msgstr "Émulation de types conteneurs" #: ../Doc/reference/datamodel.rst:2018 msgid "" @@ -2397,6 +3542,40 @@ msgid "" "`__iter__` should be the same as :meth:`keys`; for sequences, it should " "iterate through the values." msgstr "" +"Les fonctions suivantes peuvent être définies pour implémenter des objets " +"conteneurs. Les conteneurs sont habituellement des séquences (telles que les " +"tuples ou les listes) ou des tableaux de correspondances (comme les " +"dictionnaires), mais ils peuvent aussi représenter d'autres conteneurs. Le " +"premier ensemble de méthodes est utilisé soit pour émuler une séquence, soit " +"pour émuler un tableau de correspondances ; la différence est que, pour une " +"séquence, les clés doivent être soit des entiers *k* tels que ``0 <= k < N`` " +"où *N* est la longueur de la séquence, soit des objets tranches qui " +"définissent un intervalle d'éléments. Il est aussi recommandé que les " +"tableaux de correspondances fournissent les méthodes :meth:`keys`, :meth:" +"`values`, :meth:`items`, :meth:`get`, :meth:`clear`, :meth:`setdefault`, :" +"meth:`pop`, :meth:`popitem`, :meth:`!copy` et :meth:`update` avec un " +"comportement similaire aux objets dictionnaires standards de Python. Le " +"module :mod:`collections` fournit une classe de base abstraite :class:" +"`~collections.abc.MutableMapping` pour aider à la création de ces méthodes à " +"partir d'un ensemble de base composé de :meth:`__getitem__`, :meth:" +"`__setitem__`, :meth:`__delitem__` et :meth:`keys`. Les séquences muables " +"doivent fournir les méthodes :meth:`append`, :meth:`count`, :meth:`index`, :" +"meth:`extend`, :meth:`insert`, :meth:`pop`, :meth:`remove`, :meth:`reverse` " +"et :meth:`sort`, comme les objets listes standards de Python. Enfin, les " +"types séquences doivent implémenter l'addition (dans le sens de la " +"concaténation) et la multiplication (dans le sens de la répétition) en " +"définissant les méthodes :meth:`__add__`, :meth:`__radd__`, :meth:" +"`__iadd__`, :meth:`__mul__`, :meth:`__rmul__` et :meth:`__imul__` décrites " +"ci-dessous ; ils ne doivent pas définir d'autres opérateurs numériques. Il " +"est recommandé que les tableaux de correspondances et les séquences " +"implémentent la méthode :meth:`__contains__` pour permettre l'utilisation " +"efficace de l'opérateur ``in`` ; concernant les tableaux de correspondances, " +"``in`` doit rechercher dans les clés du tableau ; pour les séquences, il " +"doit chercher dans les valeurs. Il est de plus recommandé que les tableaux " +"de correspondances et les séquences implémentent la méthode :meth:`__iter__` " +"pour permettre une itération efficace dans le conteneur ; pour les tableaux " +"de correspondances, :meth:`__iter__` doit être la même que :meth:`keys` ; " +"pour les séquences, elle doit itérer sur les valeurs." #: ../Doc/reference/datamodel.rst:2053 msgid "" @@ -2405,6 +3584,10 @@ msgid "" "define a :meth:`__bool__` method and whose :meth:`__len__` method returns " "zero is considered to be false in a Boolean context." msgstr "" +"Appelée pour implémenter la fonction native :func:`len`. Elle doit renvoyer " +"la longueur de l'objet, un entier ``>=`` 0. Par ailleurs, un objet qui ne " +"définit pas de méthode :meth:`__bool__` et dont la méthode :meth:`__len__` " +"renvoie zéro est considéré comme valant ``False`` dans un contexte booléen." #: ../Doc/reference/datamodel.rst:2060 msgid "" @@ -2414,6 +3597,11 @@ msgid "" "OverflowError` by truth value testing, an object must define a :meth:" "`__bool__` method." msgstr "" +"En CPython, la longueur doit valoir au maximum :attr:`sys.maxsize`. Si la " +"longueur est plus grande que :attr:`!sys.maxsize`, des propriétés (telles " +"que :func:`len`) peuvent lever :exc:`OverflowError`. Afin d'éviter de lever :" +"exc:`!OverflowError` lors de tests booléens, un objet doit définir la " +"méthode :meth:`__bool__`." #: ../Doc/reference/datamodel.rst:2069 msgid "" @@ -2422,19 +3610,26 @@ msgid "" "The length must be an integer ``>=`` 0. This method is purely an " "optimization and is never required for correctness." msgstr "" +"Appelée pour implémenter :func:`operator.length_hint`. Elle doit renvoyer " +"une longueur estimée de l'objet (qui peut être plus grande ou plus petite " +"que la longueur réelle). La longueur doit être un entier ``>=`` 0. Cette " +"méthode est utilisée uniquement pour optimiser les traitements et n'est " +"jamais tenue de renvoyer un résultat exact." #: ../Doc/reference/datamodel.rst:2079 msgid "" "Slicing is done exclusively with the following three methods. A call like ::" msgstr "" +"Le découpage est effectué uniquement à l'aide des trois méthodes suivantes. " +"Un appel comme ::" #: ../Doc/reference/datamodel.rst:2083 msgid "is translated to ::" -msgstr "" +msgstr "est traduit en ::" #: ../Doc/reference/datamodel.rst:2087 msgid "and so forth. Missing slice items are always filled in with ``None``." -msgstr "" +msgstr "et ainsi de suite. Les éléments manquants sont remplacés par ``None``." #: ../Doc/reference/datamodel.rst:2094 msgid "" @@ -2447,18 +3642,32 @@ msgid "" "negative values), :exc:`IndexError` should be raised. For mapping types, if " "*key* is missing (not in the container), :exc:`KeyError` should be raised." msgstr "" +"Appelée pour implémenter l'évaluation de ``self[key]``. Pour les types " +"séquences, les clés autorisées sont les entiers et les objets tranches " +"(*slice*). Notez que l'interprétation spéciale des indices négatifs (si la " +"classe souhaite émuler un type séquence) est du ressort de la méthode :meth:" +"`__getitem__`. Si *key* n'est pas du bon type, une :exc:`TypeError` peut " +"être levée ; si la valeur est en dehors de l'ensemble des indices de la " +"séquence (après interprétation éventuelle des valeurs négatives), une :exc:" +"`IndexError` doit être levée. Pour les tableaux de correspondances, si *key* " +"n'existe pas dans le conteneur, une :exc:`KeyError` doit être levée." #: ../Doc/reference/datamodel.rst:2105 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 "" +":keyword:`for` s'attend à ce qu'une :exc:`IndexError` soit levée en cas " +"d'indice illégal afin de détecter correctement la fin de la séquence." #: ../Doc/reference/datamodel.rst:2111 msgid "" "Called by :class:`dict`\\ .\\ :meth:`__getitem__` to implement ``self[key]`` " "for dict subclasses when key is not in the dictionary." msgstr "" +"Appelée par :class:`dict`\\ .\\ :meth:`__getitem__` pour implémenter " +"``self[key]`` dans les sous-classes de dictionnaires lorsque la clé n'est " +"pas dans le dictionnaire." #: ../Doc/reference/datamodel.rst:2117 msgid "" @@ -2468,6 +3677,13 @@ msgid "" "sequences if elements can be replaced. The same exceptions should be raised " "for improper *key* values as for the :meth:`__getitem__` method." msgstr "" +"Appelée pour implémenter l'assignation à ``self[key]``. La même note que " +"pour :meth:`__getitem__` s'applique. Elle ne doit être implémentée que pour " +"les tableaux de correspondances qui autorisent les modifications de valeurs " +"des clés, ceux pour lesquels on peut ajouter de nouvelles clés ou, pour les " +"séquences, celles dont les éléments peuvent être remplacés. Les mêmes " +"exceptions que pour la méthode :meth:`__getitem__` doivent être levées en " +"cas de mauvaises valeurs de clés." #: ../Doc/reference/datamodel.rst:2126 msgid "" @@ -2477,6 +3693,12 @@ msgid "" "the sequence. The same exceptions should be raised for improper *key* " "values as for the :meth:`__getitem__` method." msgstr "" +"Appelée pour implémenter la suppression de ``self[key]``. La même note que " +"pour :meth:`__getitem__` s'applique. Elle ne doit être implémentée que pour " +"les tableaux de correspondances qui autorisent les suppression de clés ou " +"pour les séquences dont les éléments peuvent être supprimés de la séquence. " +"Les mêmes exceptions que pour la méthode :meth:`__getitem__` doivent être " +"levées en cas de mauvaises valeurs de clés." #: ../Doc/reference/datamodel.rst:2135 msgid "" @@ -2485,6 +3707,10 @@ msgid "" "objects in the container. For mappings, it should iterate over the keys of " "the container." msgstr "" +"Cette méthode est appelée quand un itérateur est requis pour un conteneur. " +"Cette méthode doit renvoyer un nouvel objet itérateur qui peut itérer sur " +"tous les objets du conteneur. Pour les tableaux de correspondances, elle " +"doit itérer sur les clés du conteneur." #: ../Doc/reference/datamodel.rst:2139 msgid "" @@ -2492,6 +3718,9 @@ msgid "" "return themselves. For more information on iterator objects, see :ref:" "`typeiter`." msgstr "" +"Les objets itérateurs doivent aussi implémenter cette méthode ; ils doivent " +"alors se renvoyer eux-mêmes. Pour plus d'information sur les objets " +"itérateurs, lisez :ref:`typeiter`." #: ../Doc/reference/datamodel.rst:2145 msgid "" @@ -2499,6 +3728,9 @@ msgid "" "iteration. It should return a new iterator object that iterates over all " "the objects in the container in reverse order." msgstr "" +"Appelée (si elle existe) par la fonction native :func:`reversed` pour " +"implémenter l'itération en sens inverse. Elle doit renvoyer un nouvel objet " +"itérateur qui itère sur tous les objets du conteneur en sens inverse." #: ../Doc/reference/datamodel.rst:2149 msgid "" @@ -2508,6 +3740,11 @@ msgid "" "provide :meth:`__reversed__` if they can provide an implementation that is " "more efficient than the one provided by :func:`reversed`." msgstr "" +"Si la méthode :meth:`__reversed__` n'est pas fournie, la fonction native :" +"func:`reversed` se replie sur le protocole de séquence (:meth:`__len__` and :" +"meth:`__getitem__`). Les objets qui connaissent le protocole de séquence ne " +"doivent fournir :meth:`__reversed__` que si l'implémentation qu'ils " +"proposent est plus efficace que celle de :func:`reversed`." #: ../Doc/reference/datamodel.rst:2156 msgid "" @@ -2516,6 +3753,11 @@ msgid "" "objects can supply the following special method with a more efficient " "implementation, which also does not require the object be a sequence." msgstr "" +"Les opérateurs de tests d'appartenance (:keyword:`in` and :keyword:`not in`) " +"sont normalement implémentés comme des itérations sur la séquence. " +"Cependant, les objets conteneurs peuvent fournir les méthodes spéciales " +"suivantes avec une implémentation plus efficace, qui ne requièrent " +"d'ailleurs pas que l'objet soit une séquence. " #: ../Doc/reference/datamodel.rst:2163 msgid "" @@ -2523,6 +3765,10 @@ msgid "" "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 "" +"Appelée pour implémenter les opérateurs de test d'appartenance. Elle doit " +"renvoyer ``True`` si *item* est dans *self* et ``False`` sinon. Pour les " +"tableaux de correspondances, seules les clés sont considérées (pas les " +"valeurs des paires clés-valeurs)." #: ../Doc/reference/datamodel.rst:2167 msgid "" @@ -2531,10 +3777,15 @@ msgid "" "protocol via :meth:`__getitem__`, see :ref:`this section in the language " "reference `." msgstr "" +"Pour les objets qui ne définissent pas :meth:`__contains__`, les tests " +"d'appartenance essaient d'abord d'itérer avec :meth:`__iter__` puis avec le " +"vieux protocole d'itération sur les séquences *via* :meth:`__getitem__`, " +"reportez-vous à :ref:`cette section dans la référence du langage `." #: ../Doc/reference/datamodel.rst:2176 msgid "Emulating numeric types" -msgstr "" +msgstr "Émulation de types numériques" #: ../Doc/reference/datamodel.rst:2178 msgid "" @@ -2543,6 +3794,11 @@ msgid "" "number implemented (e.g., bitwise operations for non-integral numbers) " "should be left undefined." msgstr "" +"Les méthodes suivantes peuvent être définies pour émuler des objets " +"numériques. Les méthodes correspondant à des opérations qui ne sont pas " +"autorisées pour la catégorie de nombres considérée (par exemple, les " +"opérations bit à bit pour les nombres qui ne sont pas entiers) doivent être " +"laissées indéfinies." #: ../Doc/reference/datamodel.rst:2204 msgid "" @@ -2556,12 +3812,24 @@ msgid "" "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 "" +"Ces méthodes sont appelées pour implémenter les opérations arithmétiques " +"binaires (``+``, ``-``, ``*``, ``@``, ``/``, ``//``, ``%``, :func:`divmod`, :" +"func:`pow`, ``**``, ``<<``, ``>>``, ``&``, ``^``, ``|``). Par exemple, pour " +"évaluer l'expression ``x + y``, où *x* est une instance d'une classe qui " +"possède une méthode :meth:`__add__`, ``x.__add__(y)`` est appelée. La " +"méthode :meth:`__divmod__` doit être l'équivalent d'appeler :meth:" +"`__floordiv__` et :meth:`__mod__`; elle ne doit pas être reliée à :meth:" +"`__truediv__`. Notez que :meth:`__pow__` doit être définie de manière à " +"accepter un troisième argument optionnel si la version ternaire de la " +"fonction native :func:`pow` est autorisée." #: ../Doc/reference/datamodel.rst:2215 msgid "" "If one of those methods does not support the operation with the supplied " "arguments, it should return ``NotImplemented``." msgstr "" +"Si l'une de ces méthodes n'autorise pas l'opération avec les arguments " +"donnés, elle doit renvoyer ``NotImplemented``." #: ../Doc/reference/datamodel.rst:2238 msgid "" @@ -2574,12 +3842,23 @@ msgid "" "an instance of a class that has an :meth:`__rsub__` method, ``y." "__rsub__(x)`` is called if ``x.__sub__(y)`` returns *NotImplemented*." msgstr "" +"Ces méthodes sont appelées pour implémenter les opérations arithmétiques " +"binaires (``+``, ``-``, ``*``, ``@``, ``/``, ``//``, ``%``, :func:`divmod`, :" +"func:`pow`, ``**``, ``<<``, ``>>``, ``&``, ``^``, ``|``) avec des opérandes " +"renversés (intervertis). Ces fonctions ne sont appelées que si l'opérande de " +"gauche n'autorise pas l'opération correspondante [#]_ et si les opérandes " +"sont de types différents [#]_. Par exemple, pour évaluer l'expression ``x - " +"y``, où *y* est une instance d'une classe qui possède une méthode :meth:" +"`__rsub__`, ``y.__rsub__(x)`` est appelée si ``x.__sub__(y)`` renvoie " +"*NotImplemented*." #: ../Doc/reference/datamodel.rst:2249 msgid "" "Note that ternary :func:`pow` will not try calling :meth:`__rpow__` (the " "coercion rules would become too complicated)." msgstr "" +"Notez que la fonction ternaire :func:`pow` n'essaie pas d'appeler :meth:" +"`__rpow__` (les règles de coercition seraient trop compliquées)." #: ../Doc/reference/datamodel.rst:2254 msgid "" @@ -2588,6 +3867,11 @@ msgid "" "will be called before the left operand's non-reflected method. This " "behavior allows subclasses to override their ancestors' operations." msgstr "" +"Si le type de l'opérande de droite est une sous-classe du type de l'opérande " +"de gauche et que cette sous-classe fournit la méthode symétrique pour " +"l'opération, cette méthode sera appelée avant la méthode originelle de " +"l'opérande gauche. Ce comportement permet à des sous-classes de surcharger " +"les opérations de leurs ancêtres." #: ../Doc/reference/datamodel.rst:2274 msgid "" @@ -2604,18 +3888,35 @@ msgid "" "(see :ref:`faq-augmented-assignment-tuple-error`), but this behavior is in " "fact part of the data model." msgstr "" +"Ces méthodes sont appelées pour implémenter les assignations arithmétiques " +"augmentées (``+=``, ``-=``, ``*=``, ``@=``, ``/=``, ``//=``, ``%=``, " +"``**=``, ``<<=``, ``>>=``, ``&=``, ``^=``, ``|=``). Ces méthodes doivent " +"essayer d'effectuer l'opération \"sur place\" (c'est-à-dire de modifier " +"*self*) et de renvoyer le résultat (qui peut être, mais pas nécessairement, " +"*self*). Si une méthode spécifique n'est pas définie, l'assignation " +"augmentée se replie vers la méthode normale correspondante. Par exemple, si " +"*x* est une instance d'une classe qui possède une méthode :meth:`__iadd__`, " +"``x += y`` est équivalent à ``x = x.__iadd__(y)`` . Sinon, ``x.__add__(y)`` " +"et ``y.__radd__(x)`` sont essayées, comme pour l'évaluation de ``x + y``. " +"Dans certaines situations, les assignations augmentées peuvent causer des " +"erreurs inattendues (voir :ref:`faq-augmented-assignment-tuple-error`), mais " +"ce comportement est en fait partie intégrante du modèle de données." #: ../Doc/reference/datamodel.rst:2295 msgid "" "Called to implement the unary arithmetic operations (``-``, ``+``, :func:" "`abs` and ``~``)." msgstr "" +"Appelée pour implémenter les opérations arithmétiques unaires (``-``, ``" +"+``, :func:`abs` and ``~``)." #: ../Doc/reference/datamodel.rst:2308 msgid "" "Called to implement the built-in functions :func:`complex`, :func:`int` and :" "func:`float`. Should return a value of the appropriate type." msgstr "" +"Appelées pour implémenter les fonctions natives :func:`complex`, :func:`int` " +"et :func:`float`. Elles doivent renvoyer une valeur du type approprié." #: ../Doc/reference/datamodel.rst:2315 msgid "" @@ -2625,6 +3926,11 @@ msgid "" "functions). Presence of this method indicates that the numeric object is an " "integer type. Must return an integer." msgstr "" +"Appelée pour implémenter :func:`operator.index` et lorsque Python a besoin " +"de convertir sans perte un objet numérique en objet entier (pour un " +"découpage ou dans les fonctions natives :func:`bin`, :func:`hex` et :func:" +"`oct`). La présence de cette méthode indique que l'objet numérique est un " +"type entier. Elle doit renvoyer un entier." #: ../Doc/reference/datamodel.rst:2323 msgid "" @@ -2632,6 +3938,9 @@ msgid "" "defined :meth:`__int__` should also be defined, and both should return the " "same value." msgstr "" +"Afin d'avoir un type de classe entier cohérent, lorsque :meth:`__index__` " +"est définie alors :meth:`__int__` doit aussi être définie et les deux " +"doivent renvoyer la même valeur." #: ../Doc/reference/datamodel.rst:2335 msgid "" @@ -2641,16 +3950,23 @@ msgid "" "return the value of the object truncated to an :class:`~numbers.Integral` " "(typically an :class:`int`)." msgstr "" +"Appelée pour implémenter la fonction native :func:`round` et les fonctions " +"du module :mod:`math` :func:`~math.trunc`, :func:`~math.floor` et :func:" +"`~math.ceil`. À moins que *ndigits* ne soit passé à :meth:`!__round__`, " +"toutes ces méthodes doivent renvoyer la valeur de l'objet tronquée pour " +"donner un :class:`~numbers.Integral` (typiquement un :class:`int`)." #: ../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 "" +"Si :meth:`__int__` n'est pas définie, alors la fonction native :func:`int` " +"se replie sur :meth:`__trunc__`." #: ../Doc/reference/datamodel.rst:2348 msgid "With Statement Context Managers" -msgstr "" +msgstr "Gestionnaire de contexte With" #: ../Doc/reference/datamodel.rst:2350 msgid "" @@ -2661,17 +3977,29 @@ msgid "" "using the :keyword:`with` statement (described in section :ref:`with`), but " "can also be used by directly invoking their methods." msgstr "" +"Un :dfn:`gestionnaire de contexte` est un objet qui met en place un contexte " +"prédéfini au moment de l'exécution de l'instruction :keyword:`with`. Le " +"gestionnaire de contexte gère l'entrée et la sortie de ce contexte " +"d'exécution pour tout un bloc de code. Les gestionnaires de contextes sont " +"normalement invoqués en utilisant une instruction :keyword:`with` (décrite " +"dans la section :ref:`with`), mais ils peuvent aussi être directement " +"invoqués par leurs méthodes." #: ../Doc/reference/datamodel.rst:2361 msgid "" "Typical uses of context managers include saving and restoring various kinds " "of global state, locking and unlocking resources, closing opened files, etc." msgstr "" +"Les utilisations classiques des gestionnaires de contexte sont la sauvegarde " +"et la restauration d'états divers, le verrouillage et le déverrouillage de " +"ressources, la fermeture de fichiers ouverts, etc." #: ../Doc/reference/datamodel.rst:2364 msgid "" "For more information on context managers, see :ref:`typecontextmanager`." msgstr "" +"Pour plus d'informations sur les gestionnaires de contexte, lisez :ref:" +"`typecontextmanager`." #: ../Doc/reference/datamodel.rst:2369 msgid "" @@ -2679,6 +4007,10 @@ msgid "" "statement will bind this method's return value to the target(s) specified in " "the :keyword:`as` clause of the statement, if any." msgstr "" +"Entre dans le contexte d'exécution relatif à cet objet. L'instruction :" +"keyword:`with` lie la valeur de retour de cette méthode à une (ou plusieurs) " +"cible spécifiée par la clause :keyword:`as` de l'instruction, si elle est " +"spécifiée." #: ../Doc/reference/datamodel.rst:2376 msgid "" @@ -2686,6 +4018,9 @@ msgid "" "exception that caused the context to be exited. If the context was exited " "without an exception, all three arguments will be :const:`None`." msgstr "" +"Sort du contexte d'exécution relatif à cet objet. Les paramètres décrivent " +"l'exception qui a causé la sortie du contexte. Si l'on sort du contexte sans " +"exception, les trois arguments sont à :const:`None`." #: ../Doc/reference/datamodel.rst:2380 msgid "" @@ -2694,26 +4029,34 @@ msgid "" "Otherwise, the exception will be processed normally upon exit from this " "method." msgstr "" +"Si une exception est indiquée et que la méthode souhaite supprimer " +"l'exception (c'est-à-dire qu'elle ne veut pas que l'exception soit " +"propagée), elle doit renvoyer ``True``. Sinon, l'exception est traitée " +"normalement à la sortie de cette méthode." #: ../Doc/reference/datamodel.rst:2384 msgid "" "Note that :meth:`__exit__` methods should not reraise the passed-in " "exception; this is the caller's responsibility." msgstr "" +"Notez qu'une méthode :meth:`__exit__` ne doit pas lever à nouveau " +"l'exception qu'elle reçoit ; c'est du ressort de l'appelant." #: ../Doc/reference/datamodel.rst:2391 msgid ":pep:`343` - The \"with\" statement" -msgstr ":pep:`343` - The \"with\" statement" +msgstr ":pep:`343` - L'instruction \"with\"" #: ../Doc/reference/datamodel.rst:2391 msgid "" "The specification, background, and examples for the Python :keyword:`with` " "statement." msgstr "" +"La spécification, les motivations et des exemples de l'instruction :keyword:" +"`with` en Python." #: ../Doc/reference/datamodel.rst:2398 msgid "Special method lookup" -msgstr "" +msgstr "Recherche des méthodes spéciales" #: ../Doc/reference/datamodel.rst:2400 msgid "" @@ -2722,6 +4065,10 @@ msgid "" "object's instance dictionary. That behaviour is the reason why the " "following code raises an exception::" msgstr "" +"Pour les classes définies par le développeur, l'invocation implicite de " +"méthodes spéciales n'est garantie que si ces méthodes sont définies par le " +"type d'objet, pas dans le dictionnaire de l'objet instance. Ce comportement " +"explique pourquoi le code suivant lève une exception ::" #: ../Doc/reference/datamodel.rst:2415 msgid "" @@ -2731,6 +4078,11 @@ msgid "" "used the conventional lookup process, they would fail when invoked on the " "type object itself::" msgstr "" +"La raison de ce comportement vient de certaines méthodes spéciales telles " +"que :meth:`__hash__` et :meth:`__repr__` qui sont implémentées par tous les " +"objets, y compris les objets types. Si la recherche effectuée par ces " +"méthodes utilisait le processus normal de recherche, elles ne " +"fonctionneraient pas si on les appelait sur l'objet type lui-même ::" #: ../Doc/reference/datamodel.rst:2428 msgid "" @@ -2738,6 +4090,9 @@ msgid "" "sometimes referred to as 'metaclass confusion', and is avoided by bypassing " "the instance when looking up special methods::" msgstr "" +"Essayer d'invoquer une méthode non liée d'une classe de cette manière est " +"parfois appelé \"confusion de méta-classe\" et se contourne en shuntant " +"l'instance lors de la recherche des méthodes spéciales ::" #: ../Doc/reference/datamodel.rst:2437 msgid "" @@ -2745,6 +4100,9 @@ msgid "" "correctness, implicit special method lookup generally also bypasses the :" "meth:`__getattribute__` method even of the object's metaclass::" msgstr "" +"En plus de shunter les attributs des instances pour fonctionner " +"correctement, la recherche des méthodes spéciales implicites shunte aussi la " +"méthode :meth:`__getattribute__` même dans la méta-classe de l'objet ::" #: ../Doc/reference/datamodel.rst:2463 msgid "" @@ -2754,6 +4112,11 @@ msgid "" "method *must* be set on the class object itself in order to be consistently " "invoked by the interpreter)." msgstr "" +"En shuntant le mécanisme de :meth:`__getattribute__` de cette façon, cela " +"permet d'optimiser la vitesse de l'interpréteur moyennant une certaine " +"manœuvre dans la gestion des méthodes spéciales (la méthode spéciale *doit* " +"être définie sur l'objet classe lui-même afin d'être invoquée de manière " +"cohérente par l'interpréteur)." #: ../Doc/reference/datamodel.rst:2474 msgid "Coroutines" @@ -2761,7 +4124,7 @@ msgstr "Coroutines" #: ../Doc/reference/datamodel.rst:2478 msgid "Awaitable Objects" -msgstr "" +msgstr "Objets awaitables" #: ../Doc/reference/datamodel.rst:2480 msgid "" @@ -2769,6 +4132,9 @@ msgid "" "method. :term:`Coroutine` objects returned from :keyword:`async def` " "functions are awaitable." msgstr "" +"Un objet :term:`awaitable` implémente généralement une méthode :meth:" +"`__await__`. Les objets :term:`Coroutine` renvoyés par les fonctions :" +"keyword:`async def` sont des awaitables." #: ../Doc/reference/datamodel.rst:2486 msgid "" @@ -2776,6 +4142,9 @@ msgid "" "with :func:`types.coroutine` or :func:`asyncio.coroutine` are also " "awaitable, but they do not implement :meth:`__await__`." msgstr "" +"Les objets :term:`itérateur de générateur` renvoyés par les générateurs " +"décorés par :func:`types.coroutine` ou :func:`asyncio.coroutine` sont aussi " +"des awaitables, mais ils n'implémentent pas :meth:`__await__`." #: ../Doc/reference/datamodel.rst:2492 msgid "" @@ -2783,10 +4152,13 @@ msgid "" "`awaitable` objects. For instance, :class:`asyncio.Future` implements this " "method to be compatible with the :keyword:`await` expression." msgstr "" +"Doit renvoyer un :term:`itérateur`. Doit être utilisé pour implémenter les " +"objets :term:`awaitable`. Par exemple, :class:`asyncio.Future` implémente " +"cette méthode pour être compatible avec les expressions :keyword:`await`." #: ../Doc/reference/datamodel.rst:2498 msgid ":pep:`492` for additional information about awaitable objects." -msgstr "" +msgstr ":pep:`492` pour les informations relatives aux objets awaitables." #: ../Doc/reference/datamodel.rst:2504 msgid "Coroutine Objects" @@ -2802,6 +4174,13 @@ msgid "" "raises an exception, it is propagated by the iterator. Coroutines should " "not directly raise unhandled :exc:`StopIteration` exceptions." msgstr "" +"Les objets :term:`Coroutine` sont des objets :term:`awaitable`. L'exécution " +"d'une coroutine peut être contrôlée en appelant :meth:`__await__` et en " +"itérant sur le résultat. Quand la coroutine a fini de s'exécuter et termine, " +"l'itérateur lève :exc:`StopIteration` et l'attribut :attr:`~StopIteration." +"value` de l'exception contient la valeur de retour. Si la coroutine lève une " +"exception, elle est propagée par l'itérateur. Les coroutines ne doivent pas " +"lever directement des exceptions :exc:`StopIteration` non gérées." #: ../Doc/reference/datamodel.rst:2514 msgid "" @@ -2809,10 +4188,16 @@ msgid "" "of generators (see :ref:`generator-methods`). However, unlike generators, " "coroutines do not directly support iteration." msgstr "" +"Les coroutines disposent aussi des méthodes listées ci-dessous, analogues à " +"celles des générateurs (voir :ref:`generator-methods`). Cependant, au " +"contraire des générateurs, vous ne pouvez pas itérer directement sur des " +"coroutines." #: ../Doc/reference/datamodel.rst:2518 msgid "It is a :exc:`RuntimeError` to await on a coroutine more than once." msgstr "" +"Utiliser *await* plus d'une fois sur une coroutine lève une :exc:" +"`RuntimeError`." #: ../Doc/reference/datamodel.rst:2524 msgid "" @@ -2823,6 +4208,13 @@ msgid "" "result (return value, :exc:`StopIteration`, or other exception) is the same " "as when iterating over the :meth:`__await__` return value, described above." msgstr "" +"Démarre ou reprend l'exécution d'une coroutine. Si *value* est ``None``, " +"c'est équivalent à avancer l'itérateur renvoyé par :meth:`__await__`. Si " +"*value* ne vaut pas ``None``, cette méthode appelle la méthode :meth:" +"`~generator.send` de l'itérateur qui a causé la suspension de la coroutine. " +"Le résultat (valeur de retour, :exc:`StopIteration` ou une autre exception) " +"est le même que lorsque vous itérez sur la valeur de retour de :meth:" +"`__await__`, décrite ci-dessus." #: ../Doc/reference/datamodel.rst:2534 msgid "" @@ -2834,6 +4226,13 @@ msgid "" "meth:`__await__` return value, described above. If the exception is not " "caught in the coroutine, it propagates back to the caller." msgstr "" +"Lève l'exception spécifiée dans la coroutine. Cette méthode délègue à la " +"méthode :meth:`~generator.throw` de l'itérateur qui a causé la suspension de " +"la coroutine, s'il possède une telle méthode. Sinon, l'exception est levée " +"au point de suspension. Le résultat (valeur de retour, :exc:`StopIteration` " +"ou une autre exception) est le même que lorsque vous itérez sur la valeur de " +"retour de :meth:`__await__`, décrite ci-dessus. Si l'exception n'est pas " +"gérée par la coroutine, elle est propagée à l'appelant." #: ../Doc/reference/datamodel.rst:2545 msgid "" @@ -2844,16 +4243,25 @@ msgid "" "causing the coroutine to immediately clean itself up. Finally, the coroutine " "is marked as having finished executing, even if it was never started." msgstr "" +"Demande à la coroutine de faire le ménage et de se terminer. Si la coroutine " +"est suspendue, cette méthode délègue d'abord à la méthode :meth:`~generator." +"close` de l'itérateur qui a causé la suspension de la coroutine, s'il " +"possède une telle méthode. Ensuite, elle lève :exc:`GeneratorExit` au point " +"de suspension, ce qui fait le ménage dans la coroutine immédiatement. Enfin, " +"la coroutine est marquée comme ayant terminé son exécution, même si elle n'a " +"jamais démarré." #: ../Doc/reference/datamodel.rst:2553 msgid "" "Coroutine objects are automatically closed using the above process when they " "are about to be destroyed." msgstr "" +"Les objets coroutines sont automatiquement fermés en utilisant le processus " +"décrit au-dessus au moment où ils sont détruits." #: ../Doc/reference/datamodel.rst:2559 msgid "Asynchronous Iterators" -msgstr "" +msgstr "Itérateurs asynchrones" #: ../Doc/reference/datamodel.rst:2561 msgid "" @@ -2861,25 +4269,33 @@ msgid "" "``__aiter__`` implementation, and an *asynchronous iterator* can call " "asynchronous code in its ``__anext__`` method." msgstr "" +"Un itérateur asynchrone est capable d'appeler du code asynchrone dans " +"l'implémentation de son ``__aiter__`` et peut appeler du code asynchrone " +"dans sa méthode ``__anext__``." #: ../Doc/reference/datamodel.rst:2565 msgid "" "Asynchronous iterators can be used in an :keyword:`async for` statement." msgstr "" +"Les itérateurs asynchrones peuvent être utilisés dans des instructions :" +"keyword:`async for`." #: ../Doc/reference/datamodel.rst:2569 msgid "Must return an *asynchronous iterator* object." -msgstr "" +msgstr "Doit renvoyer un objet *itérateur asynchrone*." #: ../Doc/reference/datamodel.rst:2573 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 "" +"Doit renvoyer un *awaitable* qui se traduit par la valeur suivante de " +"l'itérateur. Doit lever une :exc:`StopAsyncIteration` quand l'itération est " +"terminée." #: ../Doc/reference/datamodel.rst:2576 msgid "An example of an asynchronous iterable object::" -msgstr "" +msgstr "Un exemple d'objet itérateur asynchrone ::" #: ../Doc/reference/datamodel.rst:2595 msgid "" @@ -2887,6 +4303,9 @@ msgid "" "`asynchronous iterators `. Returning an :term:" "`awaitable` object will result in a :exc:`PendingDeprecationWarning`." msgstr "" +"À partir de CPython 3.5.2, ``__aiter__`` peut directement renvoyer des :term:" +"`itérateurs asynchrones `. Renvoyer un objet :term:" +"`awaitable` entraine un avertissement :exc:`PendingDeprecationWarning`." #: ../Doc/reference/datamodel.rst:2601 msgid "" @@ -2895,10 +4314,14 @@ msgid "" "the PendingDeprecationWarning and keep the code backwards compatible, the " "following decorator can be used::" msgstr "" +"La façon conseillée d'écrire du code compatible descendant en CPython 3.5.x " +"est de continuer à renvoyer des awaitables avec ``__aiter__``. Si vous " +"voulez éviter l'avertissement *PendingDeprecationWarning* et conserver un " +"code compatible descendant, le décorateur suivant peut être utilisé ::" #: ../Doc/reference/datamodel.rst:2620 msgid "Example::" -msgstr "Exemples ::" +msgstr "Exemple ::" #: ../Doc/reference/datamodel.rst:2631 msgid "" @@ -2906,38 +4329,50 @@ msgid "" "replaced with the :exc:`DeprecationWarning`. In CPython 3.7, returning an " "awaitable from ``__aiter__`` will result in a :exc:`RuntimeError`." msgstr "" +"À partir de CPython 3.6, le :exc:`PendingDeprecationWarning` est remplacé " +"par un :exc:`DeprecationWarning`. Dans CPython 3.7, renvoyer un awaitable " +"avec ``__aiter__`` entraine une :exc:`RuntimeError`." #: ../Doc/reference/datamodel.rst:2638 msgid "Asynchronous Context Managers" -msgstr "" +msgstr "Gestionnaires de contexte asynchrones" #: ../Doc/reference/datamodel.rst:2640 msgid "" "An *asynchronous context manager* is a *context manager* that is able to " "suspend execution in its ``__aenter__`` and ``__aexit__`` methods." msgstr "" +"Un *gestionnaire de contexte asynchrone* est un *gestionnaire de contexte* " +"qui est capable de suspendre son exécution dans ses méthodes ``__aenter__`` " +"et ``__aexit__``." #: ../Doc/reference/datamodel.rst:2643 msgid "" "Asynchronous context managers can be used in an :keyword:`async with` " "statement." msgstr "" +"Les gestionnaires de contexte asynchrones peuvent être utilisés dans des " +"instructions :keyword:`async with`." #: ../Doc/reference/datamodel.rst:2647 msgid "" "This method is semantically similar to the :meth:`__enter__`, with only " "difference that it must return an *awaitable*." msgstr "" +"Cette méthode est sémantiquement équivalente à :meth:`__enter__`, à la seule " +"différence près qu'elle doit renvoyer un *awaitable*." #: ../Doc/reference/datamodel.rst:2652 msgid "" "This method is semantically similar to the :meth:`__exit__`, with only " "difference that it must return an *awaitable*." msgstr "" +"Cette méthode est sémantiquement équivalente à :meth:`__exit__`, à la seule " +"différence près qu'elle doit renvoyer un *awaitable*." #: ../Doc/reference/datamodel.rst:2655 msgid "An example of an asynchronous context manager class::" -msgstr "" +msgstr "Un exemple de classe de gestionnaire de contexte asynchrone ::" #: ../Doc/reference/datamodel.rst:2668 msgid "Footnotes" @@ -2949,6 +4384,10 @@ msgid "" "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 "" +"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." #: ../Doc/reference/datamodel.rst:2673 msgid "" @@ -2957,6 +4396,10 @@ msgid "" "raise a :exc:`TypeError`, but may do so by relying on the behavior that " "``None`` is not callable." msgstr "" +"Les méthodes :meth:`__hash__`, :meth:`__iter__`, :meth:`__reversed__` et :" +"meth:`__contains__` ont une gestion particulière pour cela ; les autres " +"lèvent toujours :exc:`TypeError`, mais le font en considérant que ``None`` " +"n'est pas un appelable." #: ../Doc/reference/datamodel.rst:2678 msgid "" @@ -2965,6 +4408,10 @@ msgid "" "want to force fallback to the right operand's reflected method—that will " "instead have the opposite effect of explicitly *blocking* such fallback." msgstr "" +"*n'autorise pas* signifie ici que la classe ne possède pas de méthode " +"adéquate ou que la méthode renvoie ``NotImplemented``. N'assignez pas " +"``None`` à la méthode si vous voulez un repli vers la méthode symétrique de " +"l'opérande de droite -- cela aurait pour effet de *bloquer* un tel repli." #: ../Doc/reference/datamodel.rst:2684 msgid "" @@ -2972,3 +4419,6 @@ msgid "" "method (such as :meth:`__add__`) fails the operation is not supported, which " "is why the reflected method is not called." msgstr "" +"Pour des opérandes de même type, on considère que si la méthode originelle " +"(telle que :meth:`__add__`) échoue, l'opération n'est pas autorisée et donc " +"la méthode symétrique n'est pas appelée."