# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-07-20 10:51+0200\n"
"PO-Revision-Date: 2020-03-28 20:32+0100\n"
"Last-Translator: Mathieu Dupuy <deronnax@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.3\n"

#: howto/descriptor.rst:3
msgid "Descriptor HowTo Guide"
msgstr "Guide pour l'utilisation des descripteurs"

#: howto/descriptor.rst:0
msgid "Author"
msgstr "Auteur"

#: howto/descriptor.rst:5
msgid "Raymond Hettinger"
msgstr "Raymond Hettinger"

#: howto/descriptor.rst:0
msgid "Contact"
msgstr "Contact"

#: howto/descriptor.rst:6
msgid "<python at rcn dot com>"
msgstr "<python at rcn dot com>"

#: howto/descriptor.rst:8
msgid "Contents"
msgstr "Sommaire"

#: howto/descriptor.rst:11
msgid "Abstract"
msgstr "Résumé"

#: howto/descriptor.rst:13
msgid ""
"Defines descriptors, summarizes the protocol, and shows how descriptors are "
"called.  Examines a custom descriptor and several built-in Python "
"descriptors including functions, properties, static methods, and class "
"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."

#: howto/descriptor.rst:18
msgid ""
"Learning about descriptors not only provides access to a larger toolset, it "
"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."

#: howto/descriptor.rst:24
msgid "Definition and Introduction"
msgstr "Définition et introduction"

#: howto/descriptor.rst:26
msgid ""
"In general, a descriptor is an object attribute with \"binding behavior\", "
"one whose attribute access has been overridden by methods in the descriptor "
"protocol.  Those methods are :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 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."

#: howto/descriptor.rst:32
msgid ""
"The default behavior for attribute access is to get, set, or delete the "
"attribute from an object's dictionary.  For instance, ``a.x`` has a lookup "
"chain starting with ``a.__dict__['x']``, then ``type(a).__dict__['x']``, and "
"continuing through the base classes of ``type(a)`` excluding metaclasses. If "
"the looked-up value is an object defining one of the descriptor methods, "
"then Python may override the default behavior and invoke the descriptor "
"method instead. Where this occurs in the precedence chain depends on which "
"descriptor methods were defined."
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."

#: howto/descriptor.rst:41
msgid ""
"Descriptors are a powerful, general purpose protocol.  They are the "
"mechanism behind properties, methods, static methods, class methods, and :"
"func:`super()`. They are used throughout Python itself to implement the new "
"style classes introduced in version 2.2.  Descriptors simplify the "
"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."

#: howto/descriptor.rst:49
msgid "Descriptor Protocol"
msgstr "Protocole descripteur"

#: howto/descriptor.rst:51
msgid "``descr.__get__(self, obj, type=None) -> value``"
msgstr "``descr.__get__(self, obj, type=None) -> value``"

#: howto/descriptor.rst:53
msgid "``descr.__set__(self, obj, value) -> None``"
msgstr "``descr.__set__(self, obj, value) -> None``"

#: howto/descriptor.rst:55
msgid "``descr.__delete__(self, obj) -> None``"
msgstr "``descr.__delete__(self, obj) -> None``"

#: howto/descriptor.rst:57
msgid ""
"That is all there is to it.  Define any of these methods and an object is "
"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."

#: howto/descriptor.rst:61
msgid ""
"If an object defines :meth:`__set__` or :meth:`__delete__`, it is considered "
"a data descriptor.  Descriptors that only define :meth:`__get__` are called "
"non-data descriptors (they are typically used for methods but other uses are "
"possible)."
msgstr ""
"Si un objet définit :meth:`__set__` ou :meth:`__delete__`, 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)."

#: howto/descriptor.rst:66
msgid ""
"Data and non-data descriptors differ in how overrides are calculated with "
"respect to entries in an instance's dictionary.  If an instance's dictionary "
"has an entry with the same name as a data descriptor, the data descriptor "
"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é."

#: howto/descriptor.rst:72
msgid ""
"To make a read-only data descriptor, define both :meth:`__get__` and :meth:"
"`__set__` with the :meth:`__set__` raising an :exc:`AttributeError` when "
"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."

#: howto/descriptor.rst:79
msgid "Invoking Descriptors"
msgstr "Invocation des descripteurs"

#: howto/descriptor.rst:81
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)``."

#: howto/descriptor.rst:84
msgid ""
"Alternatively, it is more common for a descriptor to be invoked "
"automatically upon attribute access.  For example, ``obj.d`` looks up ``d`` "
"in the dictionary of ``obj``.  If ``d`` defines the method :meth:`__get__`, "
"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."

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

#: howto/descriptor.rst:91
msgid ""
"For objects, the machinery is in :meth:`object.__getattribute__` which "
"transforms ``b.x`` into ``type(b).__dict__['x'].__get__(b, type(b))``.  The "
"implementation works through a precedence chain that gives data descriptors "
"priority over instance variables, instance variables priority over non-data "
"descriptors, and assigns lowest priority to :meth:`__getattr__` if provided. "
"The full C implementation can be found in :c:func:"
"`PyObject_GenericGetAttr()` in :source:`Objects/object.c`."
msgstr ""
"Pour les objets, la machinerie est dans :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 en C peut être trouvée dans :c:func:"
"`PyObject_GenericGetAttr()` dans :source:`Objects/object.c`."

#: howto/descriptor.rst:99
msgid ""
"For classes, the machinery is in :meth:`type.__getattribute__` which "
"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, "
"cela ressemble à ::"

#: howto/descriptor.rst:110
msgid "The important points to remember are:"
msgstr "Les points importants à retenir sont :"

#: howto/descriptor.rst:112
msgid "descriptors are invoked by the :meth:`__getattribute__` method"
msgstr "les descripteurs sont appelés par la méthode :meth:`__getattribute__`"

#: howto/descriptor.rst:113
msgid "overriding :meth:`__getattribute__` prevents automatic descriptor calls"
msgstr ""
"redéfinir :meth:`__getattribute____` empêche les appels automatiques de "
"descripteurs"

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

#: howto/descriptor.rst:116
msgid "data descriptors always override instance dictionaries."
msgstr ""
"les descripteurs de données remplacent toujours les dictionnaires "
"d'instances."

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

#: howto/descriptor.rst:119
msgid ""
"The object returned by ``super()`` also has a custom :meth:"
"`__getattribute__` method for invoking descriptors.  The attribute lookup "
"``super(B, obj).m`` searches ``obj.__class__.__mro__`` for the base class "
"``A`` immediately following ``B`` and then returns ``A.__dict__['m']."
"__get__(obj, 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 renvoyé par ``super()`` a également une méthode personnalisée :meth:"
"`__getattribute__` pour invoquer des descripteurs. La recherche d'attribut "
"``super(B, obj).m`` recherche dans ``obj.__class__.__mro__`` la classe qui "
"suit immédiatement B, appelons la A, et renvoie ``A.__dict__['m']."
"__get__(obj, B)``. Si ce n'est pas un descripteur, ``m`` est renvoyé "
"inchangé. S'il n'est pas dans le dictionnaire, la recherche de ``m`` revient "
"à une recherche utilisant :meth:`object.__getattribute__`."

#: howto/descriptor.rst:126
msgid ""
"The implementation details are in :c:func:`super_getattro()` in :source:"
"`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`_."

#: howto/descriptor.rst:132
msgid ""
"The details above show that the mechanism for descriptors is embedded in "
"the :meth:`__getattribute__()` methods for :class:`object`, :class:`type`, "
"and :func:`super`.  Classes inherit this machinery when they derive from :"
"class:`object` or if they have a meta-class providing similar functionality. "
"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__()`."

#: howto/descriptor.rst:141
msgid "Descriptor Example"
msgstr "Exemple de descripteur"

#: howto/descriptor.rst:143
msgid ""
"The following code creates a class whose objects are data descriptors which "
"print a message for each get or set.  Overriding :meth:`__getattribute__` is "
"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 affichent un message pour chaque lecture ou écriture.  "
"Redéfinir :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 ::"

#: howto/descriptor.rst:181
msgid ""
"The protocol is simple and offers exciting possibilities.  Several use cases "
"are so common that they have been packaged into individual function calls. "
"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."

#: howto/descriptor.rst:188
msgid "Properties"
msgstr "Propriétés"

#: 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 ::"

#: 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`` ::"

#: 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 ::"

#: howto/descriptor.rst:243
msgid ""
"The :func:`property` builtin helps whenever a user interface has granted "
"attribute access and then subsequent changes require the intervention of a "
"method."
msgstr ""
"La fonction native :func:`property` 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."

#: howto/descriptor.rst:247
msgid ""
"For instance, a spreadsheet class may grant access to a cell value through "
"``Cell('b10').value``. Subsequent improvements to the program require the "
"cell to be recalculated on every access; however, the programmer does not "
"want to affect existing client code accessing the attribute directly.  The "
"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é ::"

#: howto/descriptor.rst:263
msgid "Functions and Methods"
msgstr "Fonctions et méthodes"

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

#: howto/descriptor.rst:268
msgid ""
"Class dictionaries store methods as functions.  In a class definition, "
"methods are written using :keyword:`def` or :keyword:`lambda`, the usual "
"tools for creating functions.  Methods only differ from regular functions in "
"that the first argument is reserved for the object instance.  By Python "
"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 :"
"keyword:`def` ou :keyword:`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."

#: howto/descriptor.rst:275
msgid ""
"To support method calls, functions include the :meth:`__get__` method for "
"binding methods during attribute access.  This means that all functions are "
"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 ::"

#: 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 ::"

#: howto/descriptor.rst:326
msgid "Static Methods and Class Methods"
msgstr "Méthodes statiques et méthodes de classe"

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

#: howto/descriptor.rst:331
msgid ""
"To recap, functions have a :meth:`__get__` method so that they can be "
"converted to a method when accessed as attributes.  The non-data descriptor "
"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)``."

#: 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 ::"

#: howto/descriptor.rst:339
msgid "Transformation"
msgstr "Transformation"

#: howto/descriptor.rst:339
msgid "Called from an Object"
msgstr "Appelé depuis un Objet"

#: howto/descriptor.rst:339
msgid "Called from a Class"
msgstr "Appelé depuis un Classe"

#: howto/descriptor.rst:342
msgid "function"
msgstr "fonction"

#: howto/descriptor.rst:342
msgid "f(obj, \\*args)"
msgstr "f(obj, \\*args)"

#: howto/descriptor.rst:342 howto/descriptor.rst:344
msgid "f(\\*args)"
msgstr "f(\\*args)"

#: howto/descriptor.rst:344
msgid "staticmethod"
msgstr "méthode statique"

#: howto/descriptor.rst:346
msgid "classmethod"
msgstr "méthode de classe"

#: howto/descriptor.rst:346
msgid "f(type(obj), \\*args)"
msgstr "f(type(obj), \\*args)"

#: howto/descriptor.rst:346
msgid "f(klass, \\*args)"
msgstr "f(klass, \\*args)"

#: howto/descriptor.rst:349
msgid ""
"Static methods return the underlying function without changes.  Calling "
"either ``c.f`` or ``C.f`` is the equivalent of a direct lookup into ``object."
"__getattribute__(c, \"f\")`` or ``object.__getattribute__(C, \"f\")``. As a "
"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."

#: howto/descriptor.rst:355
msgid ""
"Good candidates for static methods are methods that do not reference the "
"``self`` variable."
msgstr ""
"Les bonnes candidates pour être méthode statique sont des méthodes qui ne "
"font pas référence à la variable ``self``."

#: howto/descriptor.rst:358
msgid ""
"For instance, a statistics package may include a container class for "
"experimental data.  The class provides normal methods for computing the "
"average, mean, median, and other descriptive statistics that depend on the "
"data. However, there may be useful functions which are conceptually related "
"but do not depend on the data.  For instance, ``erf(x)`` is handy conversion "
"routine that comes up in statistical work but does not directly depend on a "
"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 traitant de statistiques peut inclure une classe qui "
"est un conteneur pour des données expérimentales.  La classe fournit les "
"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. Elle peut être "
"appelée à partir d'un objet ou de la classe :  ``s.erf(1.5) --> .9332``` ou "
"``Sample.erf(1.5) --> .9332``."

#: 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 ::"

#: 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 ::"

#: howto/descriptor.rst:392
msgid ""
"Unlike static methods, class methods prepend the class reference to the "
"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 ::"

#: howto/descriptor.rst:407
msgid ""
"This behavior is useful whenever the function only needs to have a class "
"reference and does not care about any underlying data.  One use for "
"classmethods is to create alternate class constructors.  In Python 2.3, the "
"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 des 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 ::"

#: 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 ::"

#: 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 ::"
