From 061932d5b3606eb7d854a3fed53dbf923e3eb3fb Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Sat, 14 Jan 2023 19:04:46 +0000 Subject: [PATCH] Fin de la traduction de howto/descriptor (#20) Co-authored-by: Christophe Nanteuil Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/20 Co-authored-by: Christophe Nanteuil Co-committed-by: Christophe Nanteuil --- howto/descriptor.po | 220 ++++++++++++++++++++++++++++---------------- 1 file changed, 140 insertions(+), 80 deletions(-) diff --git a/howto/descriptor.po b/howto/descriptor.po index 28fde706..5cc2d94d 100644 --- a/howto/descriptor.po +++ b/howto/descriptor.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2022-05-22 23:13+0200\n" -"PO-Revision-Date: 2022-12-16 14:41+0100\n" +"PO-Revision-Date: 2023-01-14 19:47+0100\n" "Last-Translator: Mathieu Dupuy \n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -895,7 +895,7 @@ msgstr "" #: howto/descriptor.rst:828 msgid "ORM example" -msgstr "" +msgstr "Exemple d'ORM" #: howto/descriptor.rst:830 msgid "" @@ -903,6 +903,10 @@ msgid "" "be used to implement an `object relational mapping `_." msgstr "" +"Le code suivant est une ossature simplifiée montrant comment les " +"descripteurs de données peuvent être utilisés pour implémenter une " +"`correspondance objet-relationnel `_." #: howto/descriptor.rst:834 msgid "" @@ -910,6 +914,10 @@ msgid "" "Python instances only hold keys to the database's tables. Descriptors take " "care of lookups or updates:" msgstr "" +"L'idée essentielle est que les données sont stockées dans une base de " +"données externe. Les instances Python ne contiennent que les clés des tables " +"de la base de données. Les descripteurs s'occupent des recherches et des " +"mises à jour :" #: howto/descriptor.rst:853 msgid "" @@ -917,65 +925,68 @@ msgid "" "org/wiki/Database_model>`_ that describe the schema for each table in a " "database:" msgstr "" +"Nous pouvons utiliser la classe :class:`Field` pour définir des `modèles " +"`_ qui décrivent le schéma de " +"chaque table d'une base de données :" #: howto/descriptor.rst:878 msgid "To use the models, first connect to the database::" msgstr "" +"Pour utiliser les modèles, connectons-nous d'abord à la base de données ::" #: howto/descriptor.rst:883 msgid "" "An interactive session shows how data is retrieved from the database and how " "it can be updated:" msgstr "" +"Une session interactive montre comment les données sont extraites de la base " +"de données et comment elles peuvent être mises à jour :" #: howto/descriptor.rst:928 msgid "Pure Python Equivalents" -msgstr "" +msgstr "Équivalents en Python pur" #: howto/descriptor.rst:930 -#, fuzzy msgid "" "The descriptor protocol is simple and offers exciting possibilities. " "Several use cases are so common that they have been prepackaged into built-" "in tools. Properties, bound methods, static methods, class methods, and \\_" "\\_slots\\_\\_ 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." +"Le protocole descripteur est simple et offre des possibilités très " +"intéressantes. Plusieurs cas d'utilisation sont si courants qu'ils ont été " +"regroupés dans des outils intégrés. 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 descripteur." #: howto/descriptor.rst:937 msgid "Properties" msgstr "Propriétés" #: howto/descriptor.rst:939 -#, fuzzy msgid "" "Calling :func:`property` is a succinct way of building a data descriptor " "that triggers a function call 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 ::" +"Appeler :func:`property` construit de façon succincte un descripteur de " +"données qui déclenche un appel de fonction lors de l'accès à un attribut. Sa " +"signature est ::" #: howto/descriptor.rst:944 -#, fuzzy 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`` ::" +"La documentation montre une utilisation caractéristique pour définir un " +"attribut géré ``x`` ::" #: howto/descriptor.rst:968 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 équivalent Python pur ::" +"Pour voir comment :func:`property` est implémentée dans le protocole du " +"descripteur, voici un équivalent en Python pur ::" #: howto/descriptor.rst:1071 msgid "" @@ -999,15 +1010,17 @@ 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é ::" +"programmeur ne veut pas impacter le code client existant accédant " +"directement à l'attribut. La solution consiste à envelopper l'accès à " +"l'attribut *value* dans un descripteur de données ::" #: howto/descriptor.rst:1092 msgid "" "Either the built-in :func:`property` or our :func:`Property` equivalent " "would work in this example." msgstr "" +"Soit la :func:`property` native, soit notre équivalent :func:`Property` " +"fonctionnent dans cet exemple." #: howto/descriptor.rst:1097 msgid "Functions and methods" @@ -1023,84 +1036,96 @@ msgstr "" "les deux sont fusionnés de façon transparente." #: howto/descriptor.rst:1102 -#, fuzzy msgid "" "Functions stored in class dictionaries get turned into methods when invoked. " "Methods only differ from regular functions in that the object instance is " "prepended to the other arguments. By convention, the instance is called " "*self* but could 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." +"Les fonctions placées dans les dictionnaires des classes sont transformées " +"en méthodes au moment de l'appel. Les méthodes ne diffèrent des fonctions " +"ordinaires 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*, bien qu'il soit possible de l'appeler *this* ou tout autre nom de " +"variable." #: howto/descriptor.rst:1107 msgid "" "Methods can be created manually with :class:`types.MethodType` which is " "roughly equivalent to:" msgstr "" +"Les méthodes peuvent être créées manuellement avec :class:`types." +"MethodType`, qui équivaut à peu près à :" #: howto/descriptor.rst:1124 -#, fuzzy msgid "" "To support automatic creation of methods, functions include the :meth:" "`__get__` method for binding methods during attribute access. This means " "that functions are non-data descriptors that return bound methods during " "dotted lookup from an instance. Here's how it works:" 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 " -"hors-données qui renvoient des méthodes liées lorsqu'elles sont appelées " -"depuis un objet. En Python pur, il fonctionne comme ceci ::" +"Pour prendre en charge la création automatique des 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 " +"hors-données qui renvoient des méthodes liées au cours d'une recherche " +"d'attribut d'une instance. Cela fonctionne ainsi ::" #: howto/descriptor.rst:1140 -#, fuzzy msgid "" "Running the following class in 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 ::" +"L'exécution de la classe suivante dans l'interpréteur montre comment le " +"descripteur de fonction se comporte en pratique ::" #: howto/descriptor.rst:1149 msgid "" "The function has a :term:`qualified name` attribute to support introspection:" msgstr "" +"La fonction possède un attribut `__qualname__` (:term:`nom " +"qualifié`) pour prendre en charge l'introspection :" #: howto/descriptor.rst:1156 msgid "" "Accessing the function through the class dictionary does not invoke :meth:" "`__get__`. Instead, it just returns the underlying function object::" msgstr "" +"L'accès à la fonction *via* le dictionnaire de classe n'invoque pas :meth:" +"`__get__`. À la place, il renvoie simplement l'objet de fonction sous-" +"jacent ::" #: howto/descriptor.rst:1162 msgid "" "Dotted access from a class calls :meth:`__get__` which just returns the " "underlying function unchanged::" msgstr "" +"La recherche d'attribut depuis une classe appelle :meth:`__get__`, qui " +"renvoie simplement la fonction sous-jacente inchangée ::" #: howto/descriptor.rst:1168 msgid "" "The interesting behavior occurs during dotted access from an instance. The " "dotted lookup calls :meth:`__get__` which returns a bound method object::" msgstr "" +"Le comportement intéressant se produit lors d'une recherche d'attribut à " +"partir d'une instance. La recherche d'attribut appelle :meth:`__get__` qui " +"renvoie un objet « méthode liée » ::" #: howto/descriptor.rst:1175 msgid "" "Internally, the bound method stores the underlying function and the bound " "instance::" msgstr "" +"En interne, la méthode liée stocke la fonction sous-jacente et l'instance " +"liée ::" #: howto/descriptor.rst:1184 msgid "" "If you have ever wondered where *self* comes from in regular methods or " "where *cls* comes from in class methods, this is it!" msgstr "" +"Si vous vous êtes déjà demandé d'où vient *self* dans les méthodes " +"ordinaires ou d'où vient *cls* dans les méthodes de classe, c'est ça !" #: howto/descriptor.rst:1189 msgid "Kinds of methods" @@ -1111,11 +1136,10 @@ msgid "" "Non-data descriptors provide a simple mechanism for variations on the usual " "patterns of binding functions into methods." msgstr "" -"Les descripteurs hors-données fournissent un mécanisme simple pour les " -"variations des patrons habituels des fonctions de liaison dans les méthodes." +"Les descripteurs hors-données constituent un moyen simple pour modifier le " +"modèle usuel de transformation des fonctions en méthodes." #: howto/descriptor.rst:1194 -#, fuzzy 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 " @@ -1123,15 +1147,15 @@ msgid "" "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 hors-données transforme un appel ``obj.f(*args)``en ``f(obj, " -"*args)``. Appeler ``klass.f(*args)`` devient ``f(*args)``." +"puissent être converties en méthodes lorsqu'on y accède comme attributs. Le " +"descripteur hors-données transforme un appel ``obj.f(*args)`` en ``f(obj, " +"*args)``. L'appel ``cls.f(*args)`` devient ``f(*args)``." #: howto/descriptor.rst:1199 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 ::" +"Ce tableau résume le lien classique (*binding*) et ses deux variantes les " +"plus utiles ::" #: howto/descriptor.rst:1202 msgid "Transformation" @@ -1139,11 +1163,11 @@ msgstr "Transformation" #: howto/descriptor.rst:1202 msgid "Called from an object" -msgstr "Appelé depuis un objet" +msgstr "Appelée depuis un objet" #: howto/descriptor.rst:1202 msgid "Called from a class" -msgstr "Appelé depuis une classe" +msgstr "Appelée depuis une classe" #: howto/descriptor.rst:1205 msgid "function" @@ -1185,11 +1209,11 @@ 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." +"Les méthodes statiques renvoient la fonction sous-jacente sans modification. " +"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, l'accès à la fonction devient identique que ce soit à " +"partir d'un objet ou d'une classe." #: howto/descriptor.rst:1222 msgid "" @@ -1212,26 +1236,24 @@ msgid "" 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``." +"méthodes normales pour calculer 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, la fonction d'erreur ``erf(x)`` est " +"souvent utile lorsqu'on travaille en statistique mais elle 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:1234 -#, fuzzy msgid "" "Since static methods 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 ::" +"Puisque les méthodes statiques renvoient la fonction sous-jacente sans " +"changement, les exemples d’appels sont d'une grande banalité ::" #: howto/descriptor.rst:1251 -#, fuzzy msgid "" "Using the non-data descriptor protocol, a pure Python version of :func:" "`staticmethod` would look like this:" @@ -1244,18 +1266,16 @@ msgid "Class methods" msgstr "Méthodes de classe" #: howto/descriptor.rst:1292 -#, fuzzy 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 ::" +"Contrairement aux méthodes statiques, les méthodes de classe ajoutent la " +"référence de classe en tête de la liste d'arguments, avant d'appeler la " +"fonction. C'est le même format que l'appelant soit un objet ou une classe ::" #: howto/descriptor.rst:1310 -#, fuzzy msgid "" "This behavior is useful whenever the method only needs to have a class " "reference and does not rely on data stored in a specific instance. One use " @@ -1264,27 +1284,25 @@ msgid "" "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 ::" +"de classe et ne se soucie pas des données propres à une instance " +"particulière. Une des utilisations des méthodes de classe est de créer des " +"constructeurs de classe personnalisés. Par exemple, 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:1327 -#, fuzzy 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 ::" +"ceci :" #: howto/descriptor.rst:1337 -#, fuzzy 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 hors-données, une version Python " -"pure de :func:`classmethod` ressemblerait à ceci ::" +"pure de :func:`classmethod` ressemblerait à ceci :" #: howto/descriptor.rst:1388 msgid "" @@ -1293,10 +1311,15 @@ msgid "" "decorators. For example, a classmethod and property could be chained " "together. In Python 3.11, this functionality was deprecated." msgstr "" +"La portion de code pour ``hasattr(type(self.f), '__get__')`` a été ajoutée " +"dans Python 3.9 et permet à :func:`classmethod` de prendre en charge les " +"décorateurs chaînés. Par exemple, un décorateur « méthode de classe » peut " +"être chaîné à un décorateur « propriété ». Dans Python 3.11, cette " +"fonctionnalité est devenue obsolète." #: howto/descriptor.rst:1408 msgid "Member objects and __slots__" -msgstr "" +msgstr "Objets membres et *__slots__*" #: howto/descriptor.rst:1410 msgid "" @@ -1304,18 +1327,26 @@ msgid "" "fixed-length array of slot values. From a user point of view that has " "several effects:" msgstr "" +"Lorsqu'une classe définit ``__slots__``, Python remplace le dictionnaire " +"d'instance par un tableau de longueur fixe de créneaux prédéfinis. D'un " +"point de vue utilisateur, cela :" #: howto/descriptor.rst:1414 msgid "" "1. Provides immediate detection of bugs due to misspelled attribute " "assignments. Only attribute names specified in ``__slots__`` are allowed:" msgstr "" +"1/ permet une détection immédiate des bogues dus à des affectations " +"d'attributs mal orthographiés. Seuls les noms d'attribut spécifiés dans " +"``__slots__`` sont autorisés :" #: howto/descriptor.rst:1430 msgid "" "2. Helps create immutable objects where descriptors manage access to private " "attributes stored in ``__slots__``:" msgstr "" +"2/ aide à créer des objets immuables où les descripteurs gèrent l'accès aux " +"attributs privés stockés dans ``__slots__`` :" #: howto/descriptor.rst:1465 msgid "" @@ -1324,18 +1355,28 @@ msgid "" "design pattern `_ likely " "only matters when a large number of instances are going to be created." msgstr "" +"3/ économise de la mémoire. Sur une version Linux 64 bits, une instance avec " +"deux attributs prend 48 octets avec ``__slots__`` et 152 octets sans. Ce " +"patron de conception `poids mouche `_ n'a probablement d'importance que si un " +"grand nombre d'instances doivent être créées ;" #: howto/descriptor.rst:1470 msgid "" "4. Improves speed. Reading instance variables is 35% faster with " "``__slots__`` (as measured with Python 3.10 on an Apple M1 processor)." msgstr "" +"4/ améliore la vitesse. La lecture des variables d'instance est 35 % plus " +"rapide avec ``__slots__`` (mesure effectuée avec Python 3.10 sur un " +"processeur Apple M1) ;" #: howto/descriptor.rst:1473 msgid "" "5. Blocks tools like :func:`functools.cached_property` which require an " "instance dictionary to function correctly:" msgstr "" +"5/ bloque les outils comme :func:`functools.cached_property` qui nécessitent " +"un dictionnaire d'instance pour fonctionner correctement :" #: howto/descriptor.rst:1495 msgid "" @@ -1346,12 +1387,21 @@ msgid "" "``_slotvalues`` list. Reads and writes to that private structure are " "managed by member descriptors:" msgstr "" +"Il n'est pas possible de créer une version Python pure exacte de " +"``__slots__`` car il faut un accès direct aux structures C et un contrôle " +"sur l'allocation de la mémoire des objets. Cependant, nous pouvons " +"construire une simulation presque fidèle où la structure C réelle pour les " +"*slots* est émulée par une liste privée ``_slotvalues``. Les lectures et " +"écritures dans cette structure privée sont gérées par des descripteurs de " +"membres :" #: howto/descriptor.rst:1538 msgid "" "The :meth:`type.__new__` method takes care of adding member objects to class " "variables:" msgstr "" +"La méthode :meth:`type.__new__` s'occupe d'ajouter des objets membres aux " +"variables de classe :" #: howto/descriptor.rst:1554 msgid "" @@ -1359,27 +1409,37 @@ msgid "" "slots instead of an instance dictionary. Here is a rough simulation in pure " "Python:" msgstr "" +"La méthode :meth:`object.__new__` s'occupe de créer des instances qui ont " +"des *slots* au lieu d'un dictionnaire d'instances. Voici une simulation " +"approximative en Python pur :" #: howto/descriptor.rst:1589 msgid "" "To use the simulation in a real class, just inherit from :class:`Object` and " "set the :term:`metaclass` to :class:`Type`:" msgstr "" +"Pour utiliser la simulation dans une classe réelle, héritez simplement de :" +"class:`Object` et définissez la :term:`métaclasse ` à :class:" +"`Type` :" #: howto/descriptor.rst:1603 msgid "" "At this point, the metaclass has loaded member objects for *x* and *y*::" msgstr "" +"À ce stade, la métaclasse a chargé des objets membres pour *x* et *y* ::" #: howto/descriptor.rst:1624 msgid "" "When instances are created, they have a ``slot_values`` list where the " "attributes are stored:" msgstr "" +"Lorsque les instances sont créées, elles ont une liste ``slot_values`` où " +"les attributs sont stockés :" #: howto/descriptor.rst:1636 msgid "Misspelled or unassigned attributes will raise an exception:" msgstr "" +"Les attributs mal orthographiés ou non attribués lèvent une exception :" #~ msgid "" #~ "Defines descriptors, summarizes the protocol, and shows how descriptors "