From 740eb9c40d3c04aa788e260787e885d19dc80b5f Mon Sep 17 00:00:00 2001 From: oboudou Date: Fri, 5 Oct 2018 17:53:13 +0200 Subject: [PATCH] 3.7 howto descriptor (#353) * descriptor * descriptor v2 * descriptor v2 * descriptor V4 * descriptor V5 * descriptor V5 --- howto/descriptor.po | 231 +++++++++++++++++++++++++++++++++++++++----- 1 file changed, 205 insertions(+), 26 deletions(-) diff --git a/howto/descriptor.po b/howto/descriptor.po index 2d45502d..685496d4 100644 --- a/howto/descriptor.po +++ b/howto/descriptor.po @@ -6,17 +6,18 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-09-15 21:52+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2018-10-05 17:31+0200\n" "Language-Team: FRENCH \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" +"X-Generator: Poedit 2.1.1\n" #: ../Doc/howto/descriptor.rst:3 msgid "Descriptor HowTo Guide" -msgstr "" +msgstr "Guide pour l'utilisation des descripteurs" #: ../Doc/howto/descriptor.rst:0 msgid "Author" @@ -24,15 +25,15 @@ msgstr "Auteur" #: ../Doc/howto/descriptor.rst:5 msgid "Raymond Hettinger" -msgstr "" +msgstr "Raymond Hettinger" #: ../Doc/howto/descriptor.rst:0 msgid "Contact" -msgstr "" +msgstr "Contact" #: ../Doc/howto/descriptor.rst:6 msgid "" -msgstr "" +msgstr "" #: ../Doc/howto/descriptor.rst:8 msgid "Contents" @@ -50,6 +51,11 @@ msgid "" "methods. Shows how each works by giving a pure Python equivalent and a " "sample application." msgstr "" +"Définit les descripteurs, résume le protocole et montre comment les " +"descripteurs sont appelés. Examine un descripteur personnalisé et plusieurs " +"descripteurs Python intégrés, y compris les fonctions, les propriétés, les " +"méthodes statiques et les méthodes de classe. Montre comment chacun " +"fonctionne en donnant un équivalent Python pur et un exemple d'application." #: ../Doc/howto/descriptor.rst:18 msgid "" @@ -57,10 +63,13 @@ msgid "" "creates a deeper understanding of how Python works and an appreciation for " "the elegance of its design." msgstr "" +"L'apprentissage des descripteurs permet non seulement d'accéder à un " +"ensemble d'outils plus vaste, mais aussi de mieux comprendre le " +"fonctionnement de Python et d'apprécier l'élégance de sa conception." #: ../Doc/howto/descriptor.rst:24 msgid "Definition and Introduction" -msgstr "" +msgstr "Définition et introduction" #: ../Doc/howto/descriptor.rst:26 msgid "" @@ -70,6 +79,11 @@ msgid "" "`__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 objet avec un \"comportement " +"contraignant\", dont l'accès à l'attribut a été remplacé par des méthodes " +"dans le protocole du descripteur. Ces méthodes sont : :meth:`__get__`, :" +"meth:`__set__`, et :meth:`__delete__`. Si l'une de ces méthodes est définie " +"pour un objet, il s'agit d'un descripteur." #: ../Doc/howto/descriptor.rst:32 msgid "" @@ -82,6 +96,15 @@ msgid "" "method instead. Where this occurs in the precedence chain depends on which " "descriptor methods were defined." msgstr "" +"Le comportement par défaut pour l'accès aux attributs consiste à obtenir, " +"définir ou supprimer l'attribut du dictionnaire d'un objet. Par exemple, " +"``a. x`` a une chaîne de recherche commençant par ``a. __dict__ ['x']``, " +"puis ``type (a). __dict__ ['x']``, et continuant à travers les classes de " +"base de ``type (a)`` À l'exclusion des sous-classes. Si la valeur recherchée " +"est un objet définissant l'une des méthodes de descripteur, Python peut " +"substituer le comportement par défaut et appeler à la place la méthode " +"Descriptor. Lorsque cela se produit dans la chaîne de précédence dépend de " +"quelles méthodes descripteur ont été définies." #: ../Doc/howto/descriptor.rst:41 msgid "" @@ -92,22 +115,29 @@ msgid "" "underlying C-code and offer a flexible set of new tools for everyday Python " "programs." msgstr "" +"Les descripteurs sont un protocole puissant et à usage général. Ils sont le " +"mécanisme derrière les propriétés, les méthodes, les méthodes statiques, les " +"méthodes de classes et :func:`super()`. Ils sont utilisés dans tout Python " +"lui-même pour implémenter les nouvelles classes de style introduites dans la " +"version 2.2. Les descripteurs simplifient le code C sous-jacent et offrent " +"un ensemble flexible de nouveaux outils pour les programmes Python " +"quotidiens." #: ../Doc/howto/descriptor.rst:49 msgid "Descriptor Protocol" -msgstr "" +msgstr "Protocole descripteur" #: ../Doc/howto/descriptor.rst:51 msgid "``descr.__get__(self, obj, type=None) -> value``" -msgstr "" +msgstr "``descr.__get__(self, obj, type=None) -> value``" #: ../Doc/howto/descriptor.rst:53 msgid "``descr.__set__(self, obj, value) -> None``" -msgstr "" +msgstr "``descr.__set__(self, obj, value) -> None``" #: ../Doc/howto/descriptor.rst:55 msgid "``descr.__delete__(self, obj) -> None``" -msgstr "" +msgstr "``descr.__delete__(self, obj) -> None``" #: ../Doc/howto/descriptor.rst:57 msgid "" @@ -115,6 +145,9 @@ msgid "" "considered a descriptor and can override default behavior upon being looked " "up as an attribute." msgstr "" +"C'est tout ce qu'il y a à faire. Définissez n'importe laquelle de ces " +"méthodes et un objet est considéré comme un descripteur et peut remplacer le " +"comportement par défaut lorsqu'il est recherché comme un attribut." #: ../Doc/howto/descriptor.rst:61 msgid "" @@ -123,6 +156,11 @@ msgid "" "are called non-data descriptors (they are typically used for methods but " "other uses are possible)." msgstr "" +"Si un objet définit à la fois :meth:`__get__` et :meth:`__set__`, il est " +"considéré comme un descripteur de données. Les descripteurs qui ne " +"définissent que :meth:`__get__` sont appelés descripteurs *non-data* (ils " +"sont généralement utilisés pour des méthodes mais d'autres utilisations sont " +"possibles)." #: ../Doc/howto/descriptor.rst:66 msgid "" @@ -132,6 +170,13 @@ msgid "" "takes precedence. If an instance's dictionary has an entry with the same " "name as a non-data descriptor, the dictionary entry takes precedence." msgstr "" +"Les descripteurs de données et les descripteurs *non-data* diffèrent dans la " +"façon dont les dérogations sont calculées en ce qui concerne les entrées du " +"dictionnaire d'une instance. Si le dictionnaire d'une instance comporte une " +"entrée portant le même nom qu'un descripteur de données, le descripteur de " +"données est prioritaire. Si le dictionnaire d'une instance comporte une " +"entrée portant le même nom qu'un descripteur *non-data*, l'entrée du " +"dictionnaire a la priorité." #: ../Doc/howto/descriptor.rst:72 msgid "" @@ -140,6 +185,11 @@ msgid "" "called. Defining the :meth:`__set__` method with an exception raising " "placeholder is enough to make it a data descriptor." msgstr "" +"Pour faire un descripteur de données en lecture seule, définissez à la fois :" +"meth:`__get__` et :meth:`__set__` avec :meth:`__set__` levant une erreur :" +"exc:`AttributeError` quand il est appelé. Définir la méthode :meth:" +"`__set__set__` avec une exception élevant le caractère générique est " +"suffisant pour en faire un descripteur de données." #: ../Doc/howto/descriptor.rst:79 msgid "Invoking Descriptors" @@ -150,6 +200,8 @@ msgid "" "A descriptor can be called directly by its method name. For example, ``d." "__get__(obj)``." msgstr "" +"Un descripteur peut être appelé directement par son nom de méthode. Par " +"exemple, ``d.__get__(obj)``." #: ../Doc/howto/descriptor.rst:84 msgid "" @@ -159,11 +211,18 @@ msgid "" "then ``d.__get__(obj)`` is invoked according to the precedence rules listed " "below." msgstr "" +"Alternativement, il est plus courant qu'un descripteur soit invoqué " +"automatiquement lors de l'accès aux attributs. Par exemple, ``obj.d`` " +"recherche ``d`` dans le dictionnaire de ``obj.d``. Si ``d`` définit la " +"méthode :meth:`__get__`, alors ``d.__get__(obj)`` est invoqué selon les " +"règles de priorité énumérées ci-dessous." #: ../Doc/howto/descriptor.rst:89 msgid "" "The details of invocation depend on whether ``obj`` is an object or a class." msgstr "" +"Les détails de l'invocation dépendent du fait que ``obj`` est un objet ou " +"une classe." #: ../Doc/howto/descriptor.rst:91 msgid "" @@ -175,6 +234,14 @@ msgid "" "The full C implementation can be found in :c:func:" "`PyObject_GenericGetAttr()` in :source:`Objects/object.c`." msgstr "" +"Pour les objets, la machinerie est en :meth:`object.__getattribute__` qui " +"transforme ``b.x`` en ``type(b).__dict__['x'].__get__(b, type(b)]``. " +"L'implémentation fonctionne à travers une chaîne de priorité qui donne la " +"priorité aux descripteurs de données sur les variables d'instance, la " +"priorité aux variables d'instance sur les descripteurs *non-data*, et " +"attribue la priorité la plus faible à :meth:`__getattr__` si fourni. " +"L'implémentation complète de C peut être trouvée dans :c:func:" +"`PyObject_GenericGetAttr()` dans :source:`Objects/object.c`." #: ../Doc/howto/descriptor.rst:99 msgid "" @@ -182,32 +249,43 @@ msgid "" "transforms ``B.x`` into ``B.__dict__['x'].__get__(None, B)``. In pure " "Python, it looks like::" msgstr "" +"Pour les classes, la machinerie est dans :meth:`type.__getattribute__` qui " +"transforme ``B.x`` en ``B.__dict__['x'].__get__(None, B)``. En Python pur, " +"il ressemble à : ::" #: ../Doc/howto/descriptor.rst:110 msgid "The important points to remember are:" -msgstr "" +msgstr "Les points importants à retenir sont :" #: ../Doc/howto/descriptor.rst:112 msgid "descriptors are invoked by the :meth:`__getattribute__` method" -msgstr "" +msgstr "les descripteurs sont appelés par la méthode :meth:`__getattribute__`" #: ../Doc/howto/descriptor.rst:113 msgid "overriding :meth:`__getattribute__` prevents automatic descriptor calls" msgstr "" +"redéfinition :meth:`__getattribute____` empêche les appels automatiques de " +"descripteurs" #: ../Doc/howto/descriptor.rst:114 msgid "" ":meth:`object.__getattribute__` and :meth:`type.__getattribute__` make " "different calls to :meth:`__get__`." msgstr "" +":meth:`objet.__getattribute__` et :meth:`type.__getattribute__` font " +"différents appels à :meth:`__get__`." #: ../Doc/howto/descriptor.rst:116 msgid "data descriptors always override instance dictionaries." msgstr "" +"les descripteurs de données remplacent toujours les dictionnaires " +"d'instances." #: ../Doc/howto/descriptor.rst:117 msgid "non-data descriptors may be overridden by instance dictionaries." msgstr "" +"les descripteurs *non-data* peuvent être remplacés par des dictionnaires " +"d'instance." #: ../Doc/howto/descriptor.rst:119 msgid "" @@ -218,6 +296,13 @@ msgid "" "B)``. If not a descriptor, ``m`` is returned unchanged. If not in the " "dictionary, ``m`` reverts to a search using :meth:`object.__getattribute__`." msgstr "" +"L'objet retourné par ``super()`` a aussi une méthode personnalisée :meth:" +"`__getattribute__` pour appeler les descripteurs. L'appel ``super(B, obj)." +"m()`` recherche ``obj.__class__.__mro__`` pour la classe de base ``A`` " +"immédiatement après ``B`` et renvoie ensuite ``A.__dict__['m'].__get__(obj, " +"B)``. Si ce n'est pas un descripteur, ``m`` est retourné inchangé. Si ce " +"n'est pas dans le dictionnaire, ``m`` renvoie à une recherche avec :meth:" +"`object.__getattribute__`." #: ../Doc/howto/descriptor.rst:126 msgid "" @@ -225,6 +310,9 @@ msgid "" "`Objects/typeobject.c`. and a pure Python equivalent can be found in " "`Guido's Tutorial`_." msgstr "" +"Les détails d'implémentation sont dans :c:func:`super_getattro()` dans :" +"source:`Objects/typeobject.c` et un équivalent Python pur peut être trouvé " +"dans `Guido's Tutorial`_." #: ../Doc/howto/descriptor.rst:132 msgid "" @@ -235,10 +323,16 @@ msgid "" "Likewise, classes can turn-off descriptor invocation by overriding :meth:" "`__getattribute__()`." msgstr "" +"Les détails ci-dessus montrent que le mécanisme des descripteurs est intégré " +"dans les méthodes :meth:`__getattribute__()` pour :class:`object', :class:" +"`type', et :func:`super`. Les classes héritent de cette machinerie " +"lorsqu'elles dérivent de :class:`object' ou si elles ont une méta-classe " +"fournissant des fonctionnalités similaires. De même, les classes peuvent " +"désactiver l'appel de descripteurs en remplaçant :meth:`__getattribute__()`." #: ../Doc/howto/descriptor.rst:141 msgid "Descriptor Example" -msgstr "" +msgstr "Exemple de descripteur" #: ../Doc/howto/descriptor.rst:143 msgid "" @@ -247,6 +341,11 @@ msgid "" "alternate approach that could do this for every attribute. However, this " "descriptor is useful for monitoring just a few chosen attributes::" msgstr "" +"Le code suivant crée une classe dont les objets sont des descripteurs de " +"données qui impriment un message pour chaque lecture ou écriture. " +"Redefinir :meth:`__getattribute__` est une approche alternative qui pourrait " +"le faire pour chaque attribut. Cependant, ce descripteur n'est utile que " +"pour le suivi de quelques attributs choisis : ::" #: ../Doc/howto/descriptor.rst:181 msgid "" @@ -255,27 +354,39 @@ msgid "" "Properties, bound methods, static methods, and class methods are all based " "on the descriptor protocol." msgstr "" +"Le protocole est simple et offre des possibilités passionnantes. Plusieurs " +"cas d'utilisation sont si courants qu'ils ont été regroupés en appels de " +"fonction individuels. Les propriétés, les méthodes liées, les méthodes " +"statiques et les méthodes de classe sont toutes basées sur le protocole du " +"descripteur." #: ../Doc/howto/descriptor.rst:188 msgid "Properties" -msgstr "" +msgstr "Propriétés" #: ../Doc/howto/descriptor.rst:190 msgid "" "Calling :func:`property` is a succinct way of building a data descriptor " "that triggers function calls upon access to an attribute. Its signature is::" msgstr "" +"Appeler :func:`property` est une façon succincte de construire un " +"descripteur de données qui déclenche des appels de fonction lors de l'accès " +"à un attribut. Sa signature est : ::" #: ../Doc/howto/descriptor.rst:195 msgid "" "The documentation shows a typical use to define a managed attribute ``x``::" msgstr "" +"La documentation montre une utilisation typique pour définir un attribut " +"géré ``x`` : ::" #: ../Doc/howto/descriptor.rst:203 msgid "" "To see how :func:`property` is implemented in terms of the descriptor " "protocol, here is a pure Python equivalent::" msgstr "" +"Pour voir comment :func:`property` est implémenté dans le protocole du " +"descripteur, voici un un équivalent Python pur : ::" #: ../Doc/howto/descriptor.rst:243 msgid "" @@ -283,6 +394,9 @@ msgid "" "attribute access and then subsequent changes require the intervention of a " "method." msgstr "" +"La fonction :func:`property` intégrée aide chaque fois qu'une interface " +"utilisateur a accordé l'accès à un attribut et que des modifications " +"ultérieures nécessitent l'intervention d'une méthode." #: ../Doc/howto/descriptor.rst:247 msgid "" @@ -293,16 +407,25 @@ msgid "" "solution is to wrap access to the value attribute in a property data " "descriptor::" msgstr "" +"Par exemple, une classe de tableur peut donner accès à une valeur de cellule " +"via ``Cell('b10').value``. Les améliorations ultérieures du programme " +"exigent que la cellule soit recalculée à chaque accès ; cependant, le " +"programmeur ne veut pas affecter le code client existant accédant " +"directement à l'attribut. La solution consiste à envelopper l'accès à " +"l'attribut de valeur dans un descripteur de données de propriété : ::" #: ../Doc/howto/descriptor.rst:263 msgid "Functions and Methods" -msgstr "" +msgstr "Fonctions et méthodes" #: ../Doc/howto/descriptor.rst:265 msgid "" "Python's object oriented features are built upon a function based " "environment. Using non-data descriptors, the two are merged seamlessly." msgstr "" +"Les fonctionnalités orientées objet de Python sont construites sur un " +"environnement basé sur des fonctions. À l'aide de descripteurs *non-data*, " +"les deux sont fusionnés de façon transparente." #: ../Doc/howto/descriptor.rst:268 msgid "" @@ -313,6 +436,13 @@ msgid "" "convention, the instance reference is called *self* but may be called *this* " "or any other variable name." msgstr "" +"Les dictionnaires de classes stockent les méthodes sous forme de fonctions. " +"Dans une définition de classe, les méthodes sont écrites en utilisant :mot-" +"clé:`def` ou :mot-clé:`lambda`, les outils habituels pour créer des " +"fonctions. Les méthodes ne diffèrent des fonctions régulières que par le " +"fait que le premier argument est réservé à l'instance de l'objet. Par " +"convention Python, la référence de l'instance est appelée *self* mais peut " +"être appelée *this* ou tout autre nom de variable." #: ../Doc/howto/descriptor.rst:275 msgid "" @@ -321,21 +451,30 @@ msgid "" "non-data descriptors which return bound methods when they are invoked from " "an object. In pure Python, it works like this::" msgstr "" +"Pour prendre en charge les appels de méthodes, les fonctions incluent la " +"méthode :meth:`__get__` pour lier les méthodes pendant l'accès aux " +"attributs. Cela signifie que toutes les fonctions sont des descripteurs " +"*non-data* qui renvoient des méthodes liées lorsqu'elles sont appelées " +"depuis un objet. En Python pur, il fonctionne comme ceci : ::" #: ../Doc/howto/descriptor.rst:288 msgid "" "Running the interpreter shows how the function descriptor works in practice::" msgstr "" +"L'exécution de l'interpréteur montre comment le descripteur de fonction se " +"comporte dans la pratique : ::" #: ../Doc/howto/descriptor.rst:326 msgid "Static Methods and Class Methods" -msgstr "" +msgstr "Méthodes statiques et méthodes de classe" #: ../Doc/howto/descriptor.rst:328 msgid "" "Non-data descriptors provide a simple mechanism for variations on the usual " "patterns of binding functions into methods." msgstr "" +"Les descripteurs *non-data* fournissent un mécanisme simple pour les " +"variations des patrons habituels des fonctions de liaison dans les méthodes." #: ../Doc/howto/descriptor.rst:331 msgid "" @@ -344,22 +483,28 @@ msgid "" "transforms an ``obj.f(*args)`` call into ``f(obj, *args)``. Calling ``klass." "f(*args)`` becomes ``f(*args)``." msgstr "" +"Pour résumer, les fonctions ont une méthode :meth:`__get__` pour qu'elles " +"puissent être converties en méthode lorsqu'on y accède comme attributs. Le " +"descripteur *non-data* transforme un appel ``obj.f(*args)``en ``f(obj, " +"*args)``. Appeler ``klass.f(*args)`` devient ``f(*args)``." #: ../Doc/howto/descriptor.rst:336 msgid "This chart summarizes the binding and its two most useful variants:" msgstr "" +"Ce tableau résume le lien (*binding*) et ses deux variantes les plus " +"utiles : ::" #: ../Doc/howto/descriptor.rst:339 msgid "Transformation" -msgstr "" +msgstr "Transformation" #: ../Doc/howto/descriptor.rst:339 msgid "Called from an Object" -msgstr "" +msgstr "Appelé depuis un Objet" #: ../Doc/howto/descriptor.rst:339 msgid "Called from a Class" -msgstr "" +msgstr "Appelé depuis un Classe" #: ../Doc/howto/descriptor.rst:342 msgid "function" @@ -367,27 +512,27 @@ msgstr "fonction" #: ../Doc/howto/descriptor.rst:342 msgid "f(obj, \\*args)" -msgstr "" +msgstr "f(obj, \\*args)" #: ../Doc/howto/descriptor.rst:342 ../Doc/howto/descriptor.rst:344 msgid "f(\\*args)" -msgstr "" +msgstr "f(\\*args)" #: ../Doc/howto/descriptor.rst:344 msgid "staticmethod" -msgstr "" +msgstr "méthode statique" #: ../Doc/howto/descriptor.rst:346 msgid "classmethod" -msgstr "" +msgstr "méthode de classe" #: ../Doc/howto/descriptor.rst:346 msgid "f(type(obj), \\*args)" -msgstr "" +msgstr "f(type(obj), \\*args)" #: ../Doc/howto/descriptor.rst:346 msgid "f(klass, \\*args)" -msgstr "" +msgstr "f(klass, \\*args)" #: ../Doc/howto/descriptor.rst:349 msgid "" @@ -397,12 +542,19 @@ msgid "" "result, the function becomes identically accessible from either an object or " "a class." msgstr "" +"Les méthodes statiques renvoient la fonction sous-jacente sans " +"modifications. Appeler ``c.f`` ou ``C.f`` est l'équivalent d'une recherche " +"directe dans ``objet.__getattribute__(c, \"f\")`` ou ``objet." +"__getattribute__(C, \"f\")``. Par conséquent, la fonction devient accessible " +"de manière identique à partir d'un objet ou d'une classe." #: ../Doc/howto/descriptor.rst:355 msgid "" "Good candidates for static methods are methods that do not reference the " "``self`` variable." msgstr "" +"Les méthodes candidate a méthode statique sont des méthodes qui ne font pas " +"référence à la variable ``self``." #: ../Doc/howto/descriptor.rst:358 msgid "" @@ -415,18 +567,32 @@ msgid "" "particular dataset. It can be called either from an object or the class: " "``s.erf(1.5) --> .9332`` or ``Sample.erf(1.5) --> .9332``." msgstr "" +"Par exemple, un paquet de statistiques peut inclure une classe de conteneurs " +"pour les données expérimentales. La classe fournit des méthodes normales " +"pour calculer la moyenne, la moyenne, la médiane et d'autres statistiques " +"descriptives qui dépendent des données. Cependant, il peut y avoir des " +"fonctions utiles qui sont conceptuellement liées mais qui ne dépendent pas " +"des données. Par exemple, ``erf(x)`` est une routine de conversion pratique " +"qui apparaît dans le travail statistique mais qui ne dépend pas directement " +"d'un ensemble de données particulier. Il peut être appelé à partir d'un " +"objet ou de la classe : ``s.erf(1.5) --> .9332``` ou ``Sample.erf(1.5) --" +"> .9332``." #: ../Doc/howto/descriptor.rst:367 msgid "" "Since staticmethods return the underlying function with no changes, the " "example calls are unexciting::" msgstr "" +"Depuis que les méthodes statiques renvoient la fonction sous-jacente sans " +"changement, les exemples d’appels ne sont pas excitants : ::" #: ../Doc/howto/descriptor.rst:380 msgid "" "Using the non-data descriptor protocol, a pure Python version of :func:" "`staticmethod` would look like this::" msgstr "" +"En utilisant le protocole de descripteur *non-data*, une version Python pure " +"de :func:`staticmethod` ressemblerait à ceci : ::" #: ../Doc/howto/descriptor.rst:392 msgid "" @@ -434,6 +600,9 @@ msgid "" "argument list before calling the function. This format is the same for " "whether the caller is an object or a class::" msgstr "" +"Contrairement aux méthodes statiques, les méthodes de classe préchargent la " +"référence de classe dans la liste d'arguments avant d'appeler la fonction. " +"Ce format est le même que l'appelant soit un objet ou une classe : ::" #: ../Doc/howto/descriptor.rst:407 msgid "" @@ -443,13 +612,23 @@ msgid "" "classmethod :func:`dict.fromkeys` creates a new dictionary from a list of " "keys. The pure Python equivalent is::" msgstr "" +"Ce comportement est utile lorsque la fonction n'a besoin que d'une référence " +"de classe et ne se soucie pas de données sous-jacentes. Une des " +"utilisations des méthodes de classe est de créer d'autres constructeurs de " +"classe. En Python 2.3, la méthode de classe :func:`dict.fromkeys` crée un " +"nouveau dictionnaire à partir d'une liste de clés. L'équivalent Python pur " +"est : ::" #: ../Doc/howto/descriptor.rst:423 msgid "Now a new dictionary of unique keys can be constructed like this::" msgstr "" +"Maintenant un nouveau dictionnaire de clés uniques peut être construit comme " +"ceci : ::" #: ../Doc/howto/descriptor.rst:428 msgid "" "Using the non-data descriptor protocol, a pure Python version of :func:" "`classmethod` would look like this::" msgstr "" +"En utilisant le protocole de descripteur *non-data*, une version Python pure " +"de :func:`classmethod` ressemblerait à ceci : ::"