python-docs-fr/library/functools.po

# 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-12-17 16:05+0100\n"
"PO-Revision-Date: 2019-12-11 11:16+0100\n"
"Last-Translator: Julien Palard <julien@palard.fr>\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.0.2\n"

#: library/functools.rst:2
msgid ""
":mod:`functools` --- Higher-order functions and operations on callable "
"objects"
msgstr ""
":mod:`functools` --- Fonctions de haut niveau et opérations sur des objets "
"appelables"

#: library/functools.rst:14
msgid "**Source code:** :source:`Lib/functools.py`"
msgstr "**Code source :** :source:`Lib/functools.py`"

#: library/functools.rst:23
msgid ""
"The :mod:`functools` module is for higher-order functions: functions that "
"act on or return other functions. In general, any callable object can be "
"treated as a function for the purposes of this module."
msgstr ""
"Le module :mod:`functools` est utilisé pour des fonctions de haut niveau : "
"des fonctions qui agissent sur ou revoient d'autres fonctions. En général, "
"tout objet appelable peut être utilisé comme une fonction pour les besoins "
"de ce module."

#: library/functools.rst:27
msgid "The :mod:`functools` module defines the following functions:"
msgstr "Le module :mod:`functools` définit les fonctions suivantes :"

#: library/functools.rst:31
msgid ""
"Simple lightweight unbounded function cache.  Sometimes called `\"memoize\" "
"<https://en.wikipedia.org/wiki/Memoization>`_."
msgstr ""

#: library/functools.rst:34
msgid ""
"Returns the same as ``lru_cache(maxsize=None)``, creating a thin wrapper "
"around a dictionary lookup for the function arguments.  Because it never "
"needs to evict old values, this is smaller and faster than :func:"
"`lru_cache()` with a size limit."
msgstr ""

#: library/functools.rst:245
msgid "For example::"
msgstr "Par exemple ::"

#: library/functools.rst:57
msgid ""
"Transform a method of a class into a property whose value is computed once "
"and then cached as a normal attribute for the life of the instance. Similar "
"to :func:`property`, with the addition of caching. Useful for expensive "
"computed properties of instances that are otherwise effectively immutable."
msgstr ""

#: library/functools.rst:117 library/functools.rst:330
msgid "Example::"
msgstr "Exemple ::"

#: library/functools.rst:76
msgid ""
"Note, this decorator interferes with the operation of :pep:`412` key-sharing "
"dictionaries.  This means that instance dictionaries can take more space "
"than usual."
msgstr ""

#: library/functools.rst:80
msgid ""
"Also, this decorator requires that the ``__dict__`` attribute on each "
"instance be a mutable mapping. This means it will not work with some types, "
"such as metaclasses (since the ``__dict__`` attributes on type instances are "
"read-only proxies for the class namespace), and those that specify "
"``__slots__`` without including ``__dict__`` as one of the defined slots (as "
"such classes don't provide a ``__dict__`` attribute at all)."
msgstr ""

#: library/functools.rst:87
msgid ""
"If a mutable mapping is not available or if space-efficient key sharing is "
"desired, an effect similar to :func:`cached_property` can be achieved by a "
"stacking :func:`property` on top of :func:`cache`::"
msgstr ""

#: library/functools.rst:105
msgid ""
"Transform an old-style comparison function to a :term:`key function`.  Used "
"with tools that accept key functions (such as :func:`sorted`, :func:`min`, :"
"func:`max`, :func:`heapq.nlargest`, :func:`heapq.nsmallest`, :func:"
"`itertools.groupby`).  This function is primarily used as a transition tool "
"for programs being converted from Python 2 which supported the use of "
"comparison functions."
msgstr ""
"Transforme une fonction de comparaison à l'ancienne en une :term:`fonction "
"clé`.  Utilisé avec des outils qui acceptent des fonctions clef (comme :func:"
"`sorted`, :func:`min`, :func:`max`, :func:`heapq.nlargest`, :func:`heapq."
"nsmallest`, :func:`itertools.groupby`).  Cette fonction est destinée au "
"portage de fonctions python 2 utilisant des fonctions de comparaison vers "
"Python 3."

#: library/functools.rst:112
msgid ""
"A comparison function is any callable that accept two arguments, compares "
"them, and returns a negative number for less-than, zero for equality, or a "
"positive number for greater-than.  A key function is a callable that accepts "
"one argument and returns another value to be used as the sort key."
msgstr ""
"Une fonction de comparaison est un appelable qui prend deux arguments, les "
"compare, et renvoie un nombre négatif pour l'infériorité, zéro pour "
"l'égalité ou un nombre positif pour la supériorité.  Une fonction de clé est "
"un appelable qui prend un argument et retourne une autre valeur qui sera "
"utilisée comme clé de tri."

#: library/functools.rst:121
msgid ""
"For sorting examples and a brief sorting tutorial, see :ref:`sortinghowto`."
msgstr ""
"Pour des exemples de tris et un bref tutoriel, consultez :ref:`sortinghowto`."

#: library/functools.rst:129
msgid ""
"Decorator to wrap a function with a memoizing callable that saves up to the "
"*maxsize* most recent calls.  It can save time when an expensive or I/O "
"bound function is periodically called with the same arguments."
msgstr ""
"Décorateur qui englobe une fonction avec un appelable mémoïsant qui "
"enregistre jusqu'à *maxsize* appels récents. Cela peut gagner du temps quand "
"une fonction coûteuse en ressources est souvent appelée avec les mêmes "
"arguments."

#: library/functools.rst:133
msgid ""
"Since a dictionary is used to cache results, the positional and keyword "
"arguments to the function must be hashable."
msgstr ""
"Comme un dictionnaire est utilisé pour mettre en cache les résultats, les "
"arguments positionnels et nommés de la fonction doivent être hachables."

#: library/functools.rst:136
msgid ""
"Distinct argument patterns may be considered to be distinct calls with "
"separate cache entries.  For example, `f(a=1, b=2)` and `f(b=2, a=1)` differ "
"in their keyword argument order and may have two separate cache entries."
msgstr ""
"Des agencements différents des arguments peuvent être considérés comme des "
"appels différents avec chacun leur propre entrée dans le cache. Par exemple, "
"`f(a=1, b=2)` et `f(b=2, a=1)` n'ont pas leurs arguments dans le même ordre, "
"ce qui peut conduire à des entrées séparées dans le cache."

#: library/functools.rst:141
msgid ""
"If *user_function* is specified, it must be a callable. This allows the "
"*lru_cache* decorator to be applied directly to a user function, leaving the "
"*maxsize* at its default value of 128::"
msgstr ""

#: library/functools.rst:150
#, fuzzy
msgid ""
"If *maxsize* is set to ``None``, the LRU feature is disabled and the cache "
"can grow without bound."
msgstr ""
"Si *maxsize* est à ``None``, la fonctionnalité LRU est désactivée et le "
"cache peut grossir sans limite.  La fonctionnalité LRU fonctionne mieux "
"quand *maxsize* est une puissance de deux."

#: library/functools.rst:153
msgid ""
"If *typed* is set to true, function arguments of different types will be "
"cached separately.  For example, ``f(3)`` and ``f(3.0)`` will be treated as "
"distinct calls with distinct results."
msgstr ""
"Si *typed* est vrai, les arguments de différents types seront mis en cache "
"séparément.  Par exemple, ``f(3)`` et ``f(3.0)`` seront considérés comme des "
"appels distincts avec des résultats distincts."

#: library/functools.rst:157
msgid ""
"The wrapped function is instrumented with a :func:`cache_parameters` "
"function that returns a new :class:`dict` showing the values for *maxsize* "
"and *typed*.  This is for information purposes only.  Mutating the values "
"has no effect."
msgstr ""

#: library/functools.rst:162
msgid ""
"To help measure the effectiveness of the cache and tune the *maxsize* "
"parameter, the wrapped function is instrumented with a :func:`cache_info` "
"function that returns a :term:`named tuple` showing *hits*, *misses*, "
"*maxsize* and *currsize*.  In a multi-threaded environment, the hits and "
"misses are approximate."
msgstr ""
"Pour aider à mesurer l'efficacité du cache et ajuster le paramètre "
"*maxsize*, la fonction englobée est surveillée avec une fonction :func:"
"`cache_info` qui renvoie un :term:`named tuple` affichant les *hits*, "
"*misses*, *maxsize* et *currsize*.  Dans un environnement *multithread*, les "
"succès et échecs d'appel du cache sont approximatifs."

#: library/functools.rst:168
msgid ""
"The decorator also provides a :func:`cache_clear` function for clearing or "
"invalidating the cache."
msgstr ""
"Le décorateur fournit également une fonction :func:`cache_clear` pour vider "
"ou invalider le cache."

#: library/functools.rst:171
msgid ""
"The original underlying function is accessible through the :attr:"
"`__wrapped__` attribute.  This is useful for introspection, for bypassing "
"the cache, or for rewrapping the function with a different cache."
msgstr ""
"La fonction sous-jacente originale est accessible à travers l'attribut :attr:"
"`__wrapped__`.  Ceci est utile pour l'introspection, pour outrepasser le "
"cache, ou pour ré-englober la fonction avec un cache différent."

#: library/functools.rst:175
#, fuzzy
msgid ""
"An `LRU (least recently used) cache <https://en.wikipedia.org/wiki/"
"Cache_replacement_policies#Least_recently_used_(LRU)>`_ works best when the "
"most recent calls are the best predictors of upcoming calls (for example, "
"the most popular articles on a news server tend to change each day).  The "
"cache's size limit assures that the cache does not grow without bound on "
"long-running processes such as web servers."
msgstr ""
"Un `cache LRU (*least recently used*) <https://fr.wikipedia.org/wiki/"
"Algorithmes_de_remplacement_des_lignes_de_cache#LRU_.28Least_Recently_Used.29>`_ "
"fonctionne très bien lorsque les appels récents sont les prochains appels "
"les plus probables (par exemple, les articles les plus lus d'un serveur "
"d'actualités ont tendance à ne changer que d'un jour à l'autre). La taille "
"limite du cache permet de s'assurer que le cache ne grossisse pas sans "
"limite sur les processus longs comme les serveurs web."

#: library/functools.rst:182
msgid ""
"In general, the LRU cache should only be used when you want to reuse "
"previously computed values.  Accordingly, it doesn't make sense to cache "
"functions with side-effects, functions that need to create distinct mutable "
"objects on each call, or impure functions such as time() or random()."
msgstr ""
"En général, le cache LRU ne doit être utilisé que quand vous voulez ré-"
"utiliser les valeurs déjà calculées. Ainsi, cela n'a pas de sens de mettre "
"un cache sur une fonction qui a des effets de bord, qui doit créer un objet "
"mutable distinct à chaque appel ou des fonctions *impures* telles que ``!"
"time()`` ou ``!random()``."

#: library/functools.rst:187
msgid "Example of an LRU cache for static web content::"
msgstr "Exemple d'un cache LRU pour du contenu web statique ::"

#: library/functools.rst:206
msgid ""
"Example of efficiently computing `Fibonacci numbers <https://en.wikipedia."
"org/wiki/Fibonacci_number>`_ using a cache to implement a `dynamic "
"programming <https://en.wikipedia.org/wiki/Dynamic_programming>`_ technique::"
msgstr ""
"Exemple de calcul efficace de `la suite de Fibonacci <https://fr.wikipedia."
"org/wiki/Suite_de_Fibonacci>`_ en utilisant un cache pour implémenter la "
"technique de `programmation dynamique <https://fr.wikipedia.org/wiki/"
"Programmation_dynamique>`_ ::"

#: library/functools.rst:226
msgid "Added the *typed* option."
msgstr "L'option *typed* a été ajoutée."

#: library/functools.rst:229
#, fuzzy
msgid "Added the *user_function* option."
msgstr "L'option *typed* a été ajoutée."

#: library/functools.rst:232
msgid "Added the function :func:`cache_parameters`"
msgstr ""

#: library/functools.rst:237
msgid ""
"Given a class defining one or more rich comparison ordering methods, this "
"class decorator supplies the rest.  This simplifies the effort involved in "
"specifying all of the possible rich comparison operations:"
msgstr ""
"A partir d'une classe définissant une ou plusieurs méthodes de comparaison "
"riches, ce décorateur de classe fournit le reste.  Ceci simplifie l'effort à "
"fournir dans la spécification de toutes les opérations de comparaison riche :"

#: library/functools.rst:241
msgid ""
"The class must define one of :meth:`__lt__`, :meth:`__le__`, :meth:`__gt__`, "
"or :meth:`__ge__`. In addition, the class should supply an :meth:`__eq__` "
"method."
msgstr ""
"La classe doit définir au moins une de ces méthodes :meth:`__lt__`, :meth:"
"`__le__`, :meth:`__gt__`, or :meth:`__ge__`. De plus, la classe doit fournir "
"une méthode :meth:`__eq__`."

#: library/functools.rst:265
msgid ""
"While this decorator makes it easy to create well behaved totally ordered "
"types, it *does* come at the cost of slower execution and more complex stack "
"traces for the derived comparison methods. If performance benchmarking "
"indicates this is a bottleneck for a given application, implementing all six "
"rich comparison methods instead is likely to provide an easy speed boost."
msgstr ""
"Même si ce décorateur permet de créer des types ordonnables facilement, cela "
"vient avec un *coût* d'exécution et des traces d'exécution complexes pour "
"les méthodes de comparaison dérivées. Si des tests de performances le "
"révèlent comme un goulot d'étranglement, l'implémentation manuelle des six "
"méthodes de comparaison riches résoudra normalement vos problèmes de "
"rapidité."

#: library/functools.rst:274
msgid ""
"Returning NotImplemented from the underlying comparison function for "
"unrecognised types is now supported."
msgstr ""
"Retourner NotImplemented dans les fonction de comparaison sous-jacentes pour "
"les types non reconnus est maintenant supporté."

#: library/functools.rst:280
msgid ""
"Return a new :ref:`partial object<partial-objects>` which when called will "
"behave like *func* called with the positional arguments *args* and keyword "
"arguments *keywords*. If more arguments are supplied to the call, they are "
"appended to *args*. If additional keyword arguments are supplied, they "
"extend and override *keywords*. Roughly equivalent to::"
msgstr ""
"Retourne un nouvel :ref:`objet partiel <partial-objects>` qui, quand il est "
"appelé, fonctionne comme *func* appelée avec les arguments positionnels "
"*args* et les arguments nommés *keywords*. Si plus d'arguments sont fournis "
"à l'appel, ils sont ajoutés à *args*. Si plus d'arguments nommés sont "
"fournis, ils étendent et surchargent *keywords*. À peu près équivalent à ::"

#: library/functools.rst:296
msgid ""
"The :func:`partial` is used for partial function application which \"freezes"
"\" some portion of a function's arguments and/or keywords resulting in a new "
"object with a simplified signature.  For example, :func:`partial` can be "
"used to create a callable that behaves like the :func:`int` function where "
"the *base* argument defaults to two:"
msgstr ""
":func:`partial` est utilisé pour une application de fonction partielle qui "
"\"gèle\" une portion des arguments et/ou mots-clés d'une fonction donnant un "
"nouvel objet avec une signature simplifiée.  Par exemple, :func:`partial` "
"peut être utilisé pour créer un appelable qui se comporte comme la fonction :"
"func:`int` ou l'argument *base* est deux par défaut :"

#: library/functools.rst:311
msgid ""
"Return a new :class:`partialmethod` descriptor which behaves like :class:"
"`partial` except that it is designed to be used as a method definition "
"rather than being directly callable."
msgstr ""
"Retourne un nouveau descripteur :class:`partialmethod` qui se comporte "
"comme :class:`partial` sauf qu'il est fait pour être utilisé comme une "
"définition de méthode plutôt que d'être appelé directement."

#: library/functools.rst:315
msgid ""
"*func* must be a :term:`descriptor` or a callable (objects which are both, "
"like normal functions, are handled as descriptors)."
msgstr ""
"*func* doit être un :term:`descriptor` ou un appelable (les objets qui sont "
"les deux, comme les fonction normales, sont gérés comme des descripteurs)."

#: library/functools.rst:318
msgid ""
"When *func* is a descriptor (such as a normal Python function, :func:"
"`classmethod`, :func:`staticmethod`, :func:`abstractmethod` or another "
"instance of :class:`partialmethod`), calls to ``__get__`` are delegated to "
"the underlying descriptor, and an appropriate :ref:`partial object<partial-"
"objects>` returned as the result."
msgstr ""
"Quand *func* est un descripteur (comme une fonction Python normale, :func:"
"`classmethod`, :func:`staticmethod`, :func:`abstractmethod` ou une autre "
"instance de :class:`partialmethod`), les appels à ``__get__`` sont délégués "
"au descripteur sous-jacent, et un :ref:`objet partiel <partial-objects>` "
"approprié est renvoyé comme résultat."

#: library/functools.rst:324
msgid ""
"When *func* is a non-descriptor callable, an appropriate bound method is "
"created dynamically. This behaves like a normal Python function when used as "
"a method: the *self* argument will be inserted as the first positional "
"argument, even before the *args* and *keywords* supplied to the :class:"
"`partialmethod` constructor."
msgstr ""
"Quand *func* est un appelable non-descripteur, une méthode liée appropriée "
"est crée dynamiquement. Elle se comporte comme une fonction Python normale "
"quand elle est utilisée comme méthode : l'argument *self* sera inséré comme "
"premier argument positionnel, avant les *args* et *keywords* fournis au "
"constructeur :class:`partialmethod`."

#: library/functools.rst:355
#, fuzzy
msgid ""
"Apply *function* of two arguments cumulatively to the items of *iterable*, "
"from left to right, so as to reduce the iterable to a single value.  For "
"example, ``reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])`` calculates "
"``((((1+2)+3)+4)+5)``. The left argument, *x*, is the accumulated value and "
"the right argument, *y*, is the update value from the *iterable*.  If the "
"optional *initializer* is present, it is placed before the items of the "
"iterable in the calculation, and serves as a default when the iterable is "
"empty.  If *initializer* is not given and *iterable* contains only one item, "
"the first item is returned."
msgstr ""
"Applique *function* avec deux arguments cumulativement aux éléments de "
"*sequence*, de gauche à droite, pour réduire la séquence à une valeur "
"unique.  Par exemple, ``reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])`` calcule "
"``((((1+2)+3)+4)+5)``. Le premier argument, *x*, et la valeur de cumul et le "
"deuxième, *y*, est la valeur de mise à jour depuis *sequence*.  Si "
"l'argument optionnel *initializer* est présent, il est placé avant les "
"éléments de la séquence dans le calcul, et sert de valeur par défaut quand "
"la séquence est vide.  Si *initializer* n'est pas renseigné et que "
"*sequence* ne contient qu'un élément, le premier élément est retourné."

#: library/functools.rst:364
msgid "Roughly equivalent to::"
msgstr "Sensiblement équivalent à ::"

#: library/functools.rst:376
msgid ""
"See :func:`itertools.accumulate` for an iterator that yields all "
"intermediate values."
msgstr ""

#: library/functools.rst:381
msgid ""
"Transform a function into a :term:`single-dispatch <single dispatch>` :term:"
"`generic function`."
msgstr ""
"Transforme une fonction en une :term:`fonction générique <generic "
"function>` :term:`single-dispatch <single dispatch>`."

#: library/functools.rst:384
msgid ""
"To define a generic function, decorate it with the ``@singledispatch`` "
"decorator. Note that the dispatch happens on the type of the first argument, "
"create your function accordingly::"
msgstr ""
"Pour définir une fonction générique, il faut la décorer avec le décorateur "
"``@singledispatch``. Noter que la distribution est effectuée sur le type du "
"premier argument, donc la fonction doit être créée en conséquence ::"

#: library/functools.rst:395
msgid ""
"To add overloaded implementations to the function, use the :func:`register` "
"attribute of the generic function.  It is a decorator.  For functions "
"annotated with types, the decorator will infer the type of the first "
"argument automatically::"
msgstr ""
"Pour ajouter des surcharges d'implémentation à la fonction, utiliser "
"l'attribut :func:`register` de la fonction générique.  C'est un décorateur.  "
"Pour les fonctions annotées avec des types, le décorateur infère le type du "
"premier argument automatiquement ::"

#: library/functools.rst:413
msgid ""
"For code which doesn't use type annotations, the appropriate type argument "
"can be passed explicitly to the decorator itself::"
msgstr ""
"Pour le code qui n’utilise pas les indications de type, le type souhaité "
"peut être passé explicitement en argument au décorateur ::"

#: library/functools.rst:424
msgid ""
"To enable registering lambdas and pre-existing functions, the :func:"
"`register` attribute can be used in a functional form::"
msgstr ""
"Pour permettre l'enregistrement de *lambdas* et de fonctions pré-existantes, "
"l'attribut :func:`register` peut être utilisé sous forme fonctionnelle ::"

#: library/functools.rst:432
msgid ""
"The :func:`register` attribute returns the undecorated function which "
"enables decorator stacking, pickling, as well as creating unit tests for "
"each variant independently::"
msgstr ""
"L'attribut :func:`register` renvoie la fonction non décorée ce qui permet "
"d'empiler les décorateurs, la sérialisation, et la création de tests "
"unitaires pour chaque variante indépendamment ::"

#: library/functools.rst:446
msgid ""
"When called, the generic function dispatches on the type of the first "
"argument::"
msgstr ""
"Quand elle est appelée, la fonction générique distribue sur le type du "
"premier argument ::"

#: library/functools.rst:466
msgid ""
"Where there is no registered implementation for a specific type, its method "
"resolution order is used to find a more generic implementation. The original "
"function decorated with ``@singledispatch`` is registered for the base "
"``object`` type, which means it is used if no better implementation is found."
msgstr ""
"Quand il n'y a pas d'implémentation enregistrée pour un type spécifique, son "
"ordre de résolution de méthode est utilisé pour trouver une implémentation "
"plus générique. La fonction originale est décorée avec ``@singledispatch`` "
"est enregistrée pour le type d'``object``, et elle sera utilisée si aucune "
"implémentation n'est trouvée."

#: library/functools.rst:472
msgid ""
"If an implementation registered to :term:`abstract base class`, virtual "
"subclasses will be dispatched to that implementation::"
msgstr ""

#: library/functools.rst:486
msgid ""
"To check which implementation will the generic function choose for a given "
"type, use the ``dispatch()`` attribute::"
msgstr ""
"Pour vérifier quelle implémentation la fonction générique choisira pour un "
"type donné, utiliser l'attribut ``dispatch()`` ::"

#: library/functools.rst:494
msgid ""
"To access all registered implementations, use the read-only ``registry`` "
"attribute::"
msgstr ""
"Pour accéder à toutes les implémentations enregistrées, utiliser l'attribut "
"en lecture seule ``registry`` ::"

#: library/functools.rst:508
msgid "The :func:`register` attribute supports using type annotations."
msgstr ""
"L’attribut :func:`register` gère l’utilisation des indications de type."

#: library/functools.rst:514
#, fuzzy
msgid ""
"Transform a method into a :term:`single-dispatch <single dispatch>` :term:"
"`generic function`."
msgstr ""
"Transforme une fonction en une :term:`fonction générique <generic "
"function>` :term:`single-dispatch <single dispatch>`."

#: library/functools.rst:517
#, fuzzy
msgid ""
"To define a generic method, decorate it with the ``@singledispatchmethod`` "
"decorator. Note that the dispatch happens on the type of the first non-self "
"or non-cls argument, create your function accordingly::"
msgstr ""
"Pour définir une fonction générique, il faut la décorer avec le décorateur "
"``@singledispatch``. Noter que la distribution est effectuée sur le type du "
"premier argument, donc la fonction doit être créée en conséquence ::"

#: library/functools.rst:534
msgid ""
"``@singledispatchmethod`` supports nesting with other decorators such as "
"``@classmethod``. Note that to allow for ``dispatcher.register``, "
"``singledispatchmethod`` must be the *outer most* decorator. Here is the "
"``Negator`` class with the ``neg`` methods being class bound::"
msgstr ""

#: library/functools.rst:555
msgid ""
"The same pattern can be used for other similar decorators: ``staticmethod``, "
"``abstractmethod``, and others."
msgstr ""

#: library/functools.rst:563
msgid ""
"Update a *wrapper* function to look like the *wrapped* function. The "
"optional arguments are tuples to specify which attributes of the original "
"function are assigned directly to the matching attributes on the wrapper "
"function and which attributes of the wrapper function are updated with the "
"corresponding attributes from the original function. The default values for "
"these arguments are the module level constants ``WRAPPER_ASSIGNMENTS`` "
"(which assigns to the wrapper function's ``__module__``, ``__name__``, "
"``__qualname__``, ``__annotations__`` and ``__doc__``, the documentation "
"string) and ``WRAPPER_UPDATES`` (which updates the wrapper function's "
"``__dict__``, i.e. the instance dictionary)."
msgstr ""
"Met à jour la fonction *wrapper* pour ressembler à la fonction *wrapped*. "
"Les arguments optionnels sont des *n*-uplets pour spécifier quels attributs "
"de la fonction originale sont assignés directement aux attributs "
"correspondants sur la fonction englobante et quels attributs de la fonction "
"englobante sont mis à jour avec les attributs de la fonction originale. Les "
"valeurs par défaut de ces arguments sont les constantes au niveau du module "
"``WRAPPER_ASSIGNMENTS`` (qui assigne ``__module__``, ``__name__``, "
"``__qualname__``, ``__annotations__`` et ``__doc__``, la chaîne de "
"documentation, depuis la fonction englobante) et ``WRAPPER_UPDATES`` (qui "
"met à jour le ``__dict__`` de la fonction englobante, c'est-à-dire le "
"dictionnaire de l'instance)."

#: library/functools.rst:573
msgid ""
"To allow access to the original function for introspection and other "
"purposes (e.g. bypassing a caching decorator such as :func:`lru_cache`), "
"this function automatically adds a ``__wrapped__`` attribute to the wrapper "
"that refers to the function being wrapped."
msgstr ""
"Pour autoriser l'accès à la fonction originale pour l'introspection ou à "
"d'autres fins (par ex. outrepasser l'accès à un décorateur de cache comme :"
"func:`lru_cache`), cette fonction ajoute automatiquement un attribut "
"``__wrapped__`` qui référence la fonction englobée."

#: library/functools.rst:578
msgid ""
"The main intended use for this function is in :term:`decorator` functions "
"which wrap the decorated function and return the wrapper. If the wrapper "
"function is not updated, the metadata of the returned function will reflect "
"the wrapper definition rather than the original function definition, which "
"is typically less than helpful."
msgstr ""
"La principale utilisation de cette fonction est dans les :term:`décorateurs "
"<decorator>` qui renvoient une nouvelle fonction. Si la fonction crée n'est "
"pas mise à jour, ses métadonnées refléteront sa définition dans le "
"décorateur, au lieu de la définition originale, métadonnées souvent bien "
"moins utiles."

#: library/functools.rst:584
msgid ""
":func:`update_wrapper` may be used with callables other than functions. Any "
"attributes named in *assigned* or *updated* that are missing from the object "
"being wrapped are ignored (i.e. this function will not attempt to set them "
"on the wrapper function). :exc:`AttributeError` is still raised if the "
"wrapper function itself is missing any attributes named in *updated*."
msgstr ""
":func:`update_wrapper` peut être utilisé avec des appelables autres que des "
"fonctions. Tout attribut défini dans *assigned* ou *updated* qui ne sont pas "
"l'objet englobé sont ignorés (cette fonction n'essaiera pas de les définir "
"dans la fonction englobante). :exc:`AttributeError` est toujours levée si le "
"fonction englobante elle même a des attributs non existants dans *updated*."

#: library/functools.rst:590
msgid "Automatic addition of the ``__wrapped__`` attribute."
msgstr "Ajout automatique de l'attribut ``__wrapped__``."

#: library/functools.rst:593
msgid "Copying of the ``__annotations__`` attribute by default."
msgstr "Copie de l'attribut ``__annotations__`` par défaut."

#: library/functools.rst:596
msgid "Missing attributes no longer trigger an :exc:`AttributeError`."
msgstr ""
"Les attributs manquants ne lèvent plus d'exception :exc:`AttributeError`."

#: library/functools.rst:599
msgid ""
"The ``__wrapped__`` attribute now always refers to the wrapped function, "
"even if that function defined a ``__wrapped__`` attribute. (see :issue:"
"`17482`)"
msgstr ""
"L'attribut ``__wrapped__`` renvoie toujours la fonction englobée, même si "
"cette fonction définit un attribut ``__wrapped__``. (voir :issue:`17482`)"

#: library/functools.rst:607
msgid ""
"This is a convenience function for invoking :func:`update_wrapper` as a "
"function decorator when defining a wrapper function.  It is equivalent to "
"``partial(update_wrapper, wrapped=wrapped, assigned=assigned, "
"updated=updated)``. For example::"
msgstr ""
"Ceci est une fonction d'aide pour appeler :func:`update_wrapper`  comme "
"décorateur de fonction lors de la définition d'une fonction englobante.  "
"C'est équivalent à  ``partial(update_wrapper, wrapped=wrapped, "
"assigned=assigned, updated=updated)``. Par exemple ::"

#: library/functools.rst:633
msgid ""
"Without the use of this decorator factory, the name of the example function "
"would have been ``'wrapper'``, and the docstring of the original :func:"
"`example` would have been lost."
msgstr ""
"Sans l'utilisation de cette usine à décorateur, le nom de la fonction "
"d'exemple aurait été ``'wrapper'``, et la chaîne de documentation de la "
"fonction :func:`example` originale aurait été perdue."

#: library/functools.rst:641
msgid ":class:`partial` Objects"
msgstr "Objets :class:`partial`"

#: library/functools.rst:643
msgid ""
":class:`partial` objects are callable objects created by :func:`partial`. "
"They have three read-only attributes:"
msgstr ""
"Les objets :class:`partial` sont des objets appelables créés par :func:"
"`partial`. Ils ont trois attributs en lecture seule :"

#: library/functools.rst:649
msgid ""
"A callable object or function.  Calls to the :class:`partial` object will be "
"forwarded to :attr:`func` with new arguments and keywords."
msgstr ""
"Un objet ou une fonction appelable.  Les appels à l'objet :class:`partial` "
"seront transmis à :attr:`func` avec les nouveaux arguments et mots-clés."

#: library/functools.rst:655
msgid ""
"The leftmost positional arguments that will be prepended to the positional "
"arguments provided to a :class:`partial` object call."
msgstr ""
"Les arguments positionnels qui seront ajoutés avant les arguments fournis "
"lors de l'appel d'un objet :class:`partial`."

#: library/functools.rst:661
msgid ""
"The keyword arguments that will be supplied when the :class:`partial` object "
"is called."
msgstr ""
"Les arguments nommés qui seront fournis quand l'objet :class:`partial` est "
"appelé."

#: library/functools.rst:664
msgid ""
":class:`partial` objects are like :class:`function` objects in that they are "
"callable, weak referencable, and can have attributes.  There are some "
"important differences.  For instance, the :attr:`~definition.__name__` and :"
"attr:`__doc__` attributes are not created automatically.  Also, :class:"
"`partial` objects defined in classes behave like static methods and do not "
"transform into bound methods during instance attribute look-up."
msgstr ""
"Les objets :class:`partial` sont comme des objets :class:`function` de par "
"le fait qu'il sont appelables, référençables, et peuvent avoir des "
"attributs.  Il y a cependant des différences importantes.  Par exemple, les "
"attributs :attr:`~definition.__name__` et :attr:`__doc__` ne sont pas créés "
"automatiquement.  De plus, les objets :class:`partial` définis dans les "
"classes se comportent comme des méthodes statiques et ne se transforment pas "
"en méthodes liées durant la recherche d'attributs dans l'instance."