From 2fd8387137fe472703f633a9e389957edffa6a73 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Tue, 4 Apr 2023 21:24:32 +0000 Subject: [PATCH] library/functions.po : fuzzies et fin de revue (#104) Co-authored-by: Christophe Nanteuil Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/104 Reviewed-by: Julien Palard Co-authored-by: Christophe Nanteuil Co-committed-by: Christophe Nanteuil --- dict | 1 + library/functions.po | 506 +++++++++++++++++++++++++------------------ 2 files changed, 294 insertions(+), 213 deletions(-) diff --git a/dict b/dict index 883c1b77..9007dd24 100644 --- a/dict +++ b/dict @@ -4,6 +4,7 @@ -uplet -uplets 017f +1-uplet 212a abi ahlstrom diff --git a/library/functions.po b/library/functions.po index e3a5d4dd..54a238c7 100644 --- a/library/functions.po +++ b/library/functions.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-01-15 22:33+0100\n" -"PO-Revision-Date: 2023-03-22 10:14+0100\n" +"PO-Revision-Date: 2023-04-03 23:10+0200\n" "Last-Translator: Antoine Wecxsteen\n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -481,10 +481,10 @@ msgid "" "object, it has to define an :meth:`__index__` method that returns an " "integer. Some examples:" msgstr "" -"Convertit un nombre entier en binaire dans une chaîne avec le préfixe " -"``\"0b\"``. Le résultat est une expression Python valide. Si *x* n'est pas " -"un :class:`int`, il doit définir une méthode :meth:`__index__` donnant un " -"nombre entier. Voici quelques exemples :" +"Convertit un nombre entier en binaire dans une chaîne avec le préfixe ``\"0b" +"\"``. Le résultat est une expression Python valide. Si *x* n'est pas un :" +"class:`int`, il doit définir une méthode :meth:`__index__` donnant un nombre " +"entier. Voici quelques exemples :" #: library/functions.rst:133 msgid "" @@ -559,8 +559,8 @@ msgid "" "as most methods that the :class:`bytes` type has, see :ref:`bytes-methods`." msgstr "" "Renvoie un nouveau tableau d'octets. La classe :class:`bytearray` est une " -"séquence muable de nombres entiers dans l'intervalle 0 <= x < 256. Il " -"possède la plupart des méthodes des séquences variables, décrites dans :ref:" +"séquence muable de nombres entiers dans l'intervalle 0 ≤ x < 256. Il possède " +"la plupart des méthodes des séquences variables, décrites dans :ref:" "`typesseq-mutable`, ainsi que la plupart des méthodes de la classe :class:" "`bytes`, voir :ref:`bytes-methods`." @@ -572,6 +572,7 @@ msgstr "" "Le paramètre optionnel *source* peut être utilisé pour initialiser le " "tableau de plusieurs façons :" +# énumération #: library/functions.rst:189 msgid "" "If it is a *string*, you must also give the *encoding* (and optionally, " @@ -753,7 +754,7 @@ msgid "" "``__name__``, ``__qualname__``, ``__doc__`` and ``__annotations__``) and " "have a new ``__wrapped__`` attribute." msgstr "" -"les méthodes de classe peuvent maintenant hériter des attributs des méthodes " +"les méthodes de classe héritent dorénavant des attributs des méthodes " "(``__module__``, ``__name__``, ``__qualname__``, ``__doc__`` et " "``__annotations__``) et ont un nouvel attribut ``__wrapped__``." @@ -1296,7 +1297,7 @@ msgstr "" "Cette fonction permet l'exécution dynamique de code Python. *object* doit " "être soit une chaîne soit un objet code. Si c'est une chaîne, elle est " "d'abord analysée en une suite d'instructions Python qui sont ensuite " -"exécutés (sauf erreur de syntaxe). [#]_ Si c'est un objet code, il est " +"exécutés (sauf erreur de syntaxe) [#]_. Si c'est un objet code, il est " "simplement exécuté. Dans tous les cas, le code fourni doit être valide selon " "les mêmes critères que s'il était un script dans un fichier (voir la " "section :ref:`Fichier d'entrée ` dans le manuel de référence du " @@ -1379,6 +1380,7 @@ msgstr "" "observer l'effet du code sur les variables locales, après que :func:`exec` " "soit terminée." +# suit un : #: library/functions.rst:618 msgid "Added the *closure* parameter." msgstr "ajout du paramètre *closure*." @@ -1444,14 +1446,14 @@ msgstr "" #: library/functions.rst:665 msgid "" "Here ``digit`` is a Unicode decimal digit (character in the Unicode general " -"category ``Nd``). Case is not significant, so, for example, \"inf\", " -"\"Inf\", \"INFINITY\", and \"iNfINity\" are all acceptable spellings for " -"positive infinity." +"category ``Nd``). Case is not significant, so, for example, \"inf\", \"Inf" +"\", \"INFINITY\", and \"iNfINity\" are all acceptable spellings for positive " +"infinity." msgstr "" "Ici ``digit`` est un chiffre décimal Unicode (caractère de la catégorie " "générale Unicode ``Nd``). La casse n'y est pas significative, donc, par " -"exemple, ``\"inf\"``, ``\" Inf\"``, ``\"INFINITY\"`` et ``\" iNfiNity\"`` " -"sont tous des orthographes valides pour un infini positif." +"exemple, ``\"inf\"``, ``\"Inf\"``, ``\"INFINITY\"`` et ``\"iNfiNity\"`` sont " +"toutes des orthographes valides pour un infini positif." #: library/functions.rst:670 msgid "" @@ -1814,6 +1816,12 @@ msgid "" "(with no space in between), have leading zeros, be surrounded by whitespace, " "and have single underscores interspersed between digits." msgstr "" +"Si *x* n'est pas un nombre ou si *base* est fournie, alors *x* doit être une " +"chaîne, une instance :class:`bytes` ou une instance :class:`bytearray` " +"représentant un entier dans la base *base*. Facultativement, la chaîne peut " +"être précédée de ``+`` ou ``-`` (sans espace qui suit), avoir des zéros non " +"significatifs, être entourée de caractères d'espacement et avoir des tirets " +"bas (un seul à la fois) intercalés entre les chiffres." #: library/functions.rst:900 msgid "" @@ -1845,6 +1853,7 @@ msgstr "" msgid "The integer type is described in :ref:`typesnumeric`." msgstr "Le type des entiers est décrit dans :ref:`typesnumeric`." +# suit un : #: library/functions.rst:913 msgid "" "If *base* is not an instance of :class:`int` and the *base* object has a :" @@ -1862,9 +1871,10 @@ msgstr "" msgid "Falls back to :meth:`__index__` if :meth:`__int__` is not defined." msgstr "Revient à :meth:`__index__` si :meth:`__int__` n'est pas définie." +# suit un : #: library/functions.rst:929 msgid "The delegation to :meth:`__trunc__` is deprecated." -msgstr "" +msgstr "le repli vers :meth:`__trunc__` est obsolète." #: library/functions.rst:932 msgid "" @@ -1875,9 +1885,15 @@ msgid "" "ref:`integer string conversion length limitation ` " "documentation." msgstr "" +"les chaînes données à :class:`int` et les représentations de chaîne peuvent " +"être limitées pour aider à éviter les attaques par déni de service. Une :exc:" +"`ValueError` est levée lorsque la limite est dépassée lors de la conversion " +"d'une chaîne *x* en un :class:`int` ou lorsque la conversion d'un :class:" +"`int` en une chaîne dépasserait la limite. Voir la documentation relative à " +"la :ref:`limites de longueur lors de la conversion de chaînes en entiers " +"`." #: library/functions.rst:942 -#, fuzzy msgid "" "Return ``True`` if the *object* argument is an instance of the *classinfo* " "argument, or of a (direct, indirect, or :term:`virtual `. Si *object* n'est pas un objet du type donné, la fonction renvoie " "toujours ``False``. Si *classinfo* est un *n*-uplet de types (ou " -"récursivement, d'autres *n*-uplets), renvoie ``True`` si *object* est une " -"instance de n'importe quel de ces types. Si *classinfo* n'est ni un type ni " -"un *n*-uplet de types (et récursivement), une exception :exc:`TypeError` est " -"levée." +"récursivement, d'autres *n*-uplets) ou une :ref:`union de types ` différents, renvoie ``True`` si *object* est une instance de " +"n'importe quel de ces types. Si *classinfo* n'est ni un type ni un *n*-uplet " +"de types (et récursivement), une exception :exc:`TypeError` est levée. :exc:" +"`TypeError` ne peut pas être levée pour un type invalide si une des " +"vérifications précédentes réussit." #: library/functions.rst:967 msgid "*classinfo* can be a :ref:`types-union`." -msgstr "" +msgstr "*classinfo* peut être une :ref:`union de types `." #: library/functions.rst:959 -#, fuzzy msgid "" "Return ``True`` if *class* is a subclass (direct, indirect, or :term:" "`virtual `) of *classinfo*. A class is considered a " @@ -1915,11 +1932,12 @@ msgstr "" "Renvoie ``True`` si *class* est une classe fille (directe, indirecte ou :" "term:`abstraite `) de *classinfo*. Une classe est " "considérée sous-classe d'elle-même. *classinfo* peut être un *n*-uplet de " -"classes, dans ce cas la vérification sera faite pour chaque classe de " -"*classinfo*. Dans tous les autres cas, :exc:`TypeError` est levée." +"classes (ou récursivement, d'autres *n*-uplets) ou une :ref:`union de types " +"`, dans ce cas elle renvoie ``True`` si *class* est une sous-" +"classe d'une partie de *classinfo*. Dans tous les autres cas, une :exc:" +"`TypeError` est levée." #: library/functions.rst:974 -#, fuzzy msgid "" "Return an :term:`iterator` object. The first argument is interpreted very " "differently depending on the presence of the second argument. Without a " @@ -1935,14 +1953,15 @@ msgid "" msgstr "" "Renvoie un objet :term:`itérateur `. La signification du premier " "argument dépend grandement de la présence du second. Sans cet argument, " -"*object* doit être une collection d'objets prenant en charge le protocole " -"d'itération (la méthode :meth:`__iter__`) ou le protocole des séquences (la " -"méthode :meth:`getitem`, avec des nombres entiers commençant par ``0`` comme " -"argument). S'il ne gère aucun de ces protocoles, :exc:`TypeError` est levée. " -"Si le second argument *sentinel* est fourni, *object* doit être appelable. " -"L'itérateur créé dans ce cas appelle *object* sans argument à chaque appel " -"de :meth:`~iterator.__next__`. Si la valeur reçue est égale à *sentinel* :" -"exc:`StopIteration` est levée, sinon la valeur est renvoyée." +"*object* doit être une collection d'objets prenant en charge le protocole d':" +"term:`itération ` (la méthode :meth:`__iter__`) ou le protocole " +"des séquences (la méthode :meth:`__getitem__`, avec des nombres entiers " +"commençant par ``0`` comme argument). S'il ne gère aucun de ces protocoles, " +"une :exc:`TypeError` est levée. Si le second argument *sentinel* est fourni, " +"*object* doit être appelable. L'itérateur créé dans ce cas appelle *object* " +"sans argument à chaque appel de :meth:`~iterator.__next__`. Si la valeur " +"reçue est égale à *sentinel*, une :exc:`StopIteration` est levée, sinon la " +"valeur est renvoyée." #: library/functions.rst:987 msgid "See also :ref:`typeiter`." @@ -1974,6 +1993,8 @@ msgid "" "``len`` raises :exc:`OverflowError` on lengths larger than :data:`sys." "maxsize`, such as :class:`range(2 ** 100) `." msgstr "" +"``len`` lève une :exc:`OverflowError` sur des longueurs supérieures à :data:" +"`sys.maxsize`, par exemple pour :class:`range(2 ** 100) `." #: library/functions.rst:1016 msgid "" @@ -2002,12 +2023,11 @@ msgid "" "The contents of this dictionary should not be modified; changes may not " "affect the values of local and free variables used by the interpreter." msgstr "" -"Le contenu de ce dictionnaire ne doit pas être modifié ; les changements " +"Le contenu de ce dictionnaire ne doit pas être modifié ; les changements " "n'affectent pas les valeurs des variables locales ou libres utilisées par " "l'interpréteur." #: library/functions.rst:1033 -#, fuzzy msgid "" "Return an iterator that applies *function* to every item of *iterable*, " "yielding the results. If additional *iterables* arguments are passed, " @@ -2018,7 +2038,7 @@ msgid "" msgstr "" "Renvoie un itérateur appliquant *function* à chaque élément de *iterable*, " "et donnant ses résultats au fur et à mesure avec ``yield``. Si d'autres " -"*iterable* sont fournis, *function* doit prendre autant d'arguments, et sera " +"*iterables* sont fournis, *function* doit prendre autant d'arguments, et est " "appelée avec les éléments de tous les itérables en parallèle. Avec plusieurs " "itérables, l'itération s'arrête avec l'itérable le plus court. Pour les cas " "où les arguments sont déjà rangés sous forme de *n*-uplets, voir :func:" @@ -2069,10 +2089,12 @@ msgstr "" "stabilité lors du tri, tels que ``sorted(iterable, key=keyfunc, reverse=True)" "[0]`` et ``heapq.nlargest(1, iterable, key=keyfunc)``." +# suit un : #: library/functions.rst:1102 msgid "The *default* keyword-only argument." -msgstr "L'argument nommé (et seulement donné par son nom) *default*." +msgstr "l'argument nommé (et seulement donné par son nom) *default*." +# suit un : #: library/functions.rst:1105 msgid "The *key* can be ``None``." msgstr "l'argument *key* peut être ``None``." @@ -2116,26 +2138,24 @@ msgstr "" "nsmallest(1, iterable, key=keyfunc)``." #: library/functions.rst:1112 -#, fuzzy msgid "" "Retrieve the next item from the :term:`iterator` by calling its :meth:" "`~iterator.__next__` method. If *default* is given, it is returned if the " "iterator is exhausted, otherwise :exc:`StopIteration` is raised." msgstr "" -"Donne l'élément suivant d'*iterator* en appelant sa méthode :meth:`~iterator." -"__next__`. Si *default* est fourni, il sera renvoyé si l'itérateur est " -"épuisé, sinon :exc:`StopIteration` est levée." +"Donne l'élément suivant de l':term:`itérateur ` en appelant sa " +"méthode :meth:`~iterator.__next__`. Si *default* est fourni, il est renvoyé " +"quand l'itérateur est épuisé, sinon une :exc:`StopIteration` est levée." #: library/functions.rst:1119 -#, fuzzy msgid "" "Return a new featureless object. :class:`object` is a base for all classes. " "It has methods that are common to all instances of Python classes. This " "function does not accept any arguments." msgstr "" "Renvoie un objet vide. :class:`object` est la classe parente de toutes les " -"classes. C'est elle qui porte les méthodes communes à toutes les instances " -"de classes en Python. Cette fonction n'accepte aucun argument." +"classes. Elle possède des méthodes communes à toutes les instances de " +"classes en Python. Cette fonction n'accepte aucun argument." #: library/functions.rst:1125 msgid "" @@ -2159,13 +2179,12 @@ msgstr "" "un entier, par exemple :" #: library/functions.rst:1141 -#, fuzzy msgid "" "If you want to convert an integer number to an octal string either with the " "prefix \"0o\" or not, you can use either of the following ways." msgstr "" -"Si vous voulez convertir un nombre entier en chaîne octale, avec ou sans le " -"préfixe ``0o``, vous pouvez utiliser l'une des méthodes suivantes." +"Si vous voulez convertir un nombre entier en une chaîne octale, avec ou sans " +"le préfixe ``0o``, vous pouvez utiliser l'une des méthodes suivantes." #: library/functions.rst:1158 msgid "" @@ -2175,10 +2194,9 @@ msgid "" msgstr "" "Ouvre *file* et donne un :term:`objet fichier ` correspondant. " "Si le fichier ne peut pas être ouvert, une :exc:`OSError` est levée. Voir :" -"ref:`tut-files` pour plus d'exemple d'utilisation de cette fonction." +"ref:`tut-files` pour plus d'exemples d'utilisation de cette fonction." #: library/functions.rst:1162 -#, fuzzy msgid "" "*file* is a :term:`path-like object` giving the pathname (absolute or " "relative to the current working directory) of the file to be opened or an " @@ -2193,7 +2211,6 @@ msgstr "" "d'entrée-sortie renvoyé, sauf si *closefd* est mis à ``False``)." #: library/functions.rst:1168 -#, fuzzy msgid "" "*mode* is an optional string that specifies the mode in which the file is " "opened. It defaults to ``'r'`` which means open for reading in text mode. " @@ -2214,11 +2231,10 @@ msgstr "" "fichier (ce qui, sur certains systèmes Unix, signifie que *toutes* les " "écritures seront des ajouts en fin de fichier, sans tenir compte de la " "position demandée). En mode texte, si *encoding* n'est pas spécifié, " -"l'encodage utilisé dépend de la plate-forme : ``locale." -"getpreferredencoding(False)`` est appelée pour obtenir l'encodage défini par " -"les paramètres régionaux (pour lire et écrire des octets bruts, utilisez le " -"mode binaire sans préciser *encoding* non spécifié). Les modes disponibles " -"sont :" +"l'encodage utilisé dépend de la plate-forme : :func:`locale.getencoding()` " +"est appelée pour obtenir l'encodage courant défini par les paramètres " +"régionaux (pour lire et écrire des octets bruts, utilisez le mode binaire " +"sans préciser *encoding*). Les modes disponibles sont :" #: library/functions.rst:1185 msgid "Character" @@ -2257,7 +2273,6 @@ msgid "``'a'``" msgstr "``'a'``" #: library/functions.rst:1190 -#, fuzzy msgid "open for writing, appending to the end of file if it exists" msgstr "ouvre en écriture, ajoutant à la fin du fichier s'il existe" @@ -2286,15 +2301,14 @@ msgid "open for updating (reading and writing)" msgstr "ouvre en modification (lecture et écriture)" #: library/functions.rst:1196 -#, fuzzy msgid "" "The default mode is ``'r'`` (open for reading text, a synonym of ``'rt'``). " "Modes ``'w+'`` and ``'w+b'`` open and truncate the file. Modes ``'r+'`` and " "``'r+b'`` open the file with no truncation." msgstr "" -"Le mode par défaut est ``'r'`` (ouverture pour lire du texte, synonyme de " -"``'rt'``). Les modes ``'w+'`` et ``'w+b'`` ouvrent et vident le fichier. Les " -"modes ``'r+'`` et ``'r+b'`` ouvrent le fichier sans le vider." +"Le mode par défaut est ``'r'`` (ouverture pour lire du texte, un synonyme " +"pour ``'rt'``). Les modes ``'w+'`` et ``'w+b'`` ouvrent et vident le " +"fichier. Les modes ``'r+'`` et ``'r+b'`` ouvrent le fichier sans le vider." #: library/functions.rst:1200 msgid "" @@ -2325,7 +2339,6 @@ msgstr "" "indépendant de la plate-forme." #: library/functions.rst:1214 -#, fuzzy msgid "" "*buffering* is an optional integer used to set the buffering policy. Pass 0 " "to switch buffering off (only allowed in binary mode), 1 to select line " @@ -2339,11 +2352,17 @@ msgid "" msgstr "" "*buffering* est un entier optionnel permettant de configurer l'espace " "tampon. 0 pour désactiver l'espace tampon (seulement autorisé en mode " -"binaire), 1 pour avoir un *buffer* travaillant ligne par ligne (seulement " +"binaire), 1 pour avoir un tampon travaillant ligne par ligne (seulement " "disponible en mode texte), ou un entier supérieur à 1 pour donner la taille " -"en octets d'un tampon de taille fixe. Sans l'argument *buffering*, les " -"comportements par défaut sont les suivants :" +"en octets d'un tampon de taille fixe. Notez que spécifier une taille de " +"tampon de cette manière s'applique aux entrées-sorties binaires avec tampon, " +"mais que ``TextIOWrapper`` (c'est-à-dire, les fichiers ouverts avec ``mode='r" +"+'``) a un autre tampon. Pour désactiver la mise en mémoire tampon dans " +"``TextIOWrapper``, utilisez le drapeau ``write_through`` de :func:`io." +"TextIOWrapper.reconfigure`. Sans l'argument *buffering*, les comportements " +"par défaut sont les suivants :" +# énumération #: library/functions.rst:1224 msgid "" "Binary files are buffered in fixed-size chunks; the size of the buffer is " @@ -2351,24 +2370,24 @@ msgid "" "size\" and falling back on :attr:`io.DEFAULT_BUFFER_SIZE`. On many systems, " "the buffer will typically be 4096 or 8192 bytes long." msgstr "" -"Les fichiers binaires sont mis dans un tampon de taille fixe, dont la taille " +"les fichiers binaires sont mis dans un tampon de taille fixe, dont la taille " "est choisie par une heuristique essayant de déterminer la taille des blocs " "du système sous-jacent, ou en utilisant par défaut :attr:`io." -"DEFAULT_BUFFER_SIZE`. Sur de nombreux systèmes, le tampon sera de 4096 ou " -"8192 octets." +"DEFAULT_BUFFER_SIZE`. Sur de nombreux systèmes, le tampon est de 4096 ou " +"8192 octets ;" +# fin d'énumération #: library/functions.rst:1229 msgid "" "\"Interactive\" text files (files for which :meth:`~io.IOBase.isatty` " "returns ``True``) use line buffering. Other text files use the policy " "described above for binary files." msgstr "" -"Les fichiers texte « interactifs » (fichiers pour lesquels :meth:`io.IOBase." -"isatty` renvoie ``True``) utilisent un tampon par lignes. Les autres " -"fichiers texte sont traités comme les fichiers binaires." +"les fichiers texte « interactifs » (fichiers pour lesquels :meth:`io.IOBase." +"isatty` renvoie ``True``) utilisent un tampon ligne par ligne. Les autres " +"fichiers textes sont traités comme les fichiers binaires." #: library/functions.rst:1233 -#, fuzzy msgid "" "*encoding* is the name of the encoding used to decode or encode the file. " "This should only be used in text mode. The default encoding is platform " @@ -2378,10 +2397,10 @@ msgid "" msgstr "" "*encoding* est le nom de l'encodage utilisé pour encoder ou décoder le " "fichier. Il doit seulement être utilisé en mode texte. L'encodage par défaut " -"dépend de la plateforme (ce que :func:`locale.getpreferredencoding` donne), " -"mais n'importe quel :term:`encodage de texte ` pris en charge " -"par Python peut être utilisé. Voir :mod:`codecs` pour une liste des " -"encodages pris en charge." +"dépend de la plateforme (ce que renvoie :func:`locale.getencoding`), mais " +"n'importe quel :term:`encodage de texte ` pris en charge par " +"Python peut être utilisé. Voir :mod:`codecs` pour une liste des encodages " +"pris en charge." #: library/functions.rst:1239 msgid "" @@ -2423,7 +2442,6 @@ msgstr "" "des données mal formées." #: library/functions.rst:1257 -#, fuzzy msgid "" "``'surrogateescape'`` will represent any incorrect bytes as low surrogate " "code units ranging from U+DC80 to U+DCFF. These surrogate code units will " @@ -2431,12 +2449,12 @@ msgid "" "handler is used when writing data. This is useful for processing files in " "an unknown encoding." msgstr "" -"``'surrogateescape'`` représente chaque octet incorrect par un code " -"caractère de la zone *Private Use Area* d'Unicode, de *U+DC80* à *U+DCFF*. " -"Ces codes caractères privés seront ensuite transformés dans les mêmes octets " -"erronés si le gestionnaire d'erreur ``surrogateescape`` est utilisé lors de " -"l'écriture de la donnée. C'est utile pour traiter des fichiers d'un encodage " -"inconnu." +"``'surrogateescape'`` représentera tous les octets incorrects comme des " +"points de code de substitution de l'intervalle bas U+DC80 à U+DCFF. Ces " +"points de code de substitution sont ensuite retransformés dans les mêmes " +"octets lorsque le gestionnaire d'erreurs ``surrogateescape`` est utilisé " +"pour l'écriture des données. C'est utile pour traiter des fichiers d'un " +"encodage inconnu." #: library/functions.rst:1264 msgid "" @@ -2465,14 +2483,12 @@ msgstr "" "caractères non gérés par des séquences d'échappement ``\\N{...}``." #: library/functions.rst:1279 -#, fuzzy msgid "" "*newline* determines how to parse newline characters from the stream. It can " "be ``None``, ``''``, ``'\\n'``, ``'\\r'``, and ``'\\r\\n'``. It works as " "follows:" msgstr "" -"*newline* contrôle comment le mode :term:`retours à la ligne universels " -"` fonctionne (seulement en mode texte). Il peut être " +"*newline* contrôle comment interpréter les retours à la ligne. Il peut être " "``None``, ``''``, ``'\\n'``, ``'\\r'``, et ``'\\r\\n'``. Il fonctionne comme " "suit :" @@ -2509,7 +2525,6 @@ msgstr "" "la chaîne donnée." #: library/functions.rst:1297 -#, fuzzy msgid "" "If *closefd* is ``False`` and a file descriptor rather than a filename was " "given, the underlying file descriptor will be kept open when the file is " @@ -2519,7 +2534,7 @@ msgstr "" "Si *closefd* est ``False`` et qu'un descripteur de fichier est fourni plutôt " "qu'un nom de fichier, le descripteur de fichier sera laissé ouvert lorsque " "le fichier sera fermé. Si un nom de fichier est donné, *closefd* doit rester " -"``True`` (la valeur par défaut) sans quoi une erreur est levée." +"``True`` (la valeur par défaut) ; sinon, une erreur est levée." #: library/functions.rst:1302 msgid "" @@ -2538,8 +2553,8 @@ msgstr "" #: library/functions.rst:1308 msgid "The newly created file is :ref:`non-inheritable `." msgstr "" -"Il n'est :ref:`pas possible d'hériter du fichier ` " -"nouvellement créé." +"Il n'est :ref:`pas possible d'hériter du descripteur de fichier " +"` nouvellement créé." #: library/functions.rst:1310 msgid "" @@ -2576,7 +2591,6 @@ msgstr "" "fille de :class:`io.RawIOBase`, :class:`io.FileIO` est renvoyée." #: library/functions.rst:1344 -#, fuzzy msgid "" "See also the file handling modules, such as :mod:`fileinput`, :mod:`io` " "(where :func:`open` is declared), :mod:`os`, :mod:`os.path`, :mod:" @@ -2584,7 +2598,7 @@ msgid "" msgstr "" "Consultez aussi les modules de gestion de fichiers tels que :mod:" "`fileinput`, :mod:`io` (où :func:`open` est déclarée), :mod:`os`, :mod:`os." -"path`, :mod:`tmpfile`, et :mod:`shutil`." +"path`, :mod:`tempfile`, et :mod:`shutil`." #: library/functions.rst:1348 msgid "" @@ -2602,10 +2616,12 @@ msgstr "" "Les arguments ``mode`` et ``flags`` peuvent avoir été modifiés ou déduits de " "l'appel original." +# suit un : #: library/functions.rst:1355 msgid "The *opener* parameter was added." msgstr "ajout du paramètre *opener*." +# suit un : #: library/functions.rst:1356 msgid "The ``'x'`` mode was added." msgstr "ajout du mode ``'x'``." @@ -2638,10 +2654,12 @@ msgstr "" "aucune exception, la fonction réessaye l'appel système au lieu de lever une :" "exc:`InterruptedError` (voir la :pep:`475` pour la justification)." +# suit un : #: library/functions.rst:1370 msgid "The ``'namereplace'`` error handler was added." msgstr "ajout du gestionnaire d'erreurs ``'namereplace'``." +# suit un : #: library/functions.rst:1374 msgid "Support added to accept objects implementing :class:`os.PathLike`." msgstr "prise en charge des objets implémentant :class:`os.PathLike`." @@ -2654,10 +2672,10 @@ msgstr "" "Sous Windows, ouvrir un *buffer* du terminal peut renvoyer une sous-classe " "de :class:`io.RawIOBase` autre que :class:`io.FileIO`." +# suit un : #: library/functions.rst:1378 -#, fuzzy msgid "The ``'U'`` mode has been removed." -msgstr "ajout du mode ``'x'``." +msgstr "le mode ``'U``` a été enlevé." #: library/functions.rst:1383 msgid "" @@ -2669,7 +2687,7 @@ msgstr "" "Renvoie le nombre entier représentant le code Unicode du caractère " "représenté par la chaîne donnée. Par exemple, ``ord('a')`` renvoie le nombre " "entier ``97`` et ``ord('€')`` (symbole euro) renvoie ``8364``. Il s'agit de " -"l'inverse de :func:`chr`." +"la réciproque de :func:`chr`." #: library/functions.rst:1391 msgid "" @@ -2684,7 +2702,6 @@ msgstr "" "équivalente à l'opérateur puissance : ``base**exp``." #: library/functions.rst:1396 -#, fuzzy msgid "" "The arguments must have numeric types. With mixed operand types, the " "coercion rules for binary arithmetic operators apply. For :class:`int` " @@ -2702,7 +2719,10 @@ msgstr "" "`int`, le résultat sera de même type que les opérandes (après coercition) " "sauf si le second argument est négatif, dans ce cas, les arguments sont " "convertis en ``float``, et le résultat sera un ``float`` aussi. Par exemple, " -"``10**2`` donne ``100``, alors que ``10**-2`` donne ``0.01``." +"``pow(10, 2)`` donne ``100``, alors que ``pow(10, -2)`` donne ``0.01``. Pour " +"une base négative de type :class:`int` ou :class:`float` et un exposant non " +"entier, le résultat est complexe. Par exemple, ``pow(-9, 0.5)`` renvoie une " +"valeur proche de ``3j``." #: library/functions.rst:1406 msgid "" @@ -2722,24 +2742,25 @@ msgstr "" msgid "Here's an example of computing an inverse for ``38`` modulo ``97``::" msgstr "Voici un exemple de calcul d'un inverse de ``38`` modulo ``97`` ::" +# suit un : #: library/functions.rst:1419 msgid "" "For :class:`int` operands, the three-argument form of ``pow`` now allows the " "second argument to be negative, permitting computation of modular inverses." msgstr "" -"Pour les opérandes :class:`int`, la forme à trois arguments de ``pow`` " +"pour les opérandes :class:`int`, la forme à trois arguments de ``pow`` " "permet maintenant au deuxième argument d'être négatif, permettant le calcul " "des inverses modulaires." +# suit un : #: library/functions.rst:1424 msgid "" "Allow keyword arguments. Formerly, only positional arguments were supported." msgstr "" -"Autorise les arguments par mots-clés. Auparavant, seuls les arguments " -"positionnels étaient autorisés." +"autorise les arguments nommés. Auparavant, seuls les arguments positionnels " +"étaient autorisés." #: library/functions.rst:1431 -#, fuzzy msgid "" "Print *objects* to the text stream *file*, separated by *sep* and followed " "by *end*. *sep*, *end*, *file*, and *flush*, if present, must be given as " @@ -2747,7 +2768,7 @@ msgid "" msgstr "" "Écrit *objects* dans le flux texte *file*, séparés par *sep* et suivis de " "*end*. Les arguments *sep*, *end*, *file*, et *flush*, s'ils sont présents, " -"doivent être nommés." +"doivent être passés en arguments nommés." #: library/functions.rst:1435 msgid "" @@ -2760,7 +2781,7 @@ msgstr "" "Tous les arguments positionnels sont convertis en chaîne comme le fait :func:" "`str`, puis écrits sur le flux, séparés par *sep* et terminés par *end*. " "*sep* et *end* doivent être des chaînes, ou ``None``, indiquant de prendre " -"les valeurs par défaut. Si aucun *objects* n'est donné :func:`print` écris " +"les valeurs par défaut. Si aucun *objects* n'est donné :func:`print` écrit " "seulement *end*." #: library/functions.rst:1441 @@ -2771,18 +2792,17 @@ msgid "" "binary mode file objects. For these, use ``file.write(...)`` instead." msgstr "" "L'argument *file* doit être un objet avec une méthode ``write(string)`` ; " -"s'il n'est pas fourni, ou vaut ``None``, :data:`sys.stdout` sera utilisé. " +"s'il n'est pas fourni, ou vaut ``None``, :data:`sys.stdout` est utilisé. " "Puisque les arguments affichés sont convertis en chaîne, :func:`print` ne " -"peut pas être utilisé avec des fichiers ouverts en mode binaire. Pour ceux-" +"peut pas être utilisée avec des fichiers ouverts en mode binaire. Pour ceux-" "ci utilisez plutôt ``file.write(...)``." #: library/functions.rst:1446 -#, fuzzy msgid "" "Whether the output is buffered is usually determined by *file*, but if the " "*flush* keyword argument is true, the stream is forcibly flushed." msgstr "" -"Que la sortie utilise un *buffer* ou non est souvent décidé par *file*, mais " +"Que la sortie utilise un tampon ou non est souvent décidé par *file*, mais " "si l'argument *flush* est vrai, le tampon du flux est vidé explicitement." #: library/functions.rst:1449 @@ -2801,15 +2821,14 @@ msgid "" msgstr "" "*fget* est une fonction permettant d'obtenir la valeur d'un attribut. *fset* " "est une fonction pour en définir la valeur. *fdel* quant à elle permet de " -"supprimer la valeur d'un attribut, et *doc* créé une *docstring* pour " -"l'attribut." +"supprimer la valeur d'un attribut, et *doc* crée une chaîne de documentation " +"(*docstring*) pour l'attribut." #: library/functions.rst:1461 msgid "A typical use is to define a managed attribute ``x``::" -msgstr "Une utilisation courante : définir un attribut managé ``x`` ::" +msgstr "Une utilisation courante est de définir un attribut managé ``x`` ::" #: library/functions.rst:1478 -#, fuzzy msgid "" "If *c* is an instance of *C*, ``c.x`` will invoke the getter, ``c.x = " "value`` will invoke the setter, and ``del c.x`` the deleter." @@ -2825,20 +2844,20 @@ msgid "" "possible to create read-only properties easily using :func:`property` as a :" "term:`decorator`::" msgstr "" -"S'il est donné, *doc* sera la *docstring* de l'attribut. Autrement la " -"propriété copiera celle de *fget* (si elle existe). Cela rend possible la " -"création de propriétés en lecture seule en utilisant simplement :func:" -"`property` comme un :term:`décorateur ` ::" +"Si elle est fournie, *doc* est la chaîne de documentation de l'attribut. " +"Autrement la propriété copie celle de *fget* (si elle existe). Cela rend " +"possible la création de propriétés en lecture seule en utilisant simplement :" +"func:`property` comme :term:`décorateur ` ::" #: library/functions.rst:1494 msgid "" -"The ``@property`` decorator turns the :meth:`voltage` method into a " -"\"getter\" for a read-only attribute with the same name, and it sets the " -"docstring for *voltage* to \"Get the current voltage.\"" +"The ``@property`` decorator turns the :meth:`voltage` method into a \"getter" +"\" for a read-only attribute with the same name, and it sets the docstring " +"for *voltage* to \"Get the current voltage.\"" msgstr "" -"Le décorateur ``@property`` transforme la méthode :meth:`voltage` en un " -"*getter* d'un attribut du même nom, et donne *\"Get the current voltage\"* " -"comme *docstring* de *voltage*." +"Le décorateur ``@property`` transforme la méthode :meth:`voltage` en " +"accesseur de l'attribut du même nom, et donne *\"Get the current voltage\"* " +"comme chaîne de documentation de *voltage*." #: library/functions.rst:1498 msgid "" @@ -2867,12 +2886,15 @@ msgid "" "The returned property object also has the attributes ``fget``, ``fset``, and " "``fdel`` corresponding to the constructor arguments." msgstr "" -"L'objet propriété renvoyé à aussi les attributs ``fget``, ``fset`` et " +"L'objet propriété renvoyé possède aussi les attributs ``fget``, ``fset`` et " "``fdel`` correspondants aux arguments du constructeur." +# suit un : #: library/functions.rst:1527 msgid "The docstrings of property objects are now writeable." -msgstr "Les *docstrings* des objets propriété peuvent maintenant être écrits." +msgstr "" +"les chaînes de documentation des objets *property* sont maintenant en " +"lecture-écriture." #: library/functions.rst:1536 msgid "" @@ -2884,7 +2906,6 @@ msgstr "" "`typesseq`." #: library/functions.rst:1542 -#, fuzzy msgid "" "Return a string containing a printable representation of an object. For " "many types, this function makes an attempt to return a string that would " @@ -2897,12 +2918,14 @@ msgid "" "`RuntimeError`." msgstr "" "Renvoie une chaîne contenant une représentation affichable de l'objet. Pour " -"de nombreux types, cette fonction essaye de renvoyer une chaîne qui donnera " -"à son tour un objet de même valeur lorsqu'elle est passée à :func:`eval`, " -"sinon la représentation sera une chaîne entourée de chevrons contenant le " -"nom du type et quelques informations supplémentaires, souvent le nom et " -"l'adresse de l'objet. Une classe peut contrôler ce que cette fonction " -"renvoie pour ses instances en définissant une méthode :meth:`__repr__`." +"de nombreux types, cette fonction essaye de renvoyer une chaîne qui, " +"lorsqu'elle est passée à :func:`eval`, donne à son tour un objet de même " +"valeur ; sinon la représentation sera une chaîne entourée de chevrons " +"contenant le nom du type et quelques informations supplémentaires, souvent " +"le nom et l'adresse de l'objet. Une classe peut contrôler ce que cette " +"fonction renvoie pour ses instances en définissant une méthode :meth:" +"`__repr__`. Si :func:`sys.displayhook` n'est pas accessible, cette fonction " +"lève une :exc:`RuntimeError`." #: library/functions.rst:1555 msgid "" @@ -2927,7 +2950,6 @@ msgstr "" "est renvoyé." #: library/functions.rst:1567 -#, fuzzy msgid "" "For the built-in types supporting :func:`round`, values are rounded to the " "closest multiple of 10 to the power minus *ndigits*; if two multiples are " @@ -2937,13 +2959,13 @@ msgid "" "negative). The return value is an integer if *ndigits* is omitted or " "``None``. Otherwise, the return value has the same type as *number*." msgstr "" -"Pour les types natifs supportant :func:`round`, les valeurs sont arrondies " -"au multiple de 10 puissance moins *ndigits*, si deux multiples sont " -"équidistants, l'arrondi se fait vers la valeur paire (par exemple " +"Pour les types natifs prenant en charge :func:`round`, les valeurs sont " +"arrondies au multiple de 10 puissance moins *ndigits*, si deux multiples " +"sont équidistants, l'arrondi se fait vers la valeur paire (par exemple " "``round(0.5)`` et ``round(-0.5)`` valent tous les deux ``0``, et " "``round(1.5)`` vaut ``2``). *ndigits* accepte tout nombre entier (positif, " "zéro, ou négatif). La valeur renvoyée est un entier si *ndigits* n'est pas " -"donné, (ou est ``None``). Sinon elle est du même type que *number*." +"donné (ou est ``None``). Sinon elle est du même type que *number*." #: library/functions.rst:1576 msgid "" @@ -2953,6 +2975,7 @@ msgstr "" "Pour tout autre objet Python ``number``, ``round`` délègue à ``number." "__round__``." +# suit un : #: library/functions.rst:1581 msgid "" "The behavior of :func:`round` for floats can be surprising: for example, " @@ -2961,8 +2984,8 @@ msgid "" "represented exactly as a float. See :ref:`tut-fp-issues` for more " "information." msgstr "" -"Le comportement de :func:`round` avec les nombres à virgule flottante peut " -"être surprenant : par exemple ``round(2.675, 2)`` donne ``2.67`` au lieu de " +"le comportement de :func:`round` avec les nombres à virgule flottante peut " +"être surprenant. Par exemple ``round(2.675, 2)`` donne ``2.67`` au lieu de " "``2.68``. Ce n'est pas un bogue, mais dû au fait que la plupart des " "fractions de décimaux ne peuvent pas être représentés exactement en nombre a " "virgule flottante. Voir :ref:`tut-fp-issues` pour plus d'information." @@ -2973,9 +2996,9 @@ msgid "" "*iterable*. ``set`` is a built-in class. See :class:`set` and :ref:`types-" "set` for documentation about this class." msgstr "" -"Renvoie un nouveau :class:`set`, dont les éléments peuvent être extraits " -"d'*iterable*. ``set`` est une classe native. Voir :class:`set` et :ref:" -"`types-set` pour la documentation de cette classe." +"Renvoie un nouvel :class:`ensemble `, dont les éléments sont extraits " +"d'*iterable* s'il est fourni. ``set`` est une classe native. Voir :class:" +"`set` et :ref:`types-set` pour la documentation de cette classe." #: library/functions.rst:1597 msgid "" @@ -2987,7 +3010,6 @@ msgstr "" "class:`tuple`, et :class:`dict`, ainsi que le module :mod:`collections`." #: library/functions.rst:1604 -#, fuzzy msgid "" "This is the counterpart of :func:`getattr`. The arguments are an object, a " "string, and an arbitrary value. The string may name an existing attribute " @@ -2996,10 +3018,10 @@ msgid "" "is equivalent to ``x.foobar = 123``." msgstr "" "C'est le complément de :func:`getattr`. Les arguments sont : un objet, une " -"chaîne, et une valeur de type arbitraire. La chaîne peut nommer un attribut " -"existant ou un nouvel attribut. La fonction assigne la valeur à l'attribut, " -"si l'objet l'autorise. Par exemple, ``setattr(x, 'foobar', 123)`` équivaut à " -"``x.foobar = 123``." +"chaîne et une valeur de type arbitraire. La chaîne *name* peut désigner un " +"attribut existant ou un nouvel attribut. La fonction assigne la valeur à " +"l'attribut, si l'objet l'autorise. Par exemple, ``setattr(x, 'foobar', " +"123)`` équivaut à ``x.foobar = 123``." #: library/functions.rst:1610 msgid "" @@ -3009,16 +3031,26 @@ msgid "" "whose name is not an identifier will not be accessible using the dot " "notation, but is accessible through :func:`getattr` etc.." msgstr "" +"*name* n'a pas besoin d'être un identifiant Python tel que défini dans :ref:" +"`identifiers` sauf si l'objet choisit de l'imposer, par exemple en " +"personnalisant :meth:`~object.__getattribute__` ou *via* :attr:`~object." +"__slots__`. Un attribut dont le nom n'est pas un identifiant ne sera pas " +"accessible en utilisant la notation pointée, mais est accessible *via* :func:" +"`getattr` etc." +# suit un : #: library/functions.rst:1618 msgid "" "Since :ref:`private name mangling ` happens at " "compilation time, one must manually mangle a private attribute's (attributes " "with two leading underscores) name in order to set it with :func:`setattr`." msgstr "" +"étant donné que la :ref:`transformation des noms privés ` se produit au moment de la compilation, il faut modifier " +"manuellement le nom d'un attribut privé (attributs avec deux traits de " +"soulignement en tête) afin de le définir avec :func:`setattr`." #: library/functions.rst:1627 -#, fuzzy msgid "" "Return a :term:`slice` object representing the set of indices specified by " "``range(start, stop, step)``. The *start* and *step* arguments default to " @@ -3033,14 +3065,13 @@ msgstr "" "Renvoie une :term:`tranche ` représentant un ensemble d'indices " "spécifiés par ``range(start, stop, step)``. Les arguments *start* et *step* " "valent ``None`` par défaut. Les objets « tranches » ont les attributs " -"suivants en lecture seule : :attr:`~slice.start`, :attr:`~slice.stop`, et :" +"suivants en lecture seule : :attr:`~slice.start`, :attr:`~slice.stop` et :" "attr:`~slice.step` qui valent simplement les trois arguments (ou leurs " "valeurs par défaut). Ils n'ont pas d'autre fonctionnalité explicite, " -"cependant ils sont utilisés par *Numerical Python* et d'autres bibliothèques " -"tierces. Les objets « tranches » sont aussi générés par la notation par " -"indice étendue. Par exemple ``a[start:stop:step]`` ou ``a[start:stop, i]``. " -"Voir :func:`itertools.islice` pour une version alternative renvoyant un " -"itérateur." +"cependant ils sont utilisés par *NumPy* et d'autres paquets. Les objets " +"« tranches » sont aussi générés par la notation par indice étendue. Par " +"exemple ``a[start:stop:step]`` ou ``a[start:stop, i]``. Voir :func:" +"`itertools.islice` pour une version alternative renvoyant un itérateur." #: library/functions.rst:1640 msgid "Return a new sorted list from the items in *iterable*." @@ -3049,7 +3080,9 @@ msgstr "Renvoie une nouvelle liste triée depuis les éléments d'*iterable*." #: library/functions.rst:1642 msgid "" "Has two optional arguments which must be specified as keyword arguments." -msgstr "A deux arguments optionnels qui doivent être nommés." +msgstr "" +"Possède deux arguments optionnels qui doivent être spécifiés par arguments " +"nommés." #: library/functions.rst:1644 msgid "" @@ -3057,7 +3090,7 @@ msgid "" "comparison key from each element in *iterable* (for example, ``key=str." "lower``). The default value is ``None`` (compare the elements directly)." msgstr "" -"*key* spécifie une fonction d'un argument utilisé pour extraire une clé de " +"*key* spécifie une fonction à un argument utilisée pour extraire une clé de " "comparaison de chaque élément de l'itérable (par exemple, ``key=str." "lower``). La valeur par défaut est ``None`` (compare les éléments " "directement)." @@ -3067,8 +3100,8 @@ msgid "" "*reverse* is a boolean value. If set to ``True``, then the list elements " "are sorted as if each comparison were reversed." msgstr "" -"*reverse*, une valeur booléenne. Si elle est ``True``, la liste d'éléments " -"est triée comme si toutes les comparaisons étaient inversées." +"*reverse* est une valeur booléenne. Si elle est ``True``, la liste " +"d'éléments est triée comme si toutes les comparaisons étaient inversées." #: library/functions.rst:1651 msgid "" @@ -3087,7 +3120,7 @@ msgid "" msgstr "" "La fonction native :func:`sorted` est garantie stable. Un tri est stable " "s'il garantit de ne pas changer l'ordre relatif des éléments égaux entre " -"eux. C'est utile pour trier en plusieurs passes (par exemple par département " +"eux. C'est utile pour trier en plusieurs passes (par exemple par direction " "puis par salaire)." #: library/functions.rst:1659 @@ -3101,6 +3134,15 @@ msgid "" "mixed type comparisons which can call reflected the :meth:`~object.__gt__` " "method." msgstr "" +"L'algorithme de tri utilise uniquement l'opérateur ``<`` pour comparer les " +"éléments. Alors que la définition d'une méthode :meth:`~object.__lt__` est " +"suffisante pour trier, la :PEP:`8` recommande que les six :ref:`comparaisons " +"riches ` soient implémentées. Cela contribue à éviter les " +"bogues lors de l'utilisation des mêmes données avec d'autres outils de tri " +"(tels que :func:`max`) qui reposent sur une méthode sous-jacente différente. " +"L'implémentation des six comparaisons permet également d'éviter toute " +"confusion lors de comparaisons de types mixtes qui peuvent appeler la " +"méthode :meth:`~object.__gt__`." #: library/functions.rst:1668 msgid "" @@ -3117,7 +3159,7 @@ msgid "" "A static method does not receive an implicit first argument. To declare a " "static method, use this idiom::" msgstr "" -"Une méthode statique ne reçoit pas de premier argument implicitement. Voilà " +"Une méthode statique ne reçoit pas de premier argument implicitement. Voici " "comment déclarer une méthode statique ::" #: library/functions.rst:1681 @@ -3129,7 +3171,6 @@ msgstr "" "fonction. Consultez :ref:`function` pour plus de détails." #: library/functions.rst:1684 -#, fuzzy msgid "" "A static method can be called either on the class (such as ``C.f()``) or on " "an instance (such as ``C().f()``). Moreover, they can be called as regular " @@ -3137,18 +3178,17 @@ msgid "" msgstr "" "Une méthode statique peut être appelée sur une classe (par exemple, ``C." "f()``) comme sur une instance (par exemple, ``C().f()``). De plus, elles " -"peuvent être appelées comme des fonctions régulières (comme ``f()``)." +"peuvent être appelées comme des fonctions habituelles (comme ``f()``)." #: library/functions.rst:1688 -#, fuzzy msgid "" "Static methods in Python are similar to those found in Java or C++. Also, " "see :func:`classmethod` for a variant that is useful for creating alternate " "class constructors." msgstr "" -"Les méthodes statiques en Python sont similaires à celles trouvées en Java " -"ou en C++. Consultez :func:`classmethod` pour une variante utile pour créer " -"des constructeurs alternatifs." +"Les méthodes statiques en Python sont similaires à celles que l'on trouve en " +"Java ou en C++. Consultez :func:`classmethod` pour une variante utile " +"permettant de créer des constructeurs alternatifs." #: library/functions.rst:1692 msgid "" @@ -3160,21 +3200,26 @@ msgid "" msgstr "" "Comme pour tous les décorateurs, il est possible d'appeler ``staticmethod`` " "comme une simple fonction, et faire quelque chose de son résultat. Ça peut " -"être nécessaire dans le cas où vous voudriez une référence à la fonction " -"depuis le corps d'une classe, et souhaiteriez éviter sa transformation en " -"méthode d'instance. Pour ces cas, faites comme suit ::" +"être nécessaire dans le cas où vous souhaitez une référence à la fonction " +"depuis le corps d'une classe, et voulez éviter sa transformation en méthode " +"d'instance. Dans ce cas, faites comme suit ::" #: library/functions.rst:1704 msgid "For more information on static methods, see :ref:`types`." msgstr "" "Pour plus d'informations sur les méthodes statiques, consultez :ref:`types`." +# suit un : #: library/functions.rst:1706 msgid "" "Static methods now inherit the method attributes (``__module__``, " "``__name__``, ``__qualname__``, ``__doc__`` and ``__annotations__``), have a " "new ``__wrapped__`` attribute, and are now callable as regular functions." msgstr "" +"les méthodes statiques héritent dorénavant des attributs des méthodes " +"(``__module__``, ``__name__``, ``__qualname__``, ``__doc__`` et " +"``__annotations__``), ont un nouvel attribut ``__wrapped__`` et sont " +"maintenant appelables comme les fonctions habituelles." #: library/functions.rst:1721 msgid "" @@ -3210,11 +3255,12 @@ msgid "" "using :func:`itertools.chain`." msgstr "" "Pour certains cas, il existe de bonnes alternatives à :func:`sum`. La bonne " -"méthode, et rapide, de concaténer une séquence de chaînes est d'appeler ``''." +"méthode, rapide, pour concaténer une séquence de chaînes est d'appeler ``''." "join(séquence)``. Pour additionner des nombres à virgule flottante avec une " "meilleure précision, voir :func:`math.fsum`. Pour concaténer une série " "d'itérables, utilisez plutôt :func:`itertools.chain`." +# suit un : #: library/functions.rst:1739 msgid "The *start* parameter can be specified as a keyword argument." msgstr "le paramètre *start* peut être passé comme un argument nommé." @@ -3230,35 +3276,32 @@ msgstr "" "aux méthodes héritées qui ont été remplacées dans une classe." #: library/functions.rst:1749 -#, fuzzy msgid "" "The *object_or_type* determines the :term:`method resolution order` to be " "searched. The search starts from the class right after the *type*." msgstr "" -"Le *object-or-type* détermine quel :term:`ordre de résolution des méthodes " +"*object_or_type* détermine quel :term:`ordre de résolution des méthodes " "` est utilisé pour la recherche. La recherche " "commence à partir de la classe qui suit immédiatement le *type*." #: library/functions.rst:1753 -#, fuzzy msgid "" "For example, if :attr:`~class.__mro__` of *object_or_type* is ``D -> B -> C -" "> A -> object`` and the value of *type* is ``B``, then :func:`super` " "searches ``C -> A -> object``." msgstr "" -"Par exemple, si :attr:`~class.__mro__` de *object-or-type* est ``D -> B -> C " +"Par exemple, si :attr:`~class.__mro__` de *object_or_type* est ``D -> B -> C " "-> A -> object`` et la valeur de *type* est ``B``, alors :func:`super` " "recherche ``C -> A -> object``." #: library/functions.rst:1757 -#, fuzzy msgid "" "The :attr:`~class.__mro__` attribute of the *object_or_type* lists the " "method resolution search order used by both :func:`getattr` and :func:" "`super`. The attribute is dynamic and can change whenever the inheritance " "hierarchy is updated." msgstr "" -"L'attribut :attr:`~class.__mro__` de *object-or-type* liste l'ordre de " +"L'attribut :attr:`~class.__mro__` de *object_or_type* liste l'ordre de " "recherche de la méthode de résolution utilisée par :func:`getattr` et :func:" "`super`. L'attribut est dynamique et peut changer lorsque la hiérarchie " "d'héritage est modifiée." @@ -3283,13 +3326,12 @@ msgid "" "closely parallels the use of *super* in other programming languages." msgstr "" "Il existe deux autres cas d'usage typiques pour *super*. Dans une hiérarchie " -"de classes à héritage simple, *super* peut être utilisé pour obtenir la " +"de classes à héritage simple, *super* peut être utilisée pour obtenir la " "classe parente sans avoir à la nommer explicitement, rendant le code plus " "maintenable. Cet usage se rapproche de l'usage de *super* dans d'autres " "langages de programmation." #: library/functions.rst:1772 -#, fuzzy msgid "" "The second use case is to support cooperative multiple inheritance in a " "dynamic execution environment. This use case is unique to Python and is not " @@ -3306,11 +3348,11 @@ msgstr "" "retrouve ni dans les langages compilés statiquement, ni dans les langages ne " "gérant que l'héritage simple. Cela rend possible d'implémenter un héritage " "en diamant dans lequel plusieurs classes parentes implémentent la même " -"méthode. Une bonne conception implique que chaque méthode doit avoir la même " -"signature lors de leur appel dans tous les cas (parce que l'ordre des appels " -"est déterminée à l'exécution, parce que l'ordre s'adapte aux changements " -"dans la hiérarchie, et parce que l'ordre peut inclure des classes sœurs " -"inconnues avant l'exécution)." +"méthode. Une bonne conception implique que ces implémentations doivent avoir " +"la même signature lors de leur appel dans tous les cas (parce que l'ordre " +"des appels est déterminée à l'exécution, parce que l'ordre s'adapte aux " +"changements dans la hiérarchie, et parce que l'ordre peut inclure des " +"classes sœurs inconnues avant l'exécution)." #: library/functions.rst:1782 msgid "For both use cases, a typical superclass call looks like this::" @@ -3337,11 +3379,11 @@ msgid "" "using statements or operators such as ``super()[name]``." msgstr "" "Notez que :func:`super` fait partie de l'implémentation du processus de " -"liaison de recherche d'attributs pointés explicitement comme ``super()." -"__getitem__(name)``. Il le fait en implémentant sa propre méthode :meth:" +"liaison lors de la recherche explicite d'attributs pointés comme ``super()." +"__getitem__(name)``. Elle le fait en implémentant sa propre méthode :meth:" "`__getattribute__` pour rechercher les classes dans un ordre prévisible " -"supportant l'héritage multiple coopératif. En conséquence, :func:`super` " -"n'est pas défini pour les recherches implicites via des instructions ou des " +"gérant l'héritage multiple coopératif. En conséquence, :func:`super` n'est " +"pas définie pour les recherches implicites via des instructions ou des " "opérateurs tels que ``super()[name]``." #: library/functions.rst:1800 @@ -3353,13 +3395,13 @@ msgid "" "necessary details to correctly retrieve the class being defined, as well as " "accessing the current instance for ordinary methods." msgstr "" -"Notez aussi que, en dehors de sa forme sans arguments, :func:`super` peut " +"Notez aussi que, en dehors de sa forme sans argument, :func:`super` peut " "être utilisée en dehors des méthodes. La forme à deux arguments est précise " -"et donne tous les arguments exactement, donnant les références appropriées. " -"La forme sans arguments fonctionne seulement à l'intérieur d'une définition " -"de classe, puisque c'est le compilateur qui donne les détails nécessaires à " -"propos de la classe en cours de définition, ainsi qu'accéder à l'instance " -"courante pour les méthodes ordinaires." +"et contient tous les arguments nécessaires, donnant les références " +"appropriées. La forme sans argument fonctionne seulement à l'intérieur d'une " +"définition de classe, puisque c'est le compilateur qui donne les détails " +"nécessaires à propos de la classe en cours de définition, ainsi qu'accéder à " +"l'instance courante pour les méthodes ordinaires." #: library/functions.rst:1807 msgid "" @@ -3376,7 +3418,7 @@ msgid "" "Rather than being a function, :class:`tuple` is actually an immutable " "sequence type, as documented in :ref:`typesseq-tuple` and :ref:`typesseq`." msgstr "" -"Plutôt qu'être une fonction, :class:`tuple` est en fait un type de séquence " +"Ce n'est pas une fonction, :class:`tuple` est en fait un type de séquence " "immuable, comme documenté dans :ref:`typesseq-tuple` et :ref:`typesseq`." #: library/functions.rst:1826 @@ -3398,7 +3440,6 @@ msgstr "" "d'un objet, car elle prend en compte l'héritage." #: library/functions.rst:1834 -#, fuzzy msgid "" "With three arguments, return a new type object. This is essentially a " "dynamic form of the :keyword:`class` statement. The *name* string is the " @@ -3412,14 +3453,14 @@ msgid "" msgstr "" "Avec trois arguments, renvoie un nouveau type. C'est essentiellement une " "forme dynamique de l'instruction :keyword:`class`. La chaîne *name* est le " -"nom de la classe et deviendra l'attribut :attr:`~definition.__name__` ; le " +"nom de la classe et deviendra l'attribut :attr:`~definition.__name__`. Le " "*n*-uplet *bases* contient les classes mères et deviendra l'attribut :attr:" "`~class.__bases__`. S'il est vide, :class:`object`, la classe mère ultime de " -"toutes les classes, est ajoutée. Le dictionnaire *dict* est l'espace de " -"nommage contenant les définitions du corps de la classe, il est copié ou " -"encapsulé vers un dictionnaire standard pour devenir l'attribut :attr:" -"`~object.__dict__`. Par exemple, les deux instructions suivantes créent deux " -"instances identiques de :class:`type` :" +"toutes les classes, est ajoutée. Le dictionnaire *dict* contient les " +"définitions des attributs et des méthodes du corps de la classe ; il peut " +"être copié ou encapsulé vers un dictionnaire standard pour devenir " +"l'attribut :attr:`~object.__dict__`. Par exemple, les deux instructions " +"suivantes créent deux instances identiques de :class:`type` :" #: library/functions.rst:1849 msgid "See also :ref:`bltin-type-objects`." @@ -3432,18 +3473,22 @@ msgid "" "in the same way that keywords in a class definition (besides *metaclass*) " "would." msgstr "" +"Les arguments nommés fournis à la forme à trois arguments sont passés au " +"mécanisme de métaclasse approprié (généralement :meth:`~object." +"__init_subclass__`) de la même manière que les arguments nommés dans une " +"définition de classe (en plus de *metaclass*)." #: library/functions.rst:1856 -#, fuzzy msgid "See also :ref:`class-customization`." msgstr "Voir aussi :ref:`class-customization`." +# suit un : #: library/functions.rst:1858 msgid "" "Subclasses of :class:`type` which don't override ``type.__new__`` may no " "longer use the one-argument form to get the type of an object." msgstr "" -"Les sous-classes de :class:`type` qui ne redéfinissent pas ``type.__new__`` " +"les sous-classes de :class:`type` qui ne redéfinissent pas ``type.__new__`` " "ne doivent plus utiliser la forme à un argument pour récupérer le type d'un " "objet." @@ -3485,15 +3530,19 @@ msgid "" "doesn't have a :attr:`~object.__dict__` attribute (for example, if its class " "defines the :attr:`~object.__slots__` attribute)." msgstr "" +"Une exception :exc:`TypeError` est levée si un objet est spécifié mais qu'il " +"n'a pas d'attribut :attr:`~object.__dict__` (par exemple, si sa classe " +"définit l'attribut :attr:`~object.__slots__`)." #: library/functions.rst:1883 msgid "" "Iterate over several iterables in parallel, producing tuples with an item " "from each one." msgstr "" +"Itère sur plusieurs itérables en parallèle, produisant des *n*-uplets avec " +"un élément provenant de chacun." #: library/functions.rst:1886 -#, fuzzy msgid "Example::" msgstr "Exemple ::" @@ -3502,6 +3551,9 @@ msgid "" "More formally: :func:`zip` returns an iterator of tuples, where the *i*-th " "tuple contains the *i*-th element from each of the argument iterables." msgstr "" +"Plus formellement : :func:`zip` renvoie un itérateur de *n*-uplets, où le " +"*i*:sup:`e` *n*-uplet contient le *i*:sup:`e` élément de chacun des " +"itérables passés en arguments." #: library/functions.rst:1898 msgid "" @@ -3509,6 +3561,9 @@ msgid "" "columns into rows. This is similar to `transposing a matrix `_." msgstr "" +"Une autre façon de voir :func:`zip` est qu'elle transforme les lignes en " +"colonnes et les colonnes en lignes, fournissant la `matrice transposée " +"`_." #: library/functions.rst:1902 msgid "" @@ -3516,6 +3571,9 @@ msgid "" "iterated on, e.g. by a :keyword:`!for` loop or by wrapping in a :class:" "`list`." msgstr "" +":func:`zip` est paresseuse : les éléments ne sont traités qu'au moment où " +"l'on itère, par exemple avec une boucle :keyword:`!for` ou en les plaçant " +"dans une :class:`liste `." #: library/functions.rst:1906 msgid "" @@ -3524,13 +3582,21 @@ msgid "" "the code that prepared these iterables. Python offers three different " "approaches to dealing with this issue:" msgstr "" +"Il faut savoir que les itérables passés à :func:`zip` peuvent avoir des " +"longueurs différentes ; parfois par conception, parfois à cause d'un bogue " +"dans le code qui a préparé ces itérables. Python propose trois approches " +"différentes pour traiter ce problème :" +# énumération #: library/functions.rst:1911 msgid "" "By default, :func:`zip` stops when the shortest iterable is exhausted. It " "will ignore the remaining items in the longer iterables, cutting off the " "result to the length of the shortest iterable::" msgstr "" +"par défaut, :func:`zip` s'arrête lorsque l'itérable le plus court est " +"épuisé. Elle ignore les éléments restants dans les itérables plus longs, " +"coupant le résultat à la longueur de l'itérable le plus court ::" #: library/functions.rst:1918 msgid "" @@ -3538,12 +3604,17 @@ msgid "" "equal length. In such cases, it's recommended to use the ``strict=True`` " "option. Its output is the same as regular :func:`zip`::" msgstr "" +":func:`zip` est souvent utilisée dans les cas où les itérables sont supposés " +"être de même longueur. Dans ce cas, il est recommandé d'utiliser l'option " +"``strict=True``. Cela produit la même chose que la :func:`zip` habituelle ::" #: library/functions.rst:1925 msgid "" "Unlike the default behavior, it raises a :exc:`ValueError` if one iterable " "is exhausted before the others:" msgstr "" +"Mais, contrairement au comportement par défaut, elle lève une :exc:" +"`ValueError` si un itérable est épuisé avant les autres :" #: library/functions.rst:1943 msgid "" @@ -3551,26 +3622,35 @@ msgid "" "different lengths will be silenced, possibly manifesting as a hard-to-find " "bug in another part of the program." msgstr "" +"Sans l'argument ``strict=True``, tout bogue entraînant des itérables de " +"longueurs différentes est réduit au silence, se manifestant éventuellement " +"comme un bogue difficile à trouver dans une autre partie du programme." +# énumération. #: library/functions.rst:1947 msgid "" "Shorter iterables can be padded with a constant value to make all the " "iterables have the same length. This is done by :func:`itertools." "zip_longest`." msgstr "" +"les itérables plus courts peuvent être remplis avec une valeur constante " +"pour que tous les itérables aient la même longueur. C'est le cas pour :func:" +"`itertools.zip_longest`." #: library/functions.rst:1951 msgid "" "Edge cases: With a single iterable argument, :func:`zip` returns an iterator " "of 1-tuples. With no arguments, it returns an empty iterator." msgstr "" +"Cas extrêmes : avec un seul argument itérable, :func:`zip` renvoie un " +"itérateur de « 1-uplet ». Sans argument, elle renvoie un itérateur vide." #: library/functions.rst:1954 msgid "Tips and tricks:" -msgstr "" +msgstr "Trucs et astuces :" +# suit un : #: library/functions.rst:1956 -#, fuzzy msgid "" "The left-to-right evaluation order of the iterables is guaranteed. This " "makes possible an idiom for clustering a data series into n-length groups " @@ -3578,12 +3658,12 @@ msgid "" "``n`` times so that each output tuple has the result of ``n`` calls to the " "iterator. This has the effect of dividing the input into n-length chunks." msgstr "" -"Il est garanti que les itérables soient évalués de gauche à droite. Cela " -"rend possible de grouper une séquence de données en groupes de taille *n* " -"via ``zip(*[iter(s)]*n, strict=True)``. Cela duplique le *même* itérateur " -"``n`` fois ; par conséquent le *n*-uplet obtenu contient le résultat de " -"``n`` appels à l'itérateur. Cela a pour effet de diviser la séquence en " -"morceaux de taille *n*." +"il est garanti que les itérables sont évalués de gauche à droite. Cela rend " +"possible de grouper une séquence de données en groupes de taille *n* via " +"``zip(*[iter(s)]*n, strict=True)``. Cela duplique le *même* itérateur ``n`` " +"fois ; par conséquent le *n*-uplet obtenu contient le résultat de ``n`` " +"appels à l'itérateur. Cela a pour effet de diviser la séquence en morceaux " +"de taille *n*." #: library/functions.rst:1962 msgid "" @@ -3593,17 +3673,18 @@ msgstr "" ":func:`zip` peut être utilisée conjointement avec l'opérateur ``*`` pour " "dézipper une liste ::" +# suit un : #: library/functions.rst:1973 -#, fuzzy msgid "Added the ``strict`` argument." msgstr "ajout de l'argument ``strict``." +# suit un : #: library/functions.rst:1985 msgid "" "This is an advanced function that is not needed in everyday Python " "programming, unlike :func:`importlib.import_module`." msgstr "" -"C'est une fonction avancée qui n'est pas fréquemment nécessaire, " +"c'est une fonction avancée qui n'est pas fréquemment nécessaire, " "contrairement à :func:`importlib.import_module`." #: library/functions.rst:1988 @@ -3627,7 +3708,6 @@ msgstr "" "est aussi déconseillé en faveur de :func:`importlib.import_module`." #: library/functions.rst:1997 -#, fuzzy msgid "" "The function imports the module *name*, potentially using the given " "*globals* and *locals* to determine how to interpret the name in a package " @@ -3713,6 +3793,7 @@ msgstr "" "Si vous voulez simplement importer un module (potentiellement dans un " "paquet) par son nom, utilisez :func:`importlib.import_module`." +# suit un : #: library/functions.rst:2041 msgid "" "Negative values for *level* are no longer supported (which also changes the " @@ -3743,7 +3824,6 @@ msgstr "" "lisez le code depuis un fichier, assurez-vous d'utiliser la conversion de " "retours à la ligne pour convertir les fin de lignes Windows et Mac." -#, fuzzy #~ msgid "" #~ "There is an additional mode character permitted, ``'U'``, which no longer " #~ "has any effect, and is considered deprecated. It previously enabled :term:"