ArmandS/python-docs-fr
Fork 0
forked from AFPy/python-docs-fr
Code Pull requests Activity

Traduction « tuple » par « n-uplet ». (#1490)

Browse source
This commit is contained in:
Antoine 2020-12-02 23:45:10 +01:00 • committed by GitHub
commit 97353f195e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
81 changed files with 605 additions and 587 deletions
Download patch file Download diff file Expand all files Collapse all files

5
CONTRIBUTING.rst
View file

@ -462,7 +462,10 @@ typically normalement, habituellement, comme d'habitude
(plutôt que « typiquement »)
thread fil d'exécution
traceback trace d'appels, trace de pile
tuple n-uplet
tuple *n*-uplet (avec *n* en italique), on peut
traduire *2-tuple* par « paire » ou « couple »,
*3-tuple* par « triplet », *4-tuple* par
« quadruplet » etc.
underscore tiret bas, *underscore*
whitespace caractère d'espacement
========================== ===============================================

7
c-api/allocation.po
View file

@ -72,9 +72,10 @@ msgstr ""
"l'objet Python ne sont pas initialisés. La mémoire allouée est suffisante "
"pour la structure *TYPE* plus *size* champs de la taille donnée par le champ "
"de *type* :c:member:`~PyTypeObject.tp_itemsize`. Ceci est utile pour "
"l'implémentation d'objets comme les tuples, qui sont capables de déterminer "
"leur taille à la construction. Allouer les champs en même temps que l'objet "
"diminue le nombre d'allocations, améliorant ainsi les performances."
"l'implémentation d'objets comme les *n*-uplets, qui sont capables de "
"déterminer leur taille à la construction. Allouer les champs en même temps "
"que l'objet diminue le nombre d'allocations, améliorant ainsi les "
"performances."
#: c-api/allocation.rst:53
msgid ""

2
c-api/arg.po
View file

@ -927,7 +927,7 @@ msgid ""
msgstr ""
"Les arguments additionnels qui sont donnés à ces fonctions doivent être des "
"adresses de variables dont le type est déterminé par la chaîne de format. "
"Elles sont utilisées pour stocker les valeurs du n-uplet d'entrée. Il y a "
"Elles sont utilisées pour stocker les valeurs du *n*-uplet d'entrée. Il y a "
"quelques cas, comme décrit précédemment dans le liste des unités de formats, "
"où ces paramètres sont utilisés comme valeurs d'entrée. Dans ce cas, ils "
"devraient correspondre à ce qui est spécifié pour l'unité de format "

3
c-api/call.po
View file

@ -383,7 +383,8 @@ msgid ""
"*args*, and named arguments given by the dictionary *kwargs*."
msgstr ""
"Appelle un objet Python appelable *callable*, avec des arguments donnés par "
"le tuple *args*, et des arguments nommés donnés par le dictionnaire *kwargs*."
"le *n*-uplet *args*, et des arguments nommés donnés par le dictionnaire "
"*kwargs*."
#: c-api/call.rst:230
msgid ""

4
c-api/datetime.po
View file

@ -324,5 +324,5 @@ msgid ""
"Create and return a new :class:`datetime.date` object given an argument "
"tuple suitable for passing to :meth:`datetime.date.fromtimestamp()`."
msgstr ""
"Crée et renvoie un nouvel objet :class:`datetime.date` à partir d'un n-uplet "
"qui peut être passé à :meth:`datetime.date.fromtimestamp()`."
"Crée et renvoie un nouvel objet :class:`datetime.date` à partir d'un *n*-"
"uplet qui peut être passé à :meth:`datetime.date.fromtimestamp()`."

2
c-api/mapping.po
View file

@ -133,7 +133,7 @@ msgstr ""
#: c-api/mapping.rst:93 c-api/mapping.rst:102
msgid "Previously, the function returned a list or a tuple."
msgstr "Auparavant, la fonction renvoyait une liste ou un n-uplet."
msgstr "Auparavant, la fonction renvoyait une liste ou un *n*-uplet."
#: c-api/mapping.rst:90
msgid ""

22
c-api/object.po
View file

@ -316,9 +316,9 @@ msgid ""
"The result will be ``1`` when at least one of the checks returns ``1``, "
"otherwise it will be ``0``."
msgstr ""
"Si *cls* est un tuple, la vérification est menée sur chaque entrée de *cls*. "
"Le résultat sera ``1`` quand au moins une des vérifications renvoie ``1``, "
"sinon ce sera ``0``."
"Si *cls* est un *n*-uplet, la vérification est menée sur chaque entrée de "
"*cls*. Le résultat sera ``1`` quand au moins une des vérifications renvoie "
"``1``, sinon ce sera ``0``."
#: c-api/object.rst:220
msgid ""
@ -341,7 +341,7 @@ msgstr ""
"Normalement seulement les classes objets, c'est-à-dire les instances de :"
"class:`type` ou d'une classe dérivée, sont considérées classes. Cependant, "
"les objets peuvent surcharger cela en ayant un attribut :attr:`__bases__` "
"(qui doit être un tuple de classes de bases)."
"(qui doit être un *n*-uplet de classes de bases)."
#: c-api/object.rst:232
msgid ""
@ -379,7 +379,7 @@ msgid ""
msgstr ""
"Un objet *cls* peut surcharger s'il est considéré comme une classe, et ce "
"que ses classes de bases sont, en ayant un attribut :attr:`__bases__` (qui "
"doit être un tuple des classes de base)."
"doit être un *n*-uplet des classes de base)."
#: c-api/object.rst:255
msgid ""
@ -510,17 +510,17 @@ msgstr ""
#~ "tuple *args*, and named arguments given by the dictionary *kwargs*."
#~ msgstr ""
#~ "Appelle un objet Python appelable *callable*, avec des arguments donnés "
#~ "par le tuple *args*, et des arguments nommés donnés par le dictionnaire "
#~ "*kwargs*."
#~ "par le *n*-uplet *args*, et des arguments nommés donnés par le "
#~ "dictionnaire *kwargs*."
#, fuzzy
#~ msgid ""
#~ "*args* must not be ``NULL``, use an empty tuple if no arguments are "
#~ "needed. If no named arguments are needed, *kwargs* can be ``NULL``."
#~ msgstr ""
#~ "*args* ne doit pas être égal à *NULL*, utilisez un tuple vide si aucun "
#~ "argument n'est nécessaire. Si aucun argument nommé n'est nécessaire, "
#~ "*kwargs* peut être égal à *NULL*."
#~ "*args* ne doit pas être égal à *NULL*, utilisez un *n*-uplet vide si "
#~ "aucun argument n'est nécessaire. Si aucun argument nommé n'est "
#~ "nécessaire, *kwargs* peut être égal à *NULL*."
#, fuzzy
#~ msgid ""
@ -543,7 +543,7 @@ msgstr ""
#~ "tuple *args*. If no arguments are needed, then *args* can be ``NULL``."
#~ msgstr ""
#~ "Appelle un objet Python appelable *callable*, avec des arguments donnés "
#~ "par le tuple *args*. Si aucun argument n'est nécessaire, alors *args* "
#~ "par le *n*-uplet *args*. Si aucun argument n'est nécessaire, alors *args* "
#~ "peut être égal à *NULL*."
#~ msgid ""

1
dict
View file

@ -161,6 +161,7 @@ slot
smalltalk
sqlite
surprenamment
sextuplet
sérialisable
sérialisables
sérialiser

2
distutils/apiref.po
View file

@ -518,7 +518,7 @@ msgstr ""
#: distutils/apiref.rst:211
msgid "a list of tuples"
msgstr "une liste de tuples"
msgstr "une liste de *n*-uplets"
#: distutils/apiref.rst:223
msgid "*undef_macros*"

2
extending/embedding.po
View file

@ -300,7 +300,7 @@ msgstr ""
"Une fois le script chargé, le nom recherché est obtenu en utilisant :c:func:"
"`PyObject_GetAttrString`. Si le nom existe, et que l'objet récupéré peut "
"être appelé, vous pouvez présumer sans risque que c'est une fonction. Le "
"programme continue, classiquement, par la construction de n-uplet "
"programme continue, classiquement, par la construction de *n*-uplet "
"d'arguments. L'appel à la fonction Python est alors effectué avec ::"
#: extending/embedding.rst:199

18
extending/extending.po
View file

@ -199,14 +199,14 @@ msgid ""
"determine the required types of the arguments as well as the types of the C "
"variables into which to store the converted values. More about this later."
msgstr ""
"L'argument *args* sera un pointeur vers un *tuple* Python contenant les "
"arguments. Chaque élément du *tuple* correspond à un argument dans la liste "
"des arguments de l'appel. Les arguments sont des objets Python --- afin d'en "
"faire quelque chose dans notre fonction C, nous devons les convertir en "
"valeurs C. La fonction :c:func:`PyArg_ParseTuple` de l'API Python vérifie "
"les types des arguments et les convertit en valeurs C. Elle utilise un "
"modèle sous forme de chaîne pour déterminer les types requis des arguments "
"ainsi que les types de variables C dans lequel stocker les valeurs "
"L'argument *args* sera un pointeur vers un *n*-uplet Python contenant les "
"arguments. Chaque élément du *n*-uplet correspond à un argument dans la "
"liste des arguments de l'appel. Les arguments sont des objets Python --- "
"afin d'en faire quelque chose dans notre fonction C, nous devons les "
"convertir en valeurs C. La fonction :c:func:`PyArg_ParseTuple` de l'API "
"Python vérifie les types des arguments et les convertit en valeurs C. Elle "
"utilise un modèle sous forme de chaîne pour déterminer les types requis des "
"arguments ainsi que les types de variables C dans lequel stocker les valeurs "
"converties. Nous en verront plus, plus tard."
#: extending/extending.rst:116
@ -607,7 +607,7 @@ msgid ""
"func:`PyArg_ParseTuple`; more information on this function is provided below."
msgstr ""
"Si seulement ``METH_VARARGS`` est utilisé, la fonction s'attend à ce que les "
"paramètres Python soient passés comme un n-uplet que l'on peut analyser "
"paramètres Python soient passés comme un *n*-uplet que l'on peut analyser "
"*via* :c:func:`PyArg_ParseTuple` ; des informations supplémentaires sont "
"fournies plus bas."

35
faq/design.po
View file

@ -199,7 +199,7 @@ msgstr ""
"La première concerne la performance : savoir qu'une chaîne de caractères est "
"immuable signifie que l'allocation mémoire allouée lors de la création de "
"cette chaîne est fixe et figée. C'est aussi l'une des raisons pour "
"lesquelles on fait la distinction entre les *tuples* et les listes."
"lesquelles on fait la distinction entre les *n*-uplets et les listes."
#: faq/design.rst:104
msgid ""
@ -381,8 +381,8 @@ msgstr ""
#: faq/design.rst:193
msgid "Why is join() a string method instead of a list or tuple method?"
msgstr ""
"Pourquoi ``join()`` est une méthode de chaîne plutôt qu'une de liste ou de "
"tuple ?"
"Pourquoi ``join()`` est une méthode de chaîne plutôt qu'une méthode de liste "
"ou de *n*-uplet ?"
#: faq/design.rst:195
msgid ""
@ -771,7 +771,7 @@ msgstr ""
#: faq/design.rst:405
msgid "Why are there separate tuple and list data types?"
msgstr ""
"Pourquoi les *tuples* et les *list* sont deux types de données séparés ?"
"Pourquoi les *n*-uplets et les *list* sont deux types de données séparés ?"
#: faq/design.rst:407
msgid ""
@ -782,13 +782,13 @@ msgid ""
"Cartesian coordinate is appropriately represented as a tuple of two or three "
"numbers."
msgstr ""
"Les listes et les *tuples*, bien que semblable à bien des égards, sont "
"généralement utilisés de façons fondamentalement différentes. Les *tuples* "
"Les listes et les *n*-uplets, bien que semblable à bien des égards, sont "
"généralement utilisés de façons fondamentalement différentes. Les *n*-uplets "
"peuvent être considérés comme étant similaires aux dossiers en Pascal ou aux "
"structures en C; Ce sont de petites collections de données associées qui "
"peuvent être de différents types qui sont utilisées ensemble. Par exemple, "
"un repère cartésien est correctement représenté comme un *tuple* de deux ou "
"trois nombres."
"un repère cartésien est correctement représenté comme un *n*-uplet de deux "
"ou trois nombres."
#: faq/design.rst:414
msgid ""
@ -815,12 +815,12 @@ msgid ""
"be used as dictionary keys, and hence only tuples and not lists can be used "
"as keys."
msgstr ""
"Les *tuples* sont immuables, ce qui signifie que lorsqu'un *tuple* a été "
"Les *n*-uplets sont immuables, ce qui signifie que lorsqu'un *n*-uplet a été "
"créé, vous ne pouvez remplacer aucun de ses éléments par une nouvelle "
"valeur. Les listes sont muables, ce qui signifie que vous pouvez toujours "
"modifier les éléments d'une liste. Seuls des éléments immuables peuvent être "
"utilisés comme clés de dictionnaires, et donc de ``tuple`` et ``list`` seul "
"des *tuples* peuvent être utilisés comme clés."
"des *n*-uplets peuvent être utilisés comme clés."
#: faq/design.rst:428
msgid "How are lists implemented in CPython?"
@ -936,8 +936,8 @@ msgid ""
"dictionary keys."
msgstr ""
"Si vous voulez un dictionnaire indexé avec une liste, il faut simplement "
"convertir la liste en un *tuple* ; la fonction ``tuple(L)`` crée un "
"*tuple* avec les mêmes entrées que la liste ``L``. Les *tuples* sont "
"convertir la liste en un *n*-uplet ; la fonction ``tuple(L)`` crée un *n*-"
"uplet avec les mêmes entrées que la liste ``L``. Les *n*-uplets sont "
"immuables et peuvent donc être utilisés comme clés du dictionnaire."
#: faq/design.rst:476
@ -1001,7 +1001,7 @@ msgstr ""
"Marquer les listes comme étant en lecture seule une fois qu'elles sont "
"utilisées comme clé de dictionnaire. Le problème est que ce n'est pas "
"seulement l'objet de niveau supérieur qui pourrait changer sa valeur; vous "
"pourriez utiliser un tuple contenant une liste comme clé. Utiliser "
"pourriez utiliser un *n*-uplet contenant une liste comme clé. Utiliser "
"n'importe quoi comme une clé dans un dictionnaire nécessiterait de marquer "
"tous les objets accessibles à partir de là comme en lecture seule -- et "
"encore une fois, les objets se faisant référence pourraient provoquer une "
@ -1400,15 +1400,16 @@ msgstr ""
#: faq/design.rst:727
msgid "Why does Python allow commas at the end of lists and tuples?"
msgstr ""
"Pourquoi Python permet-il les virgules à la fin des listes et des tuples ?"
"Pourquoi Python permet-il les virgules à la fin des listes et des *n*-"
"uplets ?"
#: faq/design.rst:729
msgid ""
"Python lets you add a trailing comma at the end of lists, tuples, and "
"dictionaries::"
msgstr ""
"Python vous permet d'ajouter une virgule à la fin des listes, des tuples et "
"des dictionnaires ::"
"Python vous permet d'ajouter une virgule à la fin des listes, des *n*-uplets "
"et des dictionnaires ::"
#: faq/design.rst:740
msgid "There are several reasons to allow this."
@ -1421,7 +1422,7 @@ msgid ""
"remember to add a comma to the previous line. The lines can also be "
"reordered without creating a syntax error."
msgstr ""
"Lorsque vous avez une valeur littérale pour une liste, un tuple ou un "
"Lorsque vous avez une valeur littérale pour une liste, un *n*-uplet ou un "
"dictionnaire réparti sur plusieurs lignes, il est plus facile d'ajouter plus "
"d'éléments parce que vous n'avez pas besoin de vous rappeler d'ajouter une "
"virgule à la ligne précédente. Les lignes peuvent aussi être réorganisées "

11
faq/extending.po
View file

@ -153,7 +153,7 @@ msgid ""
"specified index. Lists have similar functions, :c:func:`PyListSize` and :c:"
"func:`PyList_GetItem`."
msgstr ""
"Cela dépend du type d'objet. Si c'est un tuple, :c:func:`PyTuple_Size` "
"Cela dépend du type d'objet. Si c'est un *n*-uplet, :c:func:`PyTuple_Size` "
"renvoie sa longueur et :c:func:`PyTuple_GetItem` renvoie l'élément à l'index "
"spécifié. Les listes ont des fonctions similaires, :c:func:`PyListSize` et :"
"c:func:`PyList_GetItem`."
@ -200,7 +200,8 @@ msgstr ""
#: faq/extending.rst:104
msgid "How do I use Py_BuildValue() to create a tuple of arbitrary length?"
msgstr ""
"Comment utiliser Py_BuildValue() pour créer un tuple de longueur définie ?"
"Comment utiliser Py_BuildValue() pour créer un *n*-uplet de longueur "
"définie ?"
#: faq/extending.rst:106
msgid "You can't. Use :c:func:`PyTuple_Pack` instead."
@ -247,8 +248,8 @@ msgid ""
"format, and to call a function with one argument, surround the argument in "
"parentheses, e.g. \"(i)\"."
msgstr ""
"Notez que :c:func:`PyObject_CallObject` veut *toujours* un tuple comme liste "
"d'arguments. Aussi, pour appeler une fonction sans arguments, utilisez "
"Notez que :c:func:`PyObject_CallObject` veut *toujours* un *n*-uplet comme "
"liste d'arguments. Aussi, pour appeler une fonction sans arguments, utilisez "
"\"()\" pour être conforme au type et, pour appeler une fonction avec un "
"paramètre, entourez-le de parenthèses, p. ex. \"(i)\"."
@ -489,7 +490,7 @@ msgstr ""
"l'objet code renvoyé en appelant :c:func:`PyEval_EvalCode`. Sinon, "
"enregistrez l'entrée pour plus tard. Si la compilation échoue, vérifiez s'il "
"s'agit d'une erreur ou s'il faut juste plus de données — en extrayant la "
"chaîne de message du tuple d'exception et en la comparant à la chaîne *"
"chaîne de message du *n*-uplet d'exception et en la comparant à la chaîne *"
"\"unexpected EOF while parsing\"*. Voici un exemple complet d'utilisation de "
"la bibliothèque *readline* de GNU (il vous est possible d'ignorer **SIGINT** "
"lors de l'appel à ``readline()``) ::"

44
faq/programming.po
View file

@ -635,7 +635,7 @@ msgid ""
"dictionaries, lists, and class instances can lead to confusion."
msgstr ""
"Par définition, les objets immuables comme les nombres, les chaînes de "
"caractères, les n-uplets et ``None`` ne sont pas modifiés. Les changements "
"caractères, les *n*-uplets et ``None`` ne sont pas modifiés. Les changements "
"sur des objets muables comme les dictionnaires, les listes et les instances "
"de classe peuvent porter à confusion."
@ -693,7 +693,7 @@ msgid ""
msgstr ""
"Il faut récupérer les arguments en utilisant les sélecteurs ``*`` et ``**`` "
"dans la liste des paramètres de la fonction ; ceci donne les arguments "
"positionnels sous la forme d'un n-uplet et les arguments nommés sous forme "
"positionnels sous la forme d'un *n*-uplet et les arguments nommés sous forme "
"de dictionnaire. Ces arguments peuvent être passés à une autre fonction en "
"utilisant ``*`` et ``**`` ::"
@ -830,7 +830,7 @@ msgid ""
msgstr ""
"Il existe cependant une classe d'opérations qui se comporte différemment "
"selon le type : les opérateurs d'affectation incrémentaux. Par exemple, ``"
"+=`` modifie les listes mais pas les n-uplets ni les entiers (``a_list += "
"+=`` modifie les listes mais pas les *n*-uplets ni les entiers (``a_list += "
"[1, 2, 3]`` équivaut à ``a_list.extend([1, 2, 3])`` et modifie ``a_list``, "
"alors que ``some_tuple += (1, 2, 3)`` et ``some_int += 1`` créent de "
"nouveaux objets)."
@ -890,7 +890,7 @@ msgstr ""
#: faq/programming.rst:505
msgid "By returning a tuple of the results::"
msgstr "En renvoyant un n-uplet de résultats ::"
msgstr "En renvoyant un *n*-uplet de résultats ::"
#: faq/programming.rst:516
msgid "This is almost always the clearest solution."
@ -923,7 +923,7 @@ msgstr "Faire quelque chose d'aussi compliqué est rarement une bonne idée."
#: faq/programming.rst:561
msgid "Your best choice is to return a tuple containing the multiple results."
msgstr ""
"La meilleure option reste de renvoyer un n-uplet contenant les différents "
"La meilleure option reste de renvoyer un *n*-uplet contenant les différents "
"résultats."
#: faq/programming.rst:565
@ -1685,11 +1685,11 @@ msgstr ""
#: faq/programming.rst:1090
msgid "Sequences (Tuples/Lists)"
msgstr "Séquences (n-uplets / listes)"
msgstr "Séquences (*n*-uplets / listes)"
#: faq/programming.rst:1093
msgid "How do I convert between tuples and lists?"
msgstr "Comment convertir les listes en n-uplets et inversement ?"
msgstr "Comment convertir les listes en *n*-uplets et inversement ?"
#: faq/programming.rst:1095
msgid ""
@ -1697,7 +1697,7 @@ msgid ""
"iterable) into a tuple with the same items in the same order."
msgstr ""
"Le constructeur de type ``tuple(seq)`` convertit toute séquence (plus "
"précisément, tout itérable) en un n-uplet avec les mêmes éléments dans le "
"précisément, tout itérable) en un *n*-uplet avec les mêmes éléments dans le "
"même ordre."
#: faq/programming.rst:1098
@ -1708,10 +1708,10 @@ msgid ""
"you aren't sure that an object is already a tuple."
msgstr ""
"Par exemple ``tuple([1, 2, 3])`` renvoie ``(1, 2, 3)`` et ``tuple('abc')`` "
"renvoie ``('a', 'b', 'c')``. Si l'argument est un n-uplet, cela ne crée pas "
"de copie, mais renvoie le même objet, ce qui fait de :func:`tuple` une "
"renvoie ``('a', 'b', 'c')``. Si l'argument est un *n*-uplet, cela ne crée "
"pas de copie, mais renvoie le même objet, ce qui fait de :func:`tuple` une "
"fonction économique à appeler quand vous ne savez pas si votre objet est "
"déjà un n-uplet."
"déjà un *n*-uplet."
#: faq/programming.rst:1103
msgid ""
@ -1872,7 +1872,7 @@ msgid ""
"To get Lisp-style linked lists, you can emulate cons cells using tuples::"
msgstr ""
"Pour obtenir des listes chaînées à la sauce Lisp, vous pouvez émuler les "
"*cons cells* en utilisant des n-uplets ::"
"*cons cells* en utilisant des *n*-uplets ::"
#: faq/programming.rst:1201
msgid ""
@ -1882,7 +1882,7 @@ msgid ""
"it's usually a lot slower than using Python lists."
msgstr ""
"Si vous voulez pouvoir modifier les éléments, utilisez une liste plutôt "
"qu'un tuple. Ici la version équivalente du *car* de Lisp est "
"qu'un *n*-uplet. Ici la version équivalente du *car* de Lisp est "
"``lisp_list[0]`` et l'équivalent de *cdr* est ``lisp_list[1]``. Ne faites "
"ceci que si vous êtes réellement sûr d'en avoir besoin, cette méthode est en "
"général bien plus lente que les listes Python."
@ -1977,7 +1977,7 @@ msgid ""
"a ``list`` and ``+=`` as our exemplar."
msgstr ""
"Cette discussion est valable, en général, quand des opérateurs d'affectation "
"incrémentale sont appliqués aux éléments d'un n-uplet qui pointe sur des "
"incrémentale sont appliqués aux éléments d'un *n*-uplet qui pointe sur des "
"objets muables, mais on prendra ``list`` et ``+=`` comme exemple."
#: faq/programming.rst:1281
@ -1995,8 +1995,8 @@ msgstr ""
"La cause de l'exception est claire : ``1`` est ajouté à l'objet "
"``a_tuple[0]`` qui pointe sur (``1``), ce qui produit l'objet résultant "
"``2``, mais, lorsque l'on tente d'affecter le résultat du calcul, ``2``, à "
"l'élément ``0`` du n-uplet, on obtient une erreur car il est impossible de "
"modifier la cible sur laquelle pointe un élément d'un n-uplet."
"l'élément ``0`` du *n*-uplet, on obtient une erreur car il est impossible de "
"modifier la cible sur laquelle pointe un élément d'un *n*-uplet."
#: faq/programming.rst:1295
msgid ""
@ -2012,7 +2012,7 @@ msgid ""
"tuple is immutable."
msgstr ""
"C'est la partie de l'affectation de l'opération qui génère l'erreur, vu "
"qu'un n-uplet est immuable."
"qu'un *n*-uplet est immuable."
#: faq/programming.rst:1307
msgid "When you write something like::"
@ -2062,7 +2062,7 @@ msgstr ""
#: faq/programming.rst:1343
msgid "Thus, in our tuple example what is happening is equivalent to::"
msgstr ""
"Donc, dans notre exemple avec un n-uplet, il se passe quelque chose "
"Donc, dans notre exemple avec un *n*-uplet, il se passe quelque chose "
"équivalent à ::"
#: faq/programming.rst:1351
@ -2074,7 +2074,7 @@ msgid ""
msgstr ""
"L'appel à ``__iadd__`` réussit et la liste est étendue, mais bien que "
"``result`` pointe sur le même objet que ``a_tuple[0]``, l'affectation finale "
"échoue car les n-uplets ne sont pas muables."
"échoue car les *n*-uplets ne sont pas muables."
#: faq/programming.rst:1357
msgid ""
@ -2105,8 +2105,8 @@ msgid ""
"Merge them into an iterator of tuples, sort the resulting list, and then "
"pick out the element you want. ::"
msgstr ""
"Fusionnez-les dans un itérateur de n-uplets, ordonnez la liste obtenue, puis "
"choisissez l'élément que vous voulez ::"
"Fusionnez-les dans un itérateur de *n*-uplets, ordonnez la liste obtenue, "
"puis choisissez l'élément que vous voulez ::"
#: faq/programming.rst:1384
msgid "An alternative for the last step is::"
@ -2223,7 +2223,7 @@ msgid ""
msgstr ""
"Utilisez la fonction native ``isinstance(obj, cls)``. Vous pouvez vérifier "
"qu'un objet est une instance de plusieurs classes à la fois en fournissant "
"un n-uplet à la place d'une seule classe, par exemple, ``isinstance(obj, "
"un *n*-uplet à la place d'une seule classe, par exemple, ``isinstance(obj, "
"(class1, class2, ...))``. Vous pouvez également vérifier qu'un objet est "
"l'un des types natifs de Python, par exemple ``isinstance(obj, str)`` ou "
"``isinstance(obj, (int, float, complex))``."

24
howto/functional.po
View file

@ -500,8 +500,8 @@ msgid ""
"Iterators can be materialized as lists or tuples by using the :func:`list` "
"or :func:`tuple` constructor functions:"
msgstr ""
"Les itérateurs peuvent être transformés en listes ou en tuples en appelant "
"les constructeurs respectifs :func:`list` et :func:`tuple` :"
"Les itérateurs peuvent être transformés en listes ou en *n*-uplets en "
"appelant les constructeurs respectifs :func:`list` et :func:`tuple` :"
#: howto/functional.rst:238
msgid ""
@ -510,7 +510,7 @@ msgid ""
msgstr ""
"Le dépaquetage de séquences fonctionne également sur les itérateurs : si "
"vous savez qu'un itérateur renvoie N éléments, vous pouvez les dépaqueter "
"dans un n-uplet :"
"dans un *n*-uplet :"
#: howto/functional.rst:247
msgid ""
@ -560,7 +560,7 @@ msgid ""
"Python sequence type, such as strings, will automatically support creation "
"of an iterator."
msgstr ""
"Nous avons vu précédemment comment les listes et les *tuples* gèrent les "
"Nous avons vu précédemment comment les listes et les *n*-uplets gèrent les "
"itérateurs. En réalité, n'importe quel type de séquence en Python, par "
"exemple les chaînes de caractères, sont itérables."
@ -1190,7 +1190,7 @@ msgid ""
"and returns them in a tuple::"
msgstr ""
":func:`zip(iterA, iterB, ...) <zip>` rassemble un élément de chaque itérable "
"dans un n-uplet ::"
"dans un *n*-uplet ::"
#: howto/functional.rst:718
msgid ""
@ -1200,7 +1200,7 @@ msgid ""
"evaluation <https://en.wikipedia.org/wiki/Lazy_evaluation>`__.)"
msgstr ""
"Cela ne construit pas de liste stockée en mémoire, ni ne vide les itérateurs "
"d'entrée avant de renvoyer sa valeur ; en réalité les n-uplets sont "
"d'entrée avant de renvoyer sa valeur ; en réalité les *n*-uplets sont "
"construits et renvoyés au fur et à mesure (il s'agit techniquement parlant "
"d'un comportement d'`évaluation paresseuse <https://fr.wikipedia.org/wiki/"
"%C3%89valuation_paresseuse>`__)."
@ -1377,8 +1377,8 @@ msgid ""
"as the arguments::"
msgstr ""
":func:`itertools.starmap(func, iter) <itertools.starmap>` suppose que "
"l'itérable renvoie une séquence de n-uplets et appelle *func* en utilisant "
"tous les n-uplets comme arguments ::"
"l'itérable renvoie une séquence de *n*-uplets et appelle *func* en utilisant "
"tous les *n*-uplets comme arguments ::"
#: howto/functional.rst:839
msgid "Selecting elements"
@ -1456,7 +1456,7 @@ msgid ""
"permutations(iterable, r=None) <itertools.permutations>`, removes this "
"constraint on the order, returning all possible arrangements of length *r*::"
msgstr ""
"Les éléments de chaque tuple sont ordonnés dans le même ordre que leur "
"Les éléments de chaque *n*-uplet sont ordonnés dans le même ordre que leur "
"apparition dans *iterable*. Ainsi, dans les exemples ci-dessus, le nombre 1 "
"se trouve toujours avant 2, 3, 4 ou 5. La fonction :func:`itertools."
"permutations(iterable, r=None) <itertools.permutations>` supprime la "
@ -1499,9 +1499,9 @@ msgid ""
msgstr ""
"La fonction :func:`itertools.combinations_with_replacement(iterable, r) "
"<itertools.combinations_with_replacement>` assouplit une autre contrainte : "
"les éléments peuvent être répétés au sein du même n-uplet. Il s'agit d'un "
"tirage avec remise : le premier élément sélectionné pour chaque n-uplet est "
"replacé dans la séquence avant le tirage du deuxième. ::"
"les éléments peuvent être répétés au sein du même *n*-uplet. Il s'agit d'un "
"tirage avec remise : le premier élément sélectionné pour chaque *n*-uplet "
"est replacé dans la séquence avant le tirage du deuxième. ::"
#: howto/functional.rst:947
msgid "Grouping elements"

2
howto/instrumentation.po
View file

@ -348,7 +348,7 @@ msgid ""
msgstr ""
"Fonction appelée quand les fonctions :func:`sys.audit` ou :c:func:"
"`PySys_Audit` sont appelées. ``arg0`` est le nom de l'évènement de type "
"chaîne de caractère C. ``arg1`` est un pointeur sur un tuple d'objet de "
"chaîne de caractère C. ``arg1`` est un pointeur sur un *n*-uplet d'objet de "
"type :c:type:`PyObject`."
#: howto/instrumentation.rst:343

2
howto/logging.po
View file

@ -1092,7 +1092,7 @@ msgid ""
"in the Formatter class (to ``time.gmtime`` for GMT display)."
msgstr ""
"Les `formatters` emploient une fonction configurable par l'utilisateur pour "
"convertir le temps de création d'une entrée de journal en un tuple. Par "
"convertir le temps de création d'une entrée de journal en un *n*-uplet. Par "
"défaut, :func:`time.localtime` est employé ; pour changer cela pour une "
"instance particulière de `formatter`, assignez une fonction avec la même "
"signature que :func:`time.localtime` ou :func:`time.gmtime` à l'attribut "

6
howto/sorting.po
View file

@ -275,7 +275,7 @@ msgid ""
"items are compared; if they are the same then the second items are compared, "
"and so on."
msgstr ""
"Cette technique marche parce que les tuples sont comparés par ordre "
"Cette technique marche parce que les *n*-uplets sont comparés par ordre "
"lexicographique; les premiers objets sont comparés; si il y a des objets "
"identiques, alors l'objet suivant est comparé, et ainsi de suite."
@ -303,8 +303,8 @@ msgid ""
"sorted directly."
msgstr ""
"Les objets d'origine ne sont pas nécessairement comparables car l'ordre des "
"tuples décorés sera déterminé par au plus les deux premiers objets. Donc par "
"exemple la liste originale pourrait contenir des nombres complexes qui "
"*n*-uplets décorés sera déterminé par au plus les deux premiers objets. Donc "
"par exemple la liste originale pourrait contenir des nombres complexes qui "
"pourraient ne pas être triés directement."
#: howto/sorting.rst:199

10
library/2to3.po
View file

@ -658,9 +658,9 @@ msgid ""
"incorrect because substituting tuples for exceptions has been removed in 3.0."
msgstr ""
"Convertit ``raise E, V`` en ``raise E(V)`` et ``raise E, V, T`` en ``raise "
"E(V).with_traceback(T)``. Si ``E`` est un tuple, la conversion sera "
"incorrecte puisque la substitution de tuples aux exceptions a été supprimée "
"en 3.0."
"E(V).with_traceback(T)``. Si ``E`` est un *n*-uplet, la conversion sera "
"incorrecte puisque la substitution de *n*-uplets aux exceptions a été "
"supprimée en 3.0."
#: library/2to3.rst:378
msgid "Converts :func:`raw_input` to :func:`input`."
@ -715,8 +715,8 @@ msgid ""
"Removes implicit tuple parameter unpacking. This fixer inserts temporary "
"variables."
msgstr ""
"Supprime la décompression implicite des paramètres d'un tuple. Ce correcteur "
"ajoute des variables temporaires."
"Supprime la décompression implicite des paramètres d'un *n*-uplet. Ce "
"correcteur ajoute des variables temporaires."
#: library/2to3.rst:421
msgid ""

2
library/_thread.po
View file

@ -65,7 +65,7 @@ msgid ""
msgstr ""
"Démarre un nouveau fils d'exécution et renvoie son identifiant. Ce fil "
"d'exécution exécute la fonction *function* avec la liste d'arguments *args* "
"(qui doit être un *tuple*). L'argument optionnel *kwargs* spécifie un "
"(qui doit être un *n*-uplet). L'argument optionnel *kwargs* spécifie un "
"dictionnaire d'arguments nommés."
#: library/_thread.rst:50

4
library/argparse.po
View file

@ -1472,8 +1472,8 @@ msgid ""
"each of the arguments::"
msgstr ""
"Certaines valeurs de ``nargs`` peuvent provoquer l'affichage de ``metavar`` "
"plus d'une fois. Passer un n-uplet à ``metavar`` indique les différents noms "
"à afficher pour chacun des arguments ::"
"plus d'une fois. Passer un *n*-uplet à ``metavar`` indique les différents "
"noms à afficher pour chacun des arguments ::"
#: library/argparse.rst:1298
msgid "dest"

18
library/array.po
View file

@ -301,15 +301,15 @@ msgid ""
"as long as the array exists and no length-changing operations are applied to "
"it."
msgstr ""
"Renvoie un tuple ``(address, length)`` indiquant l'adresse mémoire courante "
"et la longueur en éléments du tampon utilisé pour contenir le contenu du "
"tableau. La taille du tampon mémoire en octets peut être calculée par "
"``array.buffer_info()[1] * array.itemsize``. Ceci est parfois utile lorsque "
"vous travaillez sur des interfaces E/S de bas niveau (et intrinsèquement "
"dangereuses) qui nécessitent des adresses mémoire, telles que certaines "
"opérations :c:func:`ioctl`. Les nombres renvoyés sont valides tant que le "
"tableau existe et qu'aucune opération qui modifie sa taille ne lui est "
"appliquée."
"Renvoie un *n*-uplet ``(address, length)`` indiquant l'adresse mémoire "
"courante et la longueur en éléments du tampon utilisé pour contenir le "
"contenu du tableau. La taille du tampon mémoire en octets peut être calculée "
"par ``array.buffer_info()[1] * array.itemsize``. Ceci est parfois utile "
"lorsque vous travaillez sur des interfaces E/S de bas niveau (et "
"intrinsèquement dangereuses) qui nécessitent des adresses mémoire, telles "
"que certaines opérations :c:func:`ioctl`. Les nombres renvoyés sont valides "
"tant que le tableau existe et qu'aucune opération qui modifie sa taille ne "
"lui est appliquée."
#: library/array.rst:121
msgid ""

4
library/ast.po
View file

@ -894,7 +894,7 @@ msgstr ""
"Évalue de manière sûre un nœud expression ou une chaîne de caractères "
"contenant une expression littérale Python ou un conteneur. La chaîne de "
"caractères ou le nœud fourni peut seulement faire partie des littéraux "
"Python suivants : chaînes de caractères, bytes, nombres, n-uplets, listes, "
"Python suivants : chaînes de caractères, bytes, nombres, *n*-uplets, listes, "
"dictionnaires, ensembles, booléens, et ``None``."
#: library/ast.rst:1573
@ -990,7 +990,7 @@ msgid ""
"Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields`` "
"that is present on *node*."
msgstr ""
"Produit un n-uplet de ``(fieldname, value)`` pour chaque champ de ``node."
"Produit un *n*-uplet de ``(fieldname, value)`` pour chaque champ de ``node."
"_fields`` qui est présent dans *node*."
#: library/ast.rst:1645

2
library/calendar.po
View file

@ -545,7 +545,7 @@ msgid ""
"encoding. In fact, :func:`time.gmtime` and :func:`timegm` are each others' "
"inverse."
msgstr ""
"Une fonction sans rapport mais pratique, qui prend un n-uplet temporel tel "
"Une fonction sans rapport mais pratique, qui prend un *n*-uplet temporel tel "
"que celui renvoyé par la fonction :func:`~time.gmtime` dans le module :mod:"
"`time`, et renvoie la valeur d'horodatage Unix (*timestamp* en anglais) "
"correspondante, en supposant une époque de 1970, et l'encodage POSIX. En "

8
library/cgitb.po
View file

@ -139,7 +139,7 @@ msgstr ""
"(c'est à dire envoyer un rapport HTML au navigateur sans l'enregistrer dans "
"un fichier). Il peut être utilisé lorsque vous avez intercepté une exception "
"et que vous en voulez un rapport généré par :mod:`cgitb`. L'argument "
"optionnel *info* doit être un *tuple* de trois éléments contenant le type de "
"l'exception, l'exception, et la pile d'appels, tel que le *tuple* renvoyé "
"par :func:`sys.exc_info`. Si l'argument *info* n'est pas donné, l'exception "
"courante est obtenue via :func:`sys.exc_info`."
"optionnel *info* doit être un *n*-uplet de trois éléments contenant le type "
"de l'exception, l'exception, et la pile d'appels, tel que le *n*-uplet "
"renvoyé par :func:`sys.exc_info`. Si l'argument *info* n'est pas donné, "
"l'exception courante est obtenue via :func:`sys.exc_info`."

61
library/collections.po
View file

@ -1121,8 +1121,8 @@ msgstr ""
#: library/collections.rst:810
msgid ":func:`namedtuple` Factory Function for Tuples with Named Fields"
msgstr ""
":func:`namedtuple` : fonction de construction pour *n-uplets* (*tuples*) "
"avec des champs nommés"
":func:`namedtuple` : fonction de construction pour *n*-uplets avec des "
"champs nommés"
#: library/collections.rst:812
msgid ""
@ -1131,10 +1131,11 @@ msgid ""
"are used, and they add the ability to access fields by name instead of "
"position index."
msgstr ""
"Les tuples nommés assignent une signification à chacun de leur élément, ce "
"qui rend le code plus lisible et explicite. Ils peuvent être utilisés "
"partout où les tuples natifs sont utilisés, et ils ajoutent la possibilité "
"d'accéder à leurs champs grâce à leur nom au lieu de leur index de position."
"Les *n*-uplets nommés assignent une signification à chacun de leur élément, "
"ce qui rend le code plus lisible et explicite. Ils peuvent être utilisés "
"partout où les *n*-uplets natifs sont utilisés, et ils ajoutent la "
"possibilité d'accéder à leurs champs grâce à leur nom au lieu de leur index "
"de position."
#: library/collections.rst:818
msgid ""
@ -1145,12 +1146,12 @@ msgid ""
"`__repr__` method which lists the tuple contents in a ``name=value`` format."
msgstr ""
"Renvoie une nouvelle sous-classe de ``tuple`` appelée *typename*. Elle est "
"utilisée pour créer des objets se comportant comme les *tuples* qui ont des "
"champs accessibles par recherche d'attribut en plus d'être indexables et "
"utilisée pour créer des objets se comportant comme les *n*-uplets qui ont "
"des champs accessibles par recherche d'attribut en plus d'être indexables et "
"itérables. Les instances de cette sous-classe possèdent aussi une "
"*docstring* explicite (avec *type_name* et les *field_names*) et une "
"méthode :meth:`__repr__` pratique qui liste le contenu du tuple au format "
"``nom=valeur``."
"méthode :meth:`__repr__` pratique qui liste le contenu du *n*-uplet au "
"format ``nom=valeur``."
#: library/collections.rst:824
msgid ""
@ -1211,15 +1212,16 @@ msgid ""
"set to that value."
msgstr ""
"Si *module* est spécifié, alors il est assigné à l'attribut ``__module__`` "
"du tuple nommé."
"du *n*-uplet nommé."
#: library/collections.rst:849
msgid ""
"Named tuple instances do not have per-instance dictionaries, so they are "
"lightweight and require no more memory than regular tuples."
msgstr ""
"Les instances de tuples nommés n'ont pas de dictionnaires propres, elles "
"sont donc légères et ne requièrent pas plus de mémoire que les tuples natifs."
"Les instances de *n*-uplets nommés n'ont pas de dictionnaires propres, elles "
"sont donc légères et ne requièrent pas plus de mémoire que les *n*-uplets "
"natifs."
#: library/collections.rst:852
msgid "Added support for *rename*."
@ -1252,8 +1254,9 @@ msgid ""
"Named tuples are especially useful for assigning field names to result "
"tuples returned by the :mod:`csv` or :mod:`sqlite3` modules::"
msgstr ""
"Les tuples nommés sont particulièrement utiles pour associer des noms de "
"champs à des tuples renvoyés par les modules :mod:`csv` ou :mod:`sqlite3` ::"
"Les *n*-uplets nommés sont particulièrement utiles pour associer des noms de "
"champs à des *n*-uplets renvoyés par les modules :mod:`csv` ou :mod:"
"`sqlite3` ::"
#: library/collections.rst:901
msgid ""
@ -1261,9 +1264,9 @@ msgid ""
"additional methods and two attributes. To prevent conflicts with field "
"names, the method and attribute names start with an underscore."
msgstr ""
"En plus des méthodes héritées de ``tuple``, les tuples nommés implémentent "
"trois méthodes et deux attributs supplémentaires. Pour éviter les conflits "
"avec noms de champs, leurs noms commencent par un tiret bas."
"En plus des méthodes héritées de ``tuple``, les *n*-uplets nommés "
"implémentent trois méthodes et deux attributs supplémentaires. Pour éviter "
"les conflits avec noms de champs, leurs noms commencent par un tiret bas."
#: library/collections.rst:907
msgid ""
@ -1302,7 +1305,7 @@ msgid ""
"Return a new instance of the named tuple replacing specified fields with new "
"values::"
msgstr ""
"Renvoie une nouvelle instance du tuple nommé en remplaçant les champs "
"Renvoie une nouvelle instance du *n*-uplet nommé en remplaçant les champs "
"spécifiés par leurs nouvelles valeurs ::"
#: library/collections.rst:950
@ -1311,8 +1314,8 @@ msgid ""
"creating new named tuple types from existing named tuples."
msgstr ""
"Tuple de chaînes de caractères listant les noms de champs. Pratique pour "
"l'introspection et pour créer de nouveaux types de tuples nommés à partir "
"d'existants."
"l'introspection et pour créer de nouveaux types de *n*-uplets nommés à "
"partir d'existants."
#: library/collections.rst:965
msgid "Dictionary mapping field names to default values."
@ -1331,8 +1334,8 @@ msgid ""
"To convert a dictionary to a named tuple, use the double-star-operator (as "
"described in :ref:`tut-unpacking-arguments`):"
msgstr ""
"Pour convertir un dictionnaire en tuple nommé, utilisez l'opérateur double-"
"étoile (comme expliqué dans :ref:`tut-unpacking-arguments`) :"
"Pour convertir un dictionnaire en *n*-uplet nommé, utilisez l'opérateur "
"double-étoile (comme expliqué dans :ref:`tut-unpacking-arguments`) :"
#: library/collections.rst:988
msgid ""
@ -1340,8 +1343,8 @@ msgid ""
"functionality with a subclass. Here is how to add a calculated field and a "
"fixed-width print format:"
msgstr ""
"Il est aisé d'ajouter ou de modifier les fonctionnalités des tuples nommés "
"grâce à l'héritage puisqu'il s'agit de simples classes. Voici comment "
"Il est aisé d'ajouter ou de modifier les fonctionnalités des *n*-uplets "
"nommés grâce à l'héritage puisqu'il s'agit de simples classes. Voici comment "
"ajouter un champ calculé avec une longueur fixe d'affichage :"
#: library/collections.rst:1007
@ -1350,7 +1353,7 @@ msgid ""
"keep memory requirements low by preventing the creation of instance "
"dictionaries."
msgstr ""
"La sous-classe ci-dessus définit ``__slots__`` comme un tuple vide. Cela "
"La sous-classe ci-dessus définit ``__slots__`` comme un *n*-uplet vide. Cela "
"permet de garder une emprunte mémoire faible en empêchant la création de "
"dictionnaire d'instance."
@ -1361,7 +1364,7 @@ msgid ""
"attribute:"
msgstr ""
"L'héritage n'est pas pertinent pour ajouter de nouveaux champs. Il est "
"préférable de simplement créer un nouveau type de tuple nommé avec "
"préférable de simplement créer un nouveau type de *n*-uplet nommé avec "
"l'attribut :attr:`~somenamedtuple._fields` :"
#: library/collections.rst:1015
@ -1383,7 +1386,7 @@ msgid ""
"keyword::"
msgstr ""
"Voir :meth:`typing.NamedTuple` pour un moyen d'ajouter des indications de "
"type pour les tuples nommés. Cela propose aussi une notation élégante "
"type pour les *n*-uplets nommés. Cela propose aussi une notation élégante "
"utilisant le mot-clé :keyword:`class` ::"
#: library/collections.rst:1038
@ -1392,7 +1395,7 @@ msgid ""
"underlying dictionary instead of a tuple."
msgstr ""
"Voir :meth:`types.SimpleNamespace` pour un espace de nommage muable basé sur "
"un dictionnaire sous-jacent à la place d'un tuple."
"un dictionnaire sous-jacent à la place d'un *n*-uplet."
#: library/collections.rst:1041
msgid ""

9
library/copyreg.po
View file

@ -55,8 +55,9 @@ msgid ""
"containing two or three elements."
msgstr ""
"Déclare que *function* devrait être utilisée en tant que fonction de "
"*réduction* pour des objets de type *type*. *function* doit soit retourner "
"une chaîne de caractères soit un tuple qui contiens deux ou trois éléments."
"*réduction* pour des objets de type *type*. *function* doit soit renvoyer "
"une chaîne de caractères soit un *n*-uplet qui contient deux ou trois "
"éléments."
#: library/copyreg.rst:34
msgid ""
@ -67,8 +68,8 @@ msgid ""
msgstr ""
"Le paramètre optionnel *contructor*, s'il est donné, est un objet appelable "
"qui peux être utilisé pour reconstruire l’objet lorsqu'il est appelé avec un "
"tuple d'arguments retournés par *function* durant la sérialisation avec "
"*pickle*. Une exception :exc:`TypeError` sera levée si *object* est une "
"*n*-uplet d'arguments renvoyés par *function* durant la sérialisation avec "
"*pickle*. Une exception :exc:`TypeError` est levée si *object* est une "
"classe ou si *constructor* n'est pas appelable."
#: library/copyreg.rst:39

2
library/ctypes.po
View file

@ -906,7 +906,7 @@ msgid ""
msgstr ""
"Il est possible de créer des structures et des unions contenant des champs "
"de bits. Seuls les entiers peuvent être des champs de bits, le nombre de "
"bits est défini dans le troisième champ du n-uplet :attr:`_fields_` ::"
"bits est défini dans le troisième champ du *n*-uplet :attr:`_fields_` ::"
#: library/ctypes.rst:655
msgid "Arrays"

8
library/dataclasses.po
View file

@ -164,7 +164,7 @@ msgid ""
msgstr ""
"``eq``: Si vrai (par défaut), une méthode :meth:`__eq__` est générée. Cette "
"méthode permet de comparer les instances de la classe comme s’il s’agissait "
"d’un tuple de ses champs, dans l’ordre. Les deux instances dans la "
"d’un *n*-uplet de ses champs, dans l’ordre. Les deux instances dans la "
"comparaison doivent être de même type."
#: library/dataclasses.rst:109
@ -184,9 +184,9 @@ msgstr ""
"``order``: Si vrai (``False`` par défaut), les méthodes :meth:`__lt__`, :"
"meth:`__le__`, :meth:`__gt__`, et :meth:`__ge__` sont générées. Elles "
"permettent de comparer les instances de la classe en les considérant comme "
"des tuples, dans l’ordre de définition des champs. Chaque instance dans la "
"comparaison doit être de même type. Si ``order`` est vrai mais que ``eq`` "
"est faux, une :exc:`ValueError` est levée."
"des *n*-uplets, dans l’ordre de définition des champs. Chaque instance dans "
"la comparaison doit être de même type. Si ``order`` est vrai mais que "
"``eq`` est faux, une :exc:`ValueError` est levée."
#: library/dataclasses.rst:119
#, fuzzy

14
library/datetime.po
View file

@ -1689,8 +1689,9 @@ msgstr ""
"analysée conformément à *format*. Cela est équivalent à ``datetime(*(time."
"strptime(date_string, format)[0:6]))``. Une :exc:`ValueError` est levée si "
"*date_string* et *format* ne peuvent être analysée par :func:`time.strptime` "
"ou si elle renvoie une valeur qui n'est pas un *tuple-temps*. Pour une liste "
"complète des directives de formatage, voir :ref:`strftime-strptime-behavior`."
"ou si elle renvoie une valeur qui n'est pas un *n*-uplet de temps. Pour une "
"liste complète des directives de formatage, voir :ref:`strftime-strptime-"
"behavior`."
#: library/datetime.rst:1052
msgid ""
@ -2244,13 +2245,12 @@ msgstr ""
"`weekday`, :meth:`isocalendar`."
#: library/datetime.rst:1405
#, fuzzy
msgid ""
"Return a :term:`named tuple` with three components: ``year``, ``week`` and "
"``weekday``. The same as ``self.date().isocalendar()``."
msgstr ""
"Renvoie un *tuple* de 3 éléments, (année ISO, numéro de semaine ISO, jour de "
"la semaine ISO). Identique à ``self.date().isocalendar()``."
"Renvoie un :term:`n-uplet nommé<named tuple>` de 3 éléments : ``year``, "
"``week`` et ``weekday``. Identique à ``self.date().isocalendar()``."
#: library/datetime.rst:1411
#, fuzzy
@ -4243,5 +4243,5 @@ msgstr ""
#~ msgid "Return a 3-tuple, (ISO year, ISO week number, ISO weekday)."
#~ msgstr ""
#~ "Renvoie un *tuple* de 3 éléments, (année ISO, numéro de semaine ISO, jour "
#~ "de la semaine ISO)."
#~ "Renvoie un *n*-uplet de 3 éléments, (année ISO, numéro de semaine ISO, "
#~ "jour de la semaine ISO)."

2
library/decimal.po
View file

@ -389,7 +389,7 @@ msgid ""
"after leading and trailing whitespace characters, as well as underscores "
"throughout, are removed::"
msgstr ""
"*value* peut être un entier, une chaîne de caractères, un tuple, :class:"
"*value* peut être un entier, une chaîne de caractères, un *n*-uplet, :class:"
"`float`, ou une autre instance de :class:`Decimal`. Si *value* n'est pas "
"fourni, le constructeur renvoie ``Decimal('0')``. Si *value* est une chaîne "
"de caractère, elle doit correspondre à la syntaxe décimale en dehors des "

2
library/dis.po
View file

@ -353,7 +353,7 @@ msgid ""
"The iterator generates a series of :class:`Instruction` named tuples giving "
"the details of each operation in the supplied code."
msgstr ""
"Cet itérateur génère une série de n-uplets de :class:`Instruction` qui "
"Cet itérateur génère une série de *n*-uplets de :class:`Instruction` qui "
"donnent les détails de chacune des opérations dans le code fourni."
#: library/dis.rst:235

6
library/enum.po
View file

@ -636,7 +636,7 @@ msgstr "ou un itérateur sur les noms ::"
#: library/enum.rst:535
msgid "or an iterator of (name, value) pairs::"
msgstr "ou un itérateur sur les tuples (nom, valeur) ::"
msgstr "ou un itérateur sur les *n*-uplets (nom, valeur) ::"
#: library/enum.rst:539
msgid "or a mapping::"
@ -981,8 +981,8 @@ msgid ""
"use a tuple as the value and a custom :meth:`__new__` to replace the tuple "
"with an :class:`int` value"
msgstr ""
"affecter un n-uplet aux valeurs et définir une méthode :meth:`__new__` pour "
"remplacer les n-uplets avec un :class:`int`"
"affecter un *n*-uplet aux valeurs et définir une méthode :meth:`__new__` "
"pour remplacer les *n*-uplets avec un :class:`int`"
#: library/enum.rst:811
msgid ""

10
library/exceptions.po
View file

@ -47,7 +47,7 @@ msgstr ""
"Les exceptions natives présentes ci-dessous peuvent être levées par "
"l'interpréteur ou par les fonctions natives. Sauf mention contraire, une "
"\"valeur associée\" indique la cause de l'erreur. Cela peut être une chaîne "
"ou un *tuple* contenant plusieurs éléments d'information (e.g., un code "
"ou un *n*-uplet contenant plusieurs éléments d'information (e.g., un code "
"d'erreur ou un message explicatif). Cette valeur associée est généralement "
"donnée en argument du constructeur de la classe."
@ -183,10 +183,10 @@ msgid ""
"assign a special meaning to the elements of this tuple, while others are "
"usually called only with a single string giving an error message."
msgstr ""
"Le *tuple* d'arguments donné au constructeur d'exception. Certaines "
"Le *n*-uplet d'arguments donné au constructeur d'exception. Certaines "
"exceptions natives (comme :exc:`OSError`) attendent un certain nombre "
"d'arguments et attribuent une signification spéciale aux éléments de ce "
"*tuple*, alors que d'autres ne sont généralement appelées qu'avec une seule "
"d'arguments et attribuent une signification spéciale aux éléments de ce *n*-"
"uplet, alors que d'autres ne sont généralement appelées qu'avec une seule "
"chaîne de caractères rendant un message d'erreur."
#: library/exceptions.rst:92
@ -439,7 +439,7 @@ msgstr ""
"La deuxième forme du constructeur définit les attributs correspondants, "
"décrits ci-dessous. Les attributs par défaut sont :const:`None` si non "
"spécifiés. Pour la rétrocompatibilité, si trois arguments sont passés, "
"l'attribut :attr:`~BaseException.args` contient seulement un *tuple* à deux "
"l'attribut :attr:`~BaseException.args` contient seulement une paire avec les "
"valeurs des deux premiers arguments du constructeur."
#: library/exceptions.rst:268

18
library/functions.po
View file

@ -1613,10 +1613,10 @@ msgstr ""
"Renvoie ``True`` si *object* est une instance de *classinfo*, ou d'une de "
"ses classes filles, directe, indirecte, ou :term:`abstraite <abstract base "
"class>`. 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 "
"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 "
"un *n*-uplet de types (et récursivement), une exception :exc:`TypeError` est "
"levée."
#: library/functions.rst:854
@ -1629,7 +1629,7 @@ msgid ""
msgstr ""
"Renvoie ``True`` si *class* est une classe fille (directe, indirecte ou :"
"term:`abstraite <abstract base class>`) de *classinfo*. Une classe est "
"considérée sous-classe d'elle-même. *classinfo* peut être un n-uplet de "
"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."
@ -1733,7 +1733,7 @@ msgstr ""
"*iterable* sont fournis, *function* doit prendre autant d'arguments, et sera "
"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 seraient déjà rangés sous forme de n-uplets, voir :func:"
"où les arguments seraient déjà rangés sous forme de *n*-uplets, voir :func:"
"`itertools.starmap`."
#: library/functions.rst:932
@ -3135,10 +3135,10 @@ msgid ""
"argument, it returns an iterator of 1-tuples. With no arguments, it returns "
"an empty iterator. Equivalent to::"
msgstr ""
"Renvoie un itérateur de n-uplets, où le *i*\\ :sup:`e` n-uplet contient le "
"*i*\\ :sup:`e` élément de chacune des séquences ou itérables fournis. "
"Renvoie un itérateur de *n*-uplets, où le *i*\\ :sup:`e` *n*-uplet contient "
"le *i*\\ :sup:`e` élément de chacune des séquences ou itérables fournis. "
"L'itérateur s'arrête lorsque le plus petit itérable fourni est épuisé. Avec "
"un seul argument itérable, elle renvoie un itérateur sur des n-uplets d'un "
"un seul argument itérable, elle renvoie un itérateur sur des *n*-uplets d'un "
"élément. Sans argument, elle renvoie un itérateur vide. Équivalent à ::"
#: library/functions.rst:1750
@ -3152,7 +3152,7 @@ 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)``. Cela duplique le *même* itérateur ``n`` fois tel "
"que le n-uplet obtenu contient le résultat de ``n`` appels à l'itérateur. "
"que 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:1756

10
library/functools.po
View file

@ -575,11 +575,11 @@ msgid ""
"``__dict__``, i.e. the instance dictionary)."
msgstr ""
"Met à jour la fonction *wrapper* pour ressembler à la fonction *wrapped*. "
"Les arguments optionnels sont des tuples 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 "
"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 "

2
library/heapq.po
View file

@ -282,7 +282,7 @@ msgid ""
"Heap elements can be tuples. This is useful for assigning comparison values "
"(such as task priorities) alongside the main record being tracked::"
msgstr ""
"Les éléments d'un tas peuvent être des n-uplets. C'est pratique pour "
"Les éléments d'un tas peuvent être des *n*-uplets. C'est pratique pour "
"assigner des valeurs de comparaison (par exemple, des priorités de tâches) "
"en plus de l'élément qui est suivi ::"

18
library/itertools.po
View file

@ -332,8 +332,8 @@ msgstr "p[, r]"
#: library/itertools.rst:70
msgid "r-length tuples, all possible orderings, no repeated elements"
msgstr ""
"n-uplets de longueur r, tous les ré-arrangements possibles, sans répétition "
"d'éléments"
"*n*-uplets de longueur r, tous les ré-arrangements possibles, sans "
"répétition d'éléments"
#: library/itertools.rst:71
msgid ":func:`combinations`"
@ -345,7 +345,7 @@ msgstr "p, r"
#: library/itertools.rst:71
msgid "r-length tuples, in sorted order, no repeated elements"
msgstr "n-uplets de longueur r, ordonnés, sans répétition d'éléments"
msgstr "*n*-uplets de longueur r, ordonnés, sans répétition d'éléments"
#: library/itertools.rst:72
msgid ":func:`combinations_with_replacement`"
@ -353,7 +353,7 @@ msgstr ":func:`combinations_with_replacement`"
#: library/itertools.rst:72
msgid "r-length tuples, in sorted order, with repeated elements"
msgstr "n-uplets de longueur r, ordonnés, avec répétition d'éléments"
msgstr "*n*-uplets de longueur r, ordonnés, avec répétition d'éléments"
#: library/itertools.rst:76
msgid "Examples"
@ -516,7 +516,7 @@ msgid ""
"the combination tuples will be produced in sorted order."
msgstr ""
"Les combinaisons sont produites dans l'ordre lexicographique. Ainsi, si "
"l'itérable *iterable* est ordonné, les n-uplets de combinaison produits le "
"l'itérable *iterable* est ordonné, les *n*-uplets de combinaison produits le "
"sont aussi."
#: library/itertools.rst:206
@ -768,7 +768,7 @@ msgid ""
"the combination tuples will be produced in sorted order."
msgstr ""
"Les combinaisons sont produites dans l'ordre lexicographique. Ainsi, si "
"l'itérable *iterable* est ordonné, les n-uplets de combinaison produits le "
"l'itérable *iterable* est ordonné, les *n*-uplets de combinaison produits le "
"sont aussi."
#: library/itertools.rst:491
@ -823,7 +823,7 @@ msgstr ""
"Les boucles imbriquées tournent comme un compteur kilométrique avec "
"l'élément le plus à droite avançant à chaque itération. Ce motif défini un "
"ordre lexicographique afin que, si les éléments des itérables en l'entrée "
"sont ordonnés, les n-uplets produits le sont aussi."
"sont ordonnés, les *n*-uplets produits le sont aussi."
#: library/itertools.rst:549
msgid ""
@ -861,7 +861,7 @@ msgstr ""
"Crée un itérateur qui renvoie *object* à l'infini. S'exécute indéfiniment "
"sauf si l'argument *times* est spécifié. Utilisée comme argument de :func:"
"`map` pour les paramètres invariants de la fonction appelée. Aussi utilisée "
"avec :func:`zip` pour créer une partie invariante d'un n-uplet."
"avec :func:`zip` pour créer une partie invariante d'un *n*-uplet."
#: library/itertools.rst:588
msgid ""
@ -882,7 +882,7 @@ msgid ""
msgstr ""
"Crée un itérateur qui exécute la fonction avec les arguments obtenus depuis "
"l'itérable. Utilisée à la place de :func:`map` quand les arguments sont déjà "
"groupés en n-uplets depuis un seul itérable — la donnée a déjà été « pré-"
"groupés en *n*-uplets depuis un seul itérable — la donnée a déjà été « pré-"
"zippée ». La différence entre :func:`map` et :func:`starmap` est similaire à "
"la différence entre ``fonction(a,b)`` et ``fonction(*c)``. À peu près "
"équivalent à ::"

4
library/json.po
View file

@ -215,7 +215,7 @@ msgid ""
"': ')`` otherwise. To get the most compact JSON representation, you should "
"specify ``(',', ':')`` to eliminate whitespace."
msgstr ""
"Si spécifié, *separators* doit être un n-uplet ``(item_separator, "
"Si spécifié, *separators* doit être un *n*-uplet ``(item_separator, "
"key_separator)``. Sa valeur par défaut est ``(', ', ': ')`` si *indent* est "
"``None``, et ``(',', ': ')`` autrement. Pour obtenir la représentation JSON "
"la plus compacte possible, passez ``(',', ':')`` pour éliminer les "
@ -599,7 +599,7 @@ msgid ""
"*s* where the document ended."
msgstr ""
"Décode en document JSON depuis *s* (une instance :class:`str` débutant par "
"un document JSON) et renvoie un n-uplet de 2 éléments contenant la "
"un document JSON) et renvoie un *n*-uplet de 2 éléments contenant la "
"représentation Python de l'objet et l'index dans *s* où le document se "
"terminait."

9
library/mailcap.po
View file

@ -65,11 +65,10 @@ msgid ""
"element is the mailcap entry for a given MIME type. If no matching MIME "
"type can be found, ``(None, None)`` is returned."
msgstr ""
"Renvoie un tuple à deux éléments ; le premier élément est une chaîne de "
"caractères (string) contenant la ligne de commande à exécuter (qui peut être "
"passée à :func:`os.system`), et le second élément est l’entrée *mailcap* "
"pour un type de MIME donné. Si le type MIME n’est pas identifié, ``(None, "
"None)`` est renvoyé."
"Renvoie une paire ; le premier élément est une chaîne de caractères (string) "
"contenant la ligne de commande à exécuter (qui peut être passée à :func:`os."
"system`), et le second élément est l’entrée *mailcap* pour un type de MIME "
"donné. Si le type MIME n’est pas identifié, ``(None, None)`` est renvoyé."
#: library/mailcap.rst:32
msgid ""

2
library/modulefinder.po
View file

@ -68,7 +68,7 @@ msgstr ""
"``sys.path`` est utilisé. *debug* définit le niveau de débogage ; des "
"valeurs plus élevées produisent plus de détails sur ce que fait la classe. "
"*excludes* est une liste de noms de modules à exclure de l'analyse. "
"*replace_paths* est une liste de tuples ``(oldpath, newpath)`` qui seront "
"*replace_paths* est une liste de paires ``(oldpath, newpath)`` qui seront "
"remplacés dans les chemins des modules."
#: library/modulefinder.rst:43

4
library/multiprocessing.po
View file

@ -572,7 +572,7 @@ msgstr ""
"avec :class:`threading.Thread`. *target* est l'objet appelable qui est "
"invoqué par la méthode :meth:`run(). Il vaut ``None`` par défaut, signifiant "
"que rien n'est appelé. *name* est le nom du processus (voir :attr:`name` "
"pour plus de détails). *args* est le *tuple* d'arguments pour l'invocation "
"pour plus de détails). *args* est le *n*-uplet d'arguments pour l'invocation "
"de la cible. *kwargs* est le dictionnaire des arguments nommés pour "
"l'invocation de la cible. S'il est fourni, l'argument nommé *daemon* met "
"l'option :attr:`daemon` du processus à ``True`` ou ``False``. S'il est "
@ -3815,7 +3815,7 @@ msgid ""
"An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where "
"*hostname* is a string and *port* is an integer."
msgstr ""
"Une adresse ``'AF_INET'`` est un *tuple* de la forme ``(hostname, port)`` où "
"Une adresse ``'AF_INET'`` est une paire de la forme ``(hostname, port)`` où "
"*hostname* est une chaîne et *port* un entier."
#: library/multiprocessing.rst:2568

8
library/netrc.po
View file

@ -107,7 +107,7 @@ msgid ""
msgstr ""
"Renvoie un triplet ``(login, account, password)`` pour s'authentifier auprès "
"de l'hôte *host*. Si le fichier *netrc* ne contient pas d'entrée pour l'hôte "
"donné, renvoie le tuple associé à l'entrée par défaut. Si aucun hôte "
"donné, renvoie le triplet associé à l'entrée par défaut. Si aucun hôte "
"correspondant ni aucune entrée par défaut n'est disponible, renvoie ``None``."
#: library/netrc.rst:69
@ -130,9 +130,9 @@ msgid ""
"Dictionary mapping host names to ``(login, account, password)`` tuples. The "
"'default' entry, if any, is represented as a pseudo-host by that name."
msgstr ""
"Dictionnaire faisant correspondre les noms d'hôtes dans des tuples ``(login, "
"account, password)``. L'entrée par défaut, le cas échéant, est représentée "
"en tant que pseudo-hôte par ce nom."
"Dictionnaire faisant correspondre les noms d'hôtes dans des triplets "
"``(login, account, password)``. L'entrée par défaut, le cas échéant, est "
"représentée en tant que pseudo-hôte par ce nom."
#: library/netrc.rst:83
msgid "Dictionary mapping macro names to string lists."

14
library/operator.po
View file

@ -264,8 +264,8 @@ msgid ""
"names can also contain dots. For example:"
msgstr ""
"Renvoie un objet appelable qui récupère *attr* de son opérande. Si plus d'un "
"attribut est demandé, renvoie un n-uplet d'attributs. Les noms des attributs "
"peuvent aussi comporter des points. Par exemple :"
"attribut est demandé, renvoie un *n*-uplet d'attributs. Les noms des "
"attributs peuvent aussi comporter des points. Par exemple :"
#: library/operator.rst:262
msgid "After ``f = attrgetter('name')``, the call ``f(b)`` returns ``b.name``."
@ -299,7 +299,7 @@ msgid ""
msgstr ""
"Renvoie un objet appelable qui récupère *item* de l'opérande en utilisant la "
"méthode :meth:`__getitem__`. Si plusieurs *item* sont passés en paramètre, "
"renvoie un n-uplet des valeurs récupérées. Par exemple :"
"renvoie un *n*-uplet des valeurs récupérées. Par exemple :"
#: library/operator.rst:297
msgid "After ``f = itemgetter(2)``, the call ``f(r)`` returns ``r[2]``."
@ -320,7 +320,7 @@ msgid ""
msgstr ""
"Les *items* en entrée peuvent être de n'importe quel type tant que celui-ci "
"est géré par la méthode :meth:`__getitem__` de l'opérande. Les dictionnaires "
"acceptent toute valeur hachable. Les listes, n-uplets et chaînes de "
"acceptent toute valeur hachable. Les listes, *n*-uplets et chaînes de "
"caractères acceptent un index ou une tranche :"
#: library/operator.rst:331
@ -329,7 +329,7 @@ msgid ""
"record:"
msgstr ""
"Exemple d'utilisation de :func:`itemgetter` pour récupérer des champs "
"spécifiques d'un n-uplet :"
"spécifiques d'un *n*-uplet :"
#: library/operator.rst:344
msgid ""
@ -817,8 +817,8 @@ msgid ""
"value is computed, but not assigned back to the input variable:"
msgstr ""
"Pour des paramètres non-mutables comme les chaînes de caractères, les "
"nombres et les n-uplets, la nouvelle valeur est calculée, mais pas affectée "
"à la variable d'entrée:"
"nombres et les *n*-uplets, la nouvelle valeur est calculée, mais pas "
"affectée à la variable d'entrée:"
#: library/operator.rst:467
msgid ""

51
library/os.po
View file

@ -604,7 +604,7 @@ msgid ""
"Return a tuple (rgid, egid, sgid) denoting the current process's real, "
"effective, and saved group ids."
msgstr ""
"Renvoie un *tuple* (*rgid*, *egid*, *sgid*) dénotant les identifiants des "
"Renvoie un triplet (*rgid*, *egid*, *sgid*) dénotant les identifiants des "
"groupes de processus réel effectif, et sauvé du processus actuel."
#: library/os.rst:420
@ -872,8 +872,8 @@ msgid ""
"Return type changed from a tuple to a tuple-like object with named "
"attributes."
msgstr ""
"Type de retour changé d'un *tuple* en un objet compatible avec le type "
"*tuple*, avec des attributs nommés."
"type de retour changé d'un quintuplet en un objet compatible avec le type "
"*n*-uplet, avec des attributs nommés."
#: library/os.rst:642
msgid ""
@ -3893,14 +3893,14 @@ msgid ""
"class:`stat_result` as a tuple always returns integers."
msgstr ""
"Pour des raisons de rétro-compatibilité, une instance du :class:"
"`stat_result` est également accessible comme un tuple d'au moins 10 valeurs "
"entières donnant les membres les plus importants (et portables) de la "
"structure :c:type:`stat`, dans l'ordre : :attr:`st_mode`, :attr:`st_ino`, :"
"attr:`st_dev`, :attr:`st_nlink`, :attr:`st_uid`, :attr:`st_gid`, :attr:"
"`st_size`, :attr:`st_atime`, :attr:`st_mtime`, :attr:`st_ctime`. Plus "
"`stat_result` est également accessible comme un *n*-uplet d'au moins 10 "
"valeurs entières donnant les membres les plus importants (et portables) de "
"la structure :c:type:`stat`, dans l'ordre : :attr:`st_mode`, :attr:"
"`st_ino`, :attr:`st_dev`, :attr:`st_nlink`, :attr:`st_uid`, :attr:`st_gid`, :"
"attr:`st_size`, :attr:`st_atime`, :attr:`st_mtime`, :attr:`st_ctime`. Plus "
"d'éléments peuvent être ajoutés à la fin par certaines implémentations. Pour "
"une compatibilité avec les anciennes versions de Python, accéder à un "
"élément de type :class:`stat_result` comme un tuple donne toujours des "
"élément de type :class:`stat_result` comme un *n*-uplet donne toujours des "
"entiers."
#: library/os.rst:2701
@ -4271,7 +4271,8 @@ msgstr ""
#: library/os.rst:2960
msgid "It is an error to specify tuples for both *times* and *ns*."
msgstr "Il est erroné de spécifier des tuples pour *times* et *ns* à la fois."
msgstr ""
"Il est erroné de spécifier des *n*-uplets pour *times* et *ns* à la fois."
#: library/os.rst:2962
#, fuzzy
@ -4356,8 +4357,8 @@ msgstr ""
"``False``, le triplet pour un répertoire est généré après les triplets de "
"tous ses sous-répertoires (les répertoires sont générés de bas-en-haut). Peu "
"importe la valeur de *topdown*, la liste des sous-répertoires est récupérée "
"avant que les tuples pour le répertoires et ses sous-répertoires ne soient "
"générés."
"avant que les *n*-uplets pour le répertoires et ses sous-répertoires ne "
"soient générés."
#: library/os.rst:3012
msgid ""
@ -4819,7 +4820,7 @@ msgstr ""
"paramètres est fixé lors de l'écriture du code. Les paramètres individuels "
"deviennent alors des paramètres additionnels aux fonctions :func:`exec\\*`. "
"Les variantes « v » sont préférables quand le nombre de paramètres est "
"variable et qu'ils sont passés dans une liste ou un *tuple* dans le "
"variable et qu'ils sont passés dans une liste ou un *n*-uplet dans le "
"paramètre *args*. Dans tous les cas, les arguments aux processus fils "
"devraient commencer avec le nom de la commande à lancer, mais ce n'est pas "
"obligatoire."
@ -5492,7 +5493,7 @@ msgstr ""
"de paramètres est fixé lors de l'écriture du code. Les paramètres "
"individuels deviennent alors des paramètres additionnels aux fonctions :func:"
"`spawn\\*`. Les variantes « v » sont préférables quand le nombre de "
"paramètres est variable et qu'ils sont passés dans une liste ou un *tuple* "
"paramètres est variable et qu'ils sont passés dans une liste ou un *n*-uplet "
"dans le paramètre *args*. Dans tous les cas, les arguments aux processus "
"fils devraient commencer avec le nom de la commande à lancer, mais ce n'est "
"pas obligatoire."
@ -5782,7 +5783,7 @@ msgid ""
"`children_system`, and :attr:`elapsed` in that order."
msgstr ""
"Pour des raisons de rétro-compatibilité, cet objet se comporte également "
"comme un *tuple* contenant :attr:`user`, :attr:`system`, :attr:"
"comme un quintuplet contenant :attr:`user`, :attr:`system`, :attr:"
"`children_user`, :attr:`children_system`, et :attr:`elapsed` dans cet ordre."
#: library/os.rst:4009
@ -5806,7 +5807,7 @@ msgid ""
"status (if the signal number is zero); the high bit of the low byte is set "
"if a core file was produced."
msgstr ""
"Attend qu'un processus fils soit complété, et renvoie un *tuple* contenant "
"Attend qu'un processus fils soit complété, et renvoie une paire contenant "
"son PID et son état de sortie : un nombre de 16 bits dont le *byte* de poids "
"faible est le nombre correspondant au signal qui a tué le processus, et dont "
"le *byte* de poids fort est le statut de sortie (si la signal vaut ``0``). "
@ -5901,10 +5902,10 @@ msgid ""
"operation."
msgstr ""
"Sur Unix : attend qu'un processus fils donné par son id de processus *pid* "
"soit terminé, et renvoie un *tuple* contenant son PID et son statut de "
"sortie (encodé comme pour :func:`wait`). La sémantique de cet appel est "
"affecté par la valeur de l'argument entier *options*, qui devrait valoir "
"``0`` pour les opérations normales."
"soit terminé, et renvoie une paire contenant son PID et son statut de sortie "
"(encodé comme pour :func:`wait`). La sémantique de cet appel est affecté par "
"la valeur de l'argument entier *options*, qui devrait valoir ``0`` pour les "
"opérations normales."
#: library/os.rst:4116
msgid ""
@ -5943,13 +5944,13 @@ msgid ""
"process handles."
msgstr ""
"Sur Windows : attend que qu'un processus donné par l'identificateur de "
"processus (*process handle*) *pid* soi complété, et renvoie un *tuple* "
"contenant *pid* et son statut de sortir décalé de 8 bits bers la gauche (le "
"processus (*process handle*) *pid* soit complété, et renvoie une paire "
"contenant *pid* et son statut de sortie décalé de 8 bits vers la gauche (le "
"décalage rend l'utilisation multiplate-forme plus facile). Un *pid* "
"inférieur ou égal à ``0`` n'a aucune signification particulière sur Windows, "
"inférieur ou égal à ``0`` n'a aucune signification particulière en Windows, "
"et lève une exception. L'argument entier *options* n'a aucun effet. *pid* "
"peut faire référence à tout processus dont l'identifiant est connue pas "
"nécessairement un processus fils. Les fonctions :func:`spawn\\* <spawnl>` "
"peut faire référence à tout processus dont l'identifiant est connu et pas "
"nécessairement à un processus fils. Les fonctions :func:`spawn\\* <spawnl>` "
"appelées avec :const:`P_NOWAIT` renvoient des identificateurs de processus "
"appropriés."

2
library/platform.po
View file

@ -220,7 +220,7 @@ msgstr ""
#: library/platform.rst:178
msgid "Result changed from a tuple to a namedtuple."
msgstr "Le type renvoyé passe d'un *tuple* à un *namedtuple*."
msgstr "Le type renvoyé passe d'un sextuplet à un *namedtuple*."
#: library/platform.rst:183
msgid "Java Platform"

4
library/queue.po
View file

@ -129,8 +129,8 @@ msgid ""
msgstr ""
"Les éléments de valeurs les plus faibles sont extraits en premier (l'élément "
"de valeur la plus faible est celui renvoyé par ``sorted(list(entries))"
"[0]``). Un cas typique est d'utiliser des tuple de la forme : "
"``(priority_number, data)``."
"[0]``). On utilise souvent des paires de la forme : ``(priority_number, "
"data)``."
#: library/queue.rst:63
msgid ""

14
library/re.po
View file

@ -1551,8 +1551,8 @@ msgstr ""
"chevauchent pas, sous forme d'une liste de chaînes. La chaîne *string* est "
"analysée de la gauche vers la droite, et les correspondances sont renvoyées "
"dans l'ordre où elles sont trouvées. Si un groupe ou plus sont présents "
"dans le motif, renvoie une liste de groupes ; il s'agira d'une liste de "
"*tuples* si le motif a plus d'un groupe. Les correspondances vides sont "
"dans le motif, renvoie une liste de groupes ; il s'agira d'une liste de *n*-"
"uplets si le motif a plus d'un groupe. Les correspondances vides sont "
"incluses dans le résultat."
#: library/re.rst:843
@ -1687,7 +1687,7 @@ msgid ""
"Perform the same operation as :func:`sub`, but return a tuple ``(new_string, "
"number_of_subs_made)``."
msgstr ""
"Réalise la même opération que :func:`sub`, mais renvoie un *tuple* "
"Réalise la même opération que :func:`sub`, mais renvoie une paire "
"``(nouvelle_chaîne, nombre_de_substitutions_réalisées)``."
#: library/re.rst:930
@ -1986,7 +1986,7 @@ msgid ""
msgstr ""
"Renvoie un ou plus sous-groupes de la correspondance. Si un seul argument "
"est donné, le résultat est une chaîne simple ; s'il y a plusieurs arguments, "
"le résultat est un *tuple* comprenant un élément par argument. Sans "
"le résultat est un *n*-uplet comprenant un élément par argument. Sans "
"arguments, *group1* vaut par défaut zéro (la correspondance entière est "
"renvoyée). Si un argument *groupN* vaut zéro, l'élément associé sera la "
"chaîne de correspondance entière ; s'il est dans l'intervalle fermé [1..99], "
@ -2036,8 +2036,8 @@ msgid ""
"however many groups are in the pattern. The *default* argument is used for "
"groups that did not participate in the match; it defaults to ``None``."
msgstr ""
"Renvoie un *tuple* contenant tous les sous-groupes de la correspondance, de "
"1 jusqu'au nombre de groupes dans le motif. L'argument *default* est "
"Renvoie un *n*-uplet contenant tous les sous-groupes de la correspondance, "
"de 1 jusqu'au nombre de groupes dans le motif. L'argument *default* est "
"utilisé pour les groupes sans correspondance ; il vaut ``None`` par défaut."
#: library/re.rst:1453
@ -2104,7 +2104,7 @@ msgid ""
"that if *group* did not contribute to the match, this is ``(-1, -1)``. "
"*group* defaults to zero, the entire match."
msgstr ""
"Pour un objet de correspondance *m*, renvoie le *tuple* ``(m.start(group), m."
"Pour un objet de correspondance *m*, renvoie la paire ``(m.start(group), m."
"end(group))``. Notez que si *group* ne figure pas dans la correspondance, "
"``(-1, -1)`` est renvoyé. *group* vaut par défaut zéro, pour la "
"correspondance entière."

6
library/sndhdr.po
View file

@ -51,8 +51,8 @@ msgstr ""
"même, *channels* vaut soit le nombre de canaux soit ``0`` s'il ne peut pas "
"être déterminé ou si la valeur est compliquée à décoder. La valeur de "
"*frames* sera soit le nombre de *frames* soit ``-1``. Le dernier élément du "
"tuple, *bits_per_sample* sera soit la taille d'un échantillon en bits, soit "
"``'A'`` pour *A-LAW* ou ``'U'`` pour *u-LAW*."
"*n*-uplet, *bits_per_sample* sera soit la taille d'un échantillon en bits, "
"soit ``'A'`` pour *A-LAW* ou ``'U'`` pour *u-LAW*."
#: library/sndhdr.rst:35
msgid ""
@ -66,7 +66,7 @@ msgstr ""
#: library/sndhdr.rst:49
msgid "Result changed from a tuple to a namedtuple."
msgstr "Le type renvoyé passe d'un *tuple* à un *namedtuple*."
msgstr "Le type renvoyé passe d'un *n*-uplet à un *n*-uplet nommé."
#: library/sndhdr.rst:45
msgid ""

6
library/spwd.po
View file

@ -43,9 +43,9 @@ msgid ""
"field below, see ``<shadow.h>``):"
msgstr ""
"Les entrées de la base de données de mots de passe *shadow* sont renvoyées "
"comme un objet semblable à un tuple, dont les attributs correspondent aux "
"membres de la structure ``spwd`` (champ attribut ci-dessous, voir ``<shadow."
"h>``) :"
"comme un objet semblable à un *n*-uplet, dont les attributs correspondent "
"aux membres de la structure ``spwd`` (champ attribut ci-dessous, voir "
"``<shadow.h>``) :"
#: library/spwd.rst:21
msgid "Index"

4
library/sqlite3.po
View file

@ -106,7 +106,7 @@ msgid ""
msgstr ""
"À la place, utilisez la capacité DB-API de substitution des paramètres. "
"Placez un ``?`` comme indicateur partout où vous voulez utiliser une valeur, "
"puis fournissez un *tuple* de valeurs comme second argument de la méthode :"
"puis fournissez un *n*-uplet de valeurs comme second argument de la méthode :"
"meth:`~Cursor.execute`. D'autres modules de base de données peuvent utiliser "
"un espace réservé différent, tel que ``%s`` ou ``:1``. Par exemple ::"
@ -184,7 +184,7 @@ msgid ""
"The version number of this module, as a tuple of integers. This is not the "
"version of the SQLite library."
msgstr ""
"Le numéro de version de ce module, sous forme d'un n-uplet d'entiers. Ce "
"Le numéro de version de ce module, sous forme d'un *n*-uplet d'entiers. Ce "
"n'est pas la version de la bibliothèque SQLite."
#: library/sqlite3.rst:137

180
library/stdtypes.po
View file

@ -1345,10 +1345,11 @@ msgid ""
"<binaryseq>` and :ref:`text strings <textseq>` are described in dedicated "
"sections."
msgstr ""
"Il existe trois types séquentiels basiques: les *lists*, *tuples* et les "
"*range*. D'autres types séquentiels spécifiques au traitement de :ref:"
"`données binaires <binaryseq>` et :ref:`chaînes de caractères <textseq>` "
"sont décrits dans des sections dédiées."
"Il existe trois types séquentiels basiques: les listes (objets *list*), *n*-"
"uplets (objets *tuple*) et les intervalles (objets *range*). D'autres types "
"séquentiels spécifiques au traitement de :ref:`données binaires "
"<binaryseq>` et :ref:`chaînes de caractères <textseq>` sont décrits dans des "
"sections dédiées."
#: library/stdtypes.rst:828
msgid "Common Sequence Operations"
@ -1519,8 +1520,8 @@ msgid ""
"(For full details see :ref:`comparisons` in the language reference.)"
msgstr ""
"Les séquences du même type supportent également la comparaison. En "
"particulier, les n-uplets et les listes sont comparés lexicographiquement en "
"comparant les éléments correspondants. Cela signifie que pour que deux "
"particulier, les *n*-uplets et les listes sont comparés lexicographiquement "
"en comparant les éléments correspondants. Cela signifie que pour que deux "
"séquences soit égales, les éléments les constituant doivent être égaux deux "
"à deux et les deux séquences doivent être du même type et de la même "
"longueur. (Pour plus de détails voir :ref:`comparisons` dans la référence du "
@ -2112,26 +2113,27 @@ msgid ""
"homogeneous data is needed (such as allowing storage in a :class:`set` or :"
"class:`dict` instance)."
msgstr ""
"Les tuples (*n-uplets* en français) sont des séquences immuables, "
"Les *n*-uplets (*tuples* en anglais) sont des séquences immuables, "
"généralement utilisées pour stocker des collections de données hétérogènes "
"(tels que les tuples de deux éléments produits par la fonction native :func:"
"`enumerate`). Les tuples sont également utilisés dans des cas où une "
"séquence homogène et immuable de données est nécessaire (pour, par exemple, "
"les stocker dans un :class:`set` ou un :class:`dict`)."
"(telles que les paires produites par la fonction native :func:`enumerate`). "
"Les *n*-uplets sont également utilisés dans des cas où une séquence homogène "
"et immuable de données est nécessaire (pour, par exemple, les stocker dans "
"un :class:`set` ou un :class:`dict`)."
#: library/stdtypes.rst:1234
msgid "Tuples may be constructed in a number of ways:"
msgstr "Les tuples peuvent être construits de différentes façons :"
msgstr "Les *n*-uplets peuvent être construits de différentes façons :"
#: library/stdtypes.rst:1236
msgid "Using a pair of parentheses to denote the empty tuple: ``()``"
msgstr ""
"En utilisant une paire de parenthèses pour désigner le tuple vide : ``()``"
"En utilisant une paire de parenthèses pour désigner le *n*-uplet vide : "
"``()``"
#: library/stdtypes.rst:1237
msgid "Using a trailing comma for a singleton tuple: ``a,`` or ``(a,)``"
msgstr ""
"En utilisant une virgule, pour créer un tuple d'un élément : ``a,`` ou "
"En utilisant une virgule, pour créer un *n*-uplet d'un élément : ``a,`` ou "
"``(a,)``"
#: library/stdtypes.rst:1238
@ -2155,13 +2157,13 @@ msgid ""
"3)``. If no argument is given, the constructor creates a new empty tuple, "
"``()``."
msgstr ""
"Le constructeur construit un tuple dont les éléments sont les mêmes et dans "
"le même ordre que les éléments de *iterable*. *iterable* peut être soit une "
"séquence, un conteneur qui supporte l'itération, soit un itérateur. Si "
"*iterable* est déjà un tuple, il est renvoyé inchangé. Par exemple, "
"``tuple('abc')`` renvoie ``('a', 'b', 'c')`` et ``tuple( [1, 2, 3] )`` "
"renvoie ``(1, 2, 3)``. Si aucun argument est donné, le constructeur crée un "
"nouveau tuple vide, ``()``."
"Le constructeur construit un *n*-uplet dont les éléments sont les mêmes et "
"dans le même ordre que les éléments de *iterable*. *iterable* peut être soit "
"une séquence, un conteneur qui prend en charge l'itération, soit un "
"itérateur. Si *iterable* est déjà un *n*-uplet, il est renvoyé inchangé. Par "
"exemple, ``tuple('abc')`` renvoie ``('a', 'b', 'c')`` et ``tuple( [1, 2, "
"3] )`` renvoie ``(1, 2, 3)``. Si aucun argument est donné, le constructeur "
"crée un nouveau *n*-uplet vide, ``()``."
#: library/stdtypes.rst:1249
msgid ""
@ -2171,19 +2173,19 @@ msgid ""
"function call with three arguments, while ``f((a, b, c))`` is a function "
"call with a 3-tuple as the sole argument."
msgstr ""
"Notez que c'est en fait la virgule qui fait un tuple et non les parenthèses. "
"Les parenthèses sont facultatives, sauf dans le cas du tuple vide, ou "
"lorsqu'elles sont nécessaires pour éviter l'ambiguïté syntaxique. Par "
"exemple, ``f(a, b, c)`` est un appel de fonction avec trois arguments, alors "
"que ``f((a, b, c))`` est un appel de fonction avec un tuple de trois "
"éléments comme unique argument."
"Notez que c'est en fait la virgule qui fait un *n*-uplet et non les "
"parenthèses. Les parenthèses sont facultatives, sauf dans le cas du *n*-"
"uplet vide, ou lorsqu'elles sont nécessaires pour éviter l'ambiguïté "
"syntaxique. Par exemple, ``f(a, b, c)`` est un appel de fonction avec trois "
"arguments, alors que ``f((a, b, c))`` est un appel de fonction avec un "
"triplet comme unique argument."
#: library/stdtypes.rst:1255
msgid ""
"Tuples implement all of the :ref:`common <typesseq-common>` sequence "
"operations."
msgstr ""
"Les tuples implémentent toutes les opérations :ref:`communes <typesseq-"
"Les *n*-uplets implémentent toutes les opérations :ref:`communes <typesseq-"
"common>` des séquences."
#: library/stdtypes.rst:1258
@ -2194,7 +2196,7 @@ msgid ""
msgstr ""
"Pour les collections hétérogènes de données où l'accès par nom est plus "
"clair que l'accès par index, :func:`collections.namedtuple` peut être un "
"choix plus approprié qu'un simple tuple."
"choix plus approprié qu'un simple *n*-uplet."
#: library/stdtypes.rst:1266
msgid "Ranges"
@ -2691,10 +2693,10 @@ msgid ""
"*end*, stop comparing at that position."
msgstr ""
"Donne ``True`` si la chaîne se termine par *suffix*, sinon ``False``. "
"*suffix* peut aussi être un tuple de suffixes à rechercher. Si l'argument "
"optionnel *start* est donné, le test se fait à partir de cette position. Si "
"l'argument optionnel *end* est fourni, la comparaison s'arrête à cette "
"position."
"*suffix* peut aussi être un *n*-uplet de suffixes à rechercher. Si "
"l'argument optionnel *start* est donné, le test se fait à partir de cette "
"position. Si l'argument optionnel *end* est fourni, la comparaison s'arrête "
"à cette position."
#: library/stdtypes.rst:1582
msgid ""
@ -3092,10 +3094,10 @@ msgid ""
"after the separator. If the separator is not found, return a 3-tuple "
"containing the string itself, followed by two empty strings."
msgstr ""
"Divise la chaîne à la première occurrence de *sep*, et donne un *tuple* de "
"trois éléments contenant la partie avant le séparateur, le séparateur lui-"
"même, et la partie après le séparateur. Si le séparateur n'est pas trouvé, "
"le *tuple* contiendra la chaîne elle-même, suivie de deux chaînes vides."
"Divise la chaîne à la première occurrence de *sep*, et donne un triplet "
"contenant la partie avant le séparateur, le séparateur lui-même, et la "
"partie après le séparateur. Si le séparateur n'est pas trouvé, le triplet "
"contiendra la chaîne elle-même, suivie de deux chaînes vides."
#: library/stdtypes.rst:1866
msgid ""
@ -3162,10 +3164,10 @@ msgid ""
"after the separator. If the separator is not found, return a 3-tuple "
"containing two empty strings, followed by the string itself."
msgstr ""
"Divise la chaîne à la dernière occurrence de *sep*, et donne un tuple de "
"trois éléments contenant la partie avant le séparateur, le séparateur lui-"
"même, et la partie après le séparateur. Si le séparateur n'est pas trouvé, "
"le *tuple* contiendra deux chaînes vides, puis par la chaîne elle-même."
"Divise la chaîne à la dernière occurrence de *sep*, et donne un triplet "
"contenant la partie avant le séparateur, le séparateur lui-même, et la "
"partie après le séparateur. Si le séparateur n'est pas trouvé, le triplet "
"contiendra deux chaînes vides, puis par la chaîne elle-même."
#: library/stdtypes.rst:1929
msgid ""
@ -3394,9 +3396,9 @@ msgid ""
"*end*, stop comparing string at that position."
msgstr ""
"Donne ``True`` si la chaîne commence par *prefix*, sinon ``False``. "
"*prefix* peut aussi être un tuple de préfixes à rechercher. Lorsque *start* "
"est donné, la comparaison commence à cette position, et lorsque *end* est "
"donné, la comparaison s'arrête à celle ci."
"*prefix* peut aussi être un *n*-uplet de préfixes à rechercher. Lorsque "
"*start* est donné, la comparaison commence à cette position, et lorsque "
"*end* est donné, la comparaison s'arrête à celle ci."
#: library/stdtypes.rst:2072
msgid ""
@ -3548,8 +3550,8 @@ msgid ""
"or extensibility."
msgstr ""
"Ces opérations de mise en forme contiennent des bizarreries menant à de "
"nombreuses erreurs classiques (telles que ne pas réussir à afficher des "
"*tuples* ou des dictionnaires correctement). Utiliser les :ref:`formatted "
"nombreuses erreurs classiques (telles que ne pas réussir à afficher des *n*-"
"uplets ou des dictionnaires correctement). Utiliser les :ref:`formatted "
"string literals <f-strings>`, la méthode :meth:`str.format` ou les :ref:"
"`template strings <template-strings>` aide à éviter ces erreurs. Chacune de "
"ces alternatives apporte son lot d'avantages et inconvénients en matière de "
@ -3579,8 +3581,8 @@ msgid ""
"example, a dictionary)."
msgstr ""
"Si *format* ne nécessite qu'un seul argument, *values* peut être un objet "
"unique. [5]_ Si *values* est un tuple, il doit contenir exactement le nombre "
"d'éléments spécifiés par la chaîne de format, ou un seul objet de "
"unique. [5]_ Si *values* est un *n*-uplet, il doit contenir exactement le "
"nombre d'éléments spécifiés par la chaîne de format, ou un seul objet de "
"correspondances ( *mapping object*, par exemple, un dictionnaire)."
#: library/stdtypes.rst:3438
@ -3618,8 +3620,8 @@ msgid ""
"object to convert comes after the minimum field width and optional precision."
msgstr ""
"Largeur minimum (facultative). Si elle vaut ``'*'`` (astérisque), la largeur "
"est lue de l'élément suivant du tuple *values*, et l'objet à convertir vient "
"après la largeur de champ minimale et la précision facultative."
"est lue de l'élément suivant du *n*-uplet *values*, et l'objet à convertir "
"vient après la largeur de champ minimale et la précision facultative."
#: library/stdtypes.rst:3453
msgid ""
@ -3630,8 +3632,8 @@ msgid ""
msgstr ""
"Précision (facultatif), donnée sous la forme d'un ``'.'`` (point) suivi de "
"la précision. Si la précision est ``'*'`` (un astérisque), la précision est "
"lue à partir de l'élément suivant du tuple *values* et la valeur à convertir "
"vient ensuite."
"lue à partir de l'élément suivant du *n*-uplet *values* et la valeur à "
"convertir vient ensuite."
#: library/stdtypes.rst:3458
msgid "Length modifier (optional)."
@ -4174,8 +4176,8 @@ msgid ""
"object of length 1. (This contrasts with text strings, where both indexing "
"and slicing will produce a string of length 1)"
msgstr ""
"Comme les objets *bytes* sont des séquences d'entiers (semblables à un "
"tuple), pour une instance de *bytes* *b*, ``b[0]`` sera un entier, tandis "
"Comme les objets *bytes* sont des séquences d'entiers (semblables à un *n*-"
"uplet), pour une instance de *bytes* *b*, ``b[0]`` sera un entier, tandis "
"que``b[0:1]`` sera un objet *bytes* de longueur 1. (Cela contraste avec les "
"chaînes, où l'indexation et le *slicing* donne une chaîne de longueur 1)"
@ -4512,9 +4514,10 @@ msgid ""
"optional *end*, stop comparing at that position."
msgstr ""
"Donne ``True`` si les octets se terminent par *suffix*, sinon ``False``. "
"*suffix* peut aussi être un tuple de suffixes à rechercher. Avec l'argument "
"optionnel *start*, la recherche se fait à partir de cette position. Avec "
"l'argument optionnel *end*, la comparaison s'arrête à cette position."
"*suffix* peut aussi être un *n*-uplet de suffixes à rechercher. Avec "
"l'argument optionnel *start*, la recherche se fait à partir de cette "
"position. Avec l'argument optionnel *end*, la comparaison s'arrête à cette "
"position."
#: library/stdtypes.rst:2715
msgid "The suffix(es) to search for may be any :term:`bytes-like object`."
@ -4589,10 +4592,10 @@ msgid ""
"found, return a 3-tuple containing a copy of the original sequence, followed "
"by two empty bytes or bytearray objects."
msgstr ""
"Divise la séquence à la première occurrence de *sep*, et renvoie un 3-tuple "
"Divise la séquence à la première occurrence de *sep*, et renvoie un triplet "
"contenant la partie précédant le séparateur, le séparateur lui même (ou sa "
"copie en *byterray*), et la partie suivant le séparateur. Si le séparateur "
"est pas trouvé, le 3-tuple renvoyé contiendra une copie de la séquence "
"est pas trouvé, le triplet renvoyé contiendra une copie de la séquence "
"d'origine, suivi de deux *bytes* ou *bytearray* vides."
#: library/stdtypes.rst:2844
@ -4659,9 +4662,9 @@ msgid ""
"optional *end*, stop comparing at that position."
msgstr ""
"Donne ``True`` si les données binaires commencent par le *prefix* spécifié, "
"sinon ``False``. *prefix* peut aussi être un tuple de préfixes à rechercher. "
"Avec l'argument *start* la recherche commence à cette position. Avec "
"l'argument *end* option, la recherche s'arrête à cette position."
"sinon ``False``. *prefix* peut aussi être un *n*-uplet de préfixes à "
"rechercher. Avec l'argument *start* la recherche commence à cette position. "
"Avec l'argument *end* option, la recherche s'arrête à cette position."
#: library/stdtypes.rst:2855
msgid "The prefix(es) to search for may be any :term:`bytes-like object`."
@ -5137,9 +5140,9 @@ msgid ""
msgstr ""
"Les opérations de formatage décrites ici présentent une variété de "
"bizarreries qui conduisent à un certain nombre d’erreurs classiques "
"(typiquement, échouer à afficher des tuples ou des dictionnaires "
"correctement). Si la valeur à afficher peut être un tuple ou un "
"dictionnaire, mettez le a l'intérieur d'un autre tuple."
"(typiquement, échouer à afficher des *n*-uplets ou des dictionnaires "
"correctement). Si la valeur à afficher peut être un *n*-uplet ou un "
"dictionnaire, mettez le a l'intérieur d'un autre *n*-uplet."
#: library/stdtypes.rst:3421
msgid ""
@ -5165,8 +5168,8 @@ msgid ""
"example, a dictionary)."
msgstr ""
"Si *format* ne nécessite qu'un seul argument, *values* peut être un objet "
"unique. [5]_ Si *values* est un tuple, il doit contenir exactement le nombre "
"d'éléments spécifiés dans le format en *bytes*, ou un seul objet de "
"unique. [5]_ Si *values* est un *n*-uplet, il doit contenir exactement le "
"nombre d'éléments spécifiés dans le format en *bytes*, ou un seul objet de "
"correspondances ( *mapping object*, par exemple, un dictionnaire)."
#: library/stdtypes.rst:3462
@ -5310,13 +5313,13 @@ msgid ""
"memoryviews can be indexed with the empty tuple."
msgstr ""
"Si le :class:`~memoryview.format` est un des formats natif du module :mod:"
"`struct`, indexer avec un nombre entier ou un *tuple* de nombres entiers est "
"aussi autorisé et renvoie un seul *element* du bon type. Les *memoryview* à "
"une dimension peuvent être indexées avec un nombre entier ou un *tuple* d'un "
"entier. Les *memoryview* multi-dimensionnelles peuvent être indexées avec "
"des *tuples* d'exactement *ndim* entiers où *ndim* est le nombre de "
"dimensions. Les *memoryviews* à zéro dimension peuvent être indexées avec "
"un *tuple* vide."
"`struct`, indexer avec un nombre entier ou un *n*-uplet de nombres entiers "
"est aussi autorisé et renvoie un seul *element* du bon type. Les "
"*memoryview* à une dimension peuvent être indexées avec un nombre entier ou "
"un *n*-uplet d'un entier. Les *memoryview* multi-dimensionnelles peuvent "
"être indexées avec des *ndim*-uplets où *ndim* est le nombre de dimensions. "
"Les *memoryviews* à zéro dimension peuvent être indexées avec un *n*-uplet "
"vide."
#: library/stdtypes.rst:3653
msgid "Here is an example with a non-byte format::"
@ -5361,7 +5364,7 @@ msgstr ""
#: library/stdtypes.rst:3706
msgid "memoryviews can now be indexed with tuple of integers."
msgstr ""
"les *memoryviews* peut maintenant être indexées par un n-uplet d'entiers."
"les *memoryviews* peut maintenant être indexées par un *n*-uplet d'entiers."
#: library/stdtypes.rst:3709
msgid ":class:`memoryview` has several methods:"
@ -5630,19 +5633,19 @@ msgid ""
"A tuple of integers the length of :attr:`ndim` giving the shape of the "
"memory as an N-dimensional array."
msgstr ""
"Un *tuple* d'entiers de longueur :attr:`ndim` donnant la forme de la "
"Un *n*-uplet d'entiers de longueur :attr:`ndim` donnant la forme de la "
"*memoryview* sous forme d'un tableau à N dimensions."
#: library/stdtypes.rst:4054
msgid "An empty tuple instead of ``None`` when ndim = 0."
msgstr "Un *tuple* vide au lieu de ``None`` lorsque *ndim = 0*."
msgstr "Un *n*-uplet vide au lieu de ``None`` lorsque *ndim = 0*."
#: library/stdtypes.rst:4051
msgid ""
"A tuple of integers the length of :attr:`ndim` giving the size in bytes to "
"access each element for each dimension of the array."
msgstr ""
"Un *tuple* d'entiers de longueur :attr:`ndim` donnant la taille en octets "
"Un *n*-uplet d'entiers de longueur :attr:`ndim` donnant la taille en octets "
"permettant d'accéder à chaque dimensions du tableau."
#: library/stdtypes.rst:4059
@ -6305,9 +6308,10 @@ msgid ""
"pairs: ``d.update(red=1, blue=2)``."
msgstr ""
":meth:`update` accepte aussi bien un autre dictionnaire qu'un itérable de "
"clef/valeurs (sous forme de *tuples* ou autre itérables de longueur deux). "
"Si des paramètres par mot-clef sont donnés, le dictionnaire et ensuite mis à "
"jour avec ces pairs de clef/valeurs : ``d.update(red=1, blue=2)``."
"clef/valeurs (sous forme de *n*-uplets ou autres itérables de longueur "
"deux). Si des paramètres par mot-clef sont donnés, le dictionnaire et "
"ensuite mis à jour avec ces pairs de clef/valeurs : ``d.update(red=1, "
"blue=2)``."
#: library/stdtypes.rst:4485
msgid ""
@ -6420,7 +6424,7 @@ msgid ""
"``(key, value)``) in the dictionary."
msgstr ""
"Renvoie un itérateur sur les clefs, les valeurs, ou les éléments "
"(représentés par des *tuples* de ``(key, value)`` du dictionnaire."
"(représentés par des paires ``(key, value)`` du dictionnaire."
#: library/stdtypes.rst:4581
msgid ""
@ -6453,7 +6457,7 @@ msgid ""
"items (in the latter case, *x* should be a ``(key, value)`` tuple)."
msgstr ""
"Renvoie ``True`` si *x* est dans les clefs, les valeurs, ou les éléments du "
"dictionnaire sous-jacent (dans le dernier cas, *x* doit être un *tuple* "
"dictionnaire sous-jacent (dans le dernier cas, *x* doit être une paire "
"``(key, value)``)."
#: library/stdtypes.rst:4599
@ -6969,7 +6973,7 @@ msgstr "La classe de l'instance de classe."
#: library/stdtypes.rst:4958
msgid "The tuple of base classes of a class object."
msgstr "Le *tuple* des classes parentes d'un objet classe."
msgstr "Le *n*-uplet des classes parentes d'un objet classe."
#: library/stdtypes.rst:4963
msgid ""
@ -6989,7 +6993,7 @@ msgid ""
"This attribute is a tuple of classes that are considered when looking for "
"base classes during method resolution."
msgstr ""
"Cet attribut est un *tuple* contenant les classes parents prises en compte "
"Cet attribut est un *n*-uplet contenant les classes parents prises en compte "
"lors de la résolution de méthode."
#: library/stdtypes.rst:4983
@ -7030,7 +7034,7 @@ msgid ""
"and similarly for tuples."
msgstr ""
"Par conséquent, la liste ``[1, 2]`` est considérée égale à ``[1.0, 2.0]``. "
"Idem avec des tuples."
"Idem avec des *n*-uplets."
#: library/stdtypes.rst:5006
msgid "They must have since the parser can't tell the type of the operands."
@ -7053,5 +7057,5 @@ msgid ""
"To format only a tuple you should therefore provide a singleton tuple whose "
"only element is the tuple to be formatted."
msgstr ""
"Pour insérer un *tuple*, vous devez donc donner un *tuple* d'un seul "
"élément, contenant le *tuple* à insérer."
"Pour insérer un *n*-uplet, vous devez donc donner un *n*-uplet d'un seul "
"élément, contenant le *n*-uplet à insérer."

14
library/string.po
View file

@ -179,7 +179,7 @@ msgid ""
"by :meth:`vformat` to break the string into either literal text, or "
"replacement fields."
msgstr ""
"Boucle sur la chaîne de format et renvoie un itérable de *tuples* "
"Boucle sur la chaîne de format et renvoie un itérable de quadruplets "
"(*literal_text*, *field_name*, *format_spec*, *conversion*). Ceci est "
"utilisé par :meth:`vformat` pour découper la chaîne de format en littéraux "
"ou en champs de remplacement."
@ -193,7 +193,7 @@ msgid ""
"field, then the values of *field_name*, *format_spec* and *conversion* will "
"be ``None``."
msgstr ""
"Les valeurs dans le *tuple* représentent conceptuellement un ensemble de "
"Les valeurs dans le *n*-uplet représentent conceptuellement un ensemble de "
"littéraux suivis d'un unique champ de remplacement. S'il n'y a pas de "
"littéral, (ce qui peut arriver si deux champs de remplacement sont placés "
"côte à côte), alors *literal_text* est une chaîne vide. S'il n'y a pas de "
@ -209,8 +209,8 @@ msgid ""
"meth:`vformat`. The return value *used_key* has the same meaning as the "
"*key* parameter to :meth:`get_value`."
msgstr ""
"Récupère le champ *field_name* du *tuple* renvoyé par :meth:`parse` (voir ci-"
"dessus), le convertit en un objet à formater. Renvoie un *tuple* (*obj*, "
"Récupère le champ *field_name* du *n*-uplet renvoyé par :meth:`parse` (voir "
"ci-dessus), le convertit en un objet à formater. Renvoie une paire (*obj*, "
"*used_key*). La version par défaut prend une chaîne de la forme définie par :"
"pep:`3101`, telle que `\"0[name]\"` ou `\"label.title\"`. *args* et *kwargs* "
"sont tels que ceux passés à :meth:`vformat`. La valeur renvoyée *used_key* a "
@ -302,9 +302,9 @@ msgid ""
"understands 's' (str), 'r' (repr) and 'a' (ascii) conversion types."
msgstr ""
"Convertit la valeur (renvoyée par :meth:`get_field`) selon un type de "
"conversion donné (comme dans le tuple renvoyé par la méthode :meth:`parse`). "
"La version par défaut comprend 's' (`str`), 'r' (`repr`) et 'a' (ASCII) "
"comme types de conversion."
"conversion donné (comme dans le *n*-uplet renvoyé par la méthode :meth:"
"`parse`). La version par défaut comprend 's' (`str`), 'r' (`repr`) et "
"'a' (ASCII) comme types de conversion."
#: library/string.rst:186
msgid "Format String Syntax"

7
library/struct.po
View file

@ -127,7 +127,7 @@ msgid ""
msgstr ""
"Dissocie depuis le tampon *buffer* (en supposant que celui-ci a été agrégé "
"avec ``pack(format, …)``) à l'aide de la chaîne de format *format*. Le "
"résultat est un n-uplet, qui peut éventuellement ne contenir qu'un seul "
"résultat est un *n*-uplet, qui peut éventuellement ne contenir qu'un seul "
"élément. La taille de *buffer* en octets doit correspondre à la taille "
"requise par le format, telle que calculée par :func:`calcsize`."
@ -162,7 +162,8 @@ msgstr ""
#: library/struct.rst:89
msgid "Each iteration yields a tuple as specified by the format string."
msgstr ""
"Chaque itération produit un n-uplet tel que spécifié par la chaîne de format."
"Chaque itération produit un *n*-uplet tel que spécifié par la chaîne de "
"format."
#: library/struct.rst:96
msgid ""
@ -859,7 +860,7 @@ msgid ""
"the result in a named tuple::"
msgstr ""
"Les champs dissociés peuvent être nommés en leur assignant des variables ou "
"en encapsulant le résultat dans un n-uplet nommé ::"
"en encapsulant le résultat dans un *n*-uplet nommé ::"
#: library/struct.rst:368
msgid ""

10
library/subprocess.po
View file

@ -1338,7 +1338,7 @@ msgid ""
":meth:`communicate` returns a tuple ``(stdout_data, stderr_data)``. The data "
"will be strings if streams were opened in text mode; otherwise, bytes."
msgstr ""
":meth:`communicate` renvoie un *tuple* ``(stdout_data, stderr_data)``. Les "
":meth:`communicate` renvoie une paire ``(stdout_data, stderr_data)``. Les "
"données seront des chaînes de caractères si les flux sont ouverts en mode "
"texte, et des objets *bytes* dans le cas contraire."
@ -1351,7 +1351,7 @@ msgid ""
msgstr ""
"Notez que si vous souhaitez envoyer des données sur l'entrée standard du "
"processus, vous devez créer l'objet *Popen* avec ``stdin=PIPE``. "
"Similairement, pour obtenir autre chose que ``None`` dans le *tuple* "
"Similairement, pour obtenir autre chose que ``None`` dans le *n*-uplet "
"résultant, vous devez aussi préciser ``stdout=PIPE`` et/ou ``stderr=PIPE``."
#: library/subprocess.rst:756
@ -2154,9 +2154,9 @@ msgid ""
"the notes on :ref:`frequently-used-arguments` for more details."
msgstr ""
"Exécute la chaîne *cmd* dans un *shell* avec :meth:`Popen.check_output` et "
"renvoie un *tuple* de 2 éléments ``(exitcode, output)``. L'encodage local "
"est utilisé, voir les notes de la section :ref:`frequently-used-arguments` "
"pour plus de détails."
"renvoie une paire ``(exitcode, output)``. L'encodage local est utilisé, voir "
"les notes de la section :ref:`frequently-used-arguments` pour plus de "
"détails."
#: library/subprocess.rst:1417
msgid ""

6
library/sunau.po
View file

@ -334,9 +334,9 @@ msgid ""
"compname)``, with values valid for the :meth:`set\\*` methods. Set all "
"parameters."
msgstr ""
"Le *tuple* doit être ``(nchannels, sampwidth, framerate, nframes, comptype, "
"compname)``, avec des valeurs valides pour les méthodes :meth:`set\\*`. Tous "
"les paramètres sont obligatoires et doivent être définis."
"Le sextuplet doit être ``(nchannels, sampwidth, framerate, nframes, "
"comptype, compname)``, avec des valeurs valides pour les méthodes :meth:`set"
"\\*`. Tous les paramètres sont obligatoires et doivent être définis."
#: library/sunau.rst:241
#, fuzzy

61
library/sys.po
View file

@ -62,7 +62,7 @@ msgid ""
msgstr ""
"Quand un événement d'audit est déclenché par la fonction :func:`sys.audit`, "
"chaque fonction de rappel est appelée dans l'ordre dans lequel elle a été "
"ajoutée avec le nom de l'événement et le *tuple* des arguments. Les "
"ajoutée avec le nom de l'événement et le *n*-uplet des arguments. Les "
"fonctions de rappel qui sont ajoutées par :c:func:`PySys_AddAuditHook` sont "
"appelées les premières, suivi par les fonctions de rappel ajoutées dans "
"l'interpréteur en cours d'exécution."
@ -238,7 +238,7 @@ msgid ""
"this Python interpreter. (This information is not available in any other "
"way --- ``modules.keys()`` only lists the imported modules.)"
msgstr ""
"Un *tuple* de chaînes de caractères donnant les noms de tous les modules "
"Un *n*-uplet de chaînes de caractères donnant les noms de tous les modules "
"compilés dans l'interpréteur Python. (Cette information n'est pas "
"disponible autrement --- ```modules.keys()`` liste seulement les modules "
"importés.)"
@ -568,15 +568,14 @@ msgid ""
"defined as \"executing an except clause.\" For any stack frame, only "
"information about the exception being currently handled is accessible."
msgstr ""
"Cette fonction renvoie un *tuple* de trois valeurs qui donnent des "
"informations sur l'exception actuellement traitée. L'information renvoyée "
"est spécifique à la fois au fil d'exécution courant et à la *stack frame* "
"courante. Si la *stack frame* actuelle ne traite pas d'exception, "
"l'information est extraite de la *stack frame* parente, puis celle "
"appelante, et ainsi de suite jusqu'à trouver une *stack frame* traitant une "
"exception. Ici, \"traiter une exception\" signifie \"exécute une clause "
"*except*\". Pour chaque *stack frame*, seule l'information à propos d'une "
"exception actuellement traitée est accessible."
"Cette fonction renvoie un triplet qui donne des informations sur l'exception "
"actuellement traitée. L'information renvoyée est spécifique à la fois au "
"fil d'exécution courant et à la *stack frame* courante. Si la *stack frame* "
"actuelle ne traite pas d'exception, l'information est extraite de la *stack "
"frame* parente, puis celle appelante, et ainsi de suite jusqu'à trouver une "
"*stack frame* traitant une exception. Ici, \"traiter une exception\" "
"signifie \"exécute une clause *except*\". Pour chaque *stack frame*, seule "
"l'information à propos d'une exception actuellement traitée est accessible."
#: library/sys.rst:362
msgid ""
@ -588,14 +587,14 @@ msgid ""
"a :ref:`traceback object <traceback-objects>` which encapsulates the call "
"stack at the point where the exception originally occurred."
msgstr ""
"Si aucune exception n'est actuellement traitée de toute la pile, un *tuple* "
"contenant trois valeurs ``None`` sera renvoyé. Autrement, les valeurs "
"renvoyées sont ``(type, value, traceback)``. Respectivement *type* reçoit "
"le type de l'exception traitée (une classe fille de :exc:`BaseException`), "
"*value* reçoit l'instance de l'exception (une instance du type de "
"l'exception), et *traceback* reçoit un :ref:`objet traceback <traceback-"
"objects>` qui encapsule la pile d'appels au point où l'exception s'est "
"produite à l'origine."
"Si aucune exception n'est actuellement traitée de toute la pile, un triplet "
"de trois ``None`` sera renvoyé. Autrement, les valeurs renvoyées sont "
"``(type, value, traceback)``. Respectivement *type* reçoit le type de "
"l'exception traitée (une classe fille de :exc:`BaseException`), *value* "
"reçoit l'instance de l'exception (une instance du type de l'exception), et "
"*traceback* reçoit un :ref:`objet traceback <traceback-objects>` qui "
"encapsule la pile d'appels au point où l'exception s'est produite à "
"l'origine."
#: library/sys.rst:373
msgid ""
@ -1383,16 +1382,16 @@ msgid ""
"getwindowsversion().major``. For compatibility with prior versions, only the "
"first 5 elements are retrievable by indexing."
msgstr ""
"Renvoie un tuple nommé décrivant la version de Windows en cours "
"Renvoie un *n*-uplet nommé décrivant la version de Windows en cours "
"d'exécution.\n"
"Les attributs nommés sont *major*, *minor*, *build*, *platform*,\n"
"*service_pack*, *service_pack_minor*, *service_pack_major*,\n"
"*suite_mask*, *product_type* et *platform_version*. *service_pack*\n"
"contient une string, *platform_version* un *tuple* de trois valeurs, et tous "
"les autres sont des nombres entiers. Ces attributs sont également "
"accessibles par leur nom, donc ``sys.getwindowsversion()[0]`` est équivalent "
"à ``sys.getwindowsversion().major``. Pour des raisons de compatibilité avec "
"les versions antérieures, seuls les 5 premiers éléments sont accessibles par "
"contient une string, *platform_version* un triplet, et tous les autres sont "
"des nombres entiers. Ces attributs sont également accessibles par leur nom, "
"donc ``sys.getwindowsversion()[0]`` est équivalent à ``sys."
"getwindowsversion().major``. Pour des raisons de compatibilité avec les "
"versions antérieures, seuls les 5 premiers éléments sont accessibles par "
"leur indice."
#: library/sys.rst:745
@ -1463,7 +1462,7 @@ msgid ""
"Changed to a named tuple and added *service_pack_minor*, "
"*service_pack_major*, *suite_mask*, and *product_type*."
msgstr ""
"Changé en un *tuple* nommé, et ajout de *service_pack_minor*, "
"Changé en un *n*-uplet nommé, et ajout de *service_pack_minor*, "
"*service_pack_major*, *suite_mask*, et *product_type*."
#: library/sys.rst:776
@ -1654,7 +1653,7 @@ msgid ""
"would be ``sys.version_info(2, 7, 2, 'final', 0)``. For CPython they are "
"the same value, since it is the reference implementation."
msgstr ""
"*version* est un *named tuple*, du même format que :data:`sys."
"*version* est un *n*-uplet nommé, du même format que :data:`sys."
"version_info`. Il représente la version de l'**implementation** de Python. "
"C'est une information différente de la version du **langage** auquel "
"l'interpréteur actuel se conforme (donnée par ``sys.version_info``). Par "
@ -2511,7 +2510,7 @@ msgid ""
"local trace function."
msgstr ""
"Une exception est survenue. La fonction de traçage locale est appelée, *arg* "
"est le *tuple* ``(exception, valeur, traceback)``, la valeur renvoyée "
"est le triplet ``(exception, valeur, traceback)``, la valeur renvoyée "
"spécifie la nouvelle fonction de traçage locale."
#: library/sys.rst:1347
@ -2640,8 +2639,8 @@ msgid ""
msgstr ""
"Permet d'activer ou de désactiver le suivi d'origine de la coroutine. "
"Lorsque cette option est activée, l'attribut ``cr_origin`` sur les objets de "
"la coroutine contient un tuple (nom de fichier, numéro de ligne, nom de "
"fonction) de tuples gardant la trace d'appels de l'endroit où l'objet "
"la coroutine contient un *n*-uplet de triplets (nom de fichier, numéro de "
"ligne, nom de fonction) gardant la trace d'appels de l'endroit où l'objet "
"coroutine a été créé, avec l'appel le plus récent en premier. Lorsqu'il est "
"désactivé, la valeur de ``cr_origin`` est ``None``."
@ -3050,7 +3049,7 @@ msgid ""
"also be accessed by name, so ``sys.version_info[0]`` is equivalent to ``sys."
"version_info.major`` and so on."
msgstr ""
"Un *tuple* contenant les cinq composants du numéro de version : *major*, "
"Un quintuplet contenant les composants du numéro de version : *major*, "
"*minor*, *micro*, *releaselevel* et *serial*. Toutes les valeurs sauf "
"*releaselevel* sont des nombres entiers. *releaselevel* peut valoir "
"``'alpha'``, ``'beta'``, ``'candidate'``, ou ``'final'``. La valeur de "

2
library/tempfile.po
View file

@ -356,7 +356,7 @@ msgid ""
"file (as would be returned by :func:`os.open`) and the absolute pathname of "
"that file, in that order."
msgstr ""
":func:`mkstemp` renvoie un n-uplet contenant un descripteur (*handle* en "
":func:`mkstemp` renvoie une paire contenant un descripteur (*handle* en "
"anglais) au niveau du système d'exploitation vers un fichier ouvert (le même "
"que renvoie :func:`os.open`) et le chemin d'accès absolu de ce fichier, dans "
"cet ordre."

4
library/threading.po
View file

@ -514,8 +514,8 @@ msgstr ""
msgid ""
"*args* is the argument tuple for the target invocation. Defaults to ``()``."
msgstr ""
"*args* est le tuple d'arguments pour l'invocation de l'objet appelable. La "
"valeur par défaut est ``()``."
"*args* est le *n*-uplet d'arguments pour l'invocation de l'objet appelable. "
"La valeur par défaut est ``()``."
#: library/threading.rst:272
msgid ""

34
library/time.po
View file

@ -243,11 +243,11 @@ msgid ""
"Jun 20 23:21:05 1993'``. The day field is two characters long and is space "
"padded if the day is a single digit, e.g.: ``'Wed Jun 9 04:26:40 1993'``."
msgstr ""
"Convertit un n-uplet ou :class:`struct_time` représentant une heure renvoyée "
"par :func:`gmtime` ou :func:`localtime` en une chaîne de la forme suivante : "
"``'Sun Jun 20 23:21:05 1993'``. Le numéro du jour est un champ de deux "
"caractères complété par une espace si celui-ci n'a qu'un seul chiffre, par "
"exemple : ``'Wed Jun 9 04:26:40 1993'``."
"Convertit un *n*-uplet ou :class:`struct_time` représentant une heure "
"renvoyée par :func:`gmtime` ou :func:`localtime` en une chaîne de la forme "
"suivante : ``'Sun Jun 20 23:21:05 1993'``. Le numéro du jour est un champ de "
"deux caractères complété par une espace si celui-ci n'a qu'un seul chiffre, "
"par exemple : ``'Wed Jun 9 04:26:40 1993'``."
#: library/time.rst:129
msgid ""
@ -467,7 +467,7 @@ msgid ""
"dependent."
msgstr ""
"C’est la fonction inverse de :func:`localtime`. Son argument est soit un :"
"class:`struct_time` soit un 9-tuple (puisque le drapeau *dst* est "
"class:`struct_time` soit un 9-uplet (puisque le drapeau *dst* est "
"nécessaire ; utilisez ``-1`` comme drapeau *dst* s’il est inconnu) qui "
"exprime le temps **local**, pas UTC. Il retourne un nombre à virgule "
"flottante, pour compatibilité avec :func:`.time`. Si la valeur d’entrée ne "
@ -577,8 +577,8 @@ msgid ""
"`localtime` is used. *format* must be a string. :exc:`ValueError` is "
"raised if any field in *t* is outside of the allowed range."
msgstr ""
"Convertit un *tuple* ou :class:`struct_time` représentant une heure renvoyée "
"par :func:`gmtime` ou :func:`localtime` en une chaîne spécifiée par "
"Convertit un *n*-uplet ou :class:`struct_time` représentant une heure "
"renvoyée par :func:`gmtime` ou :func:`localtime` en une chaîne spécifiée par "
"l’argument *format*. Si *t* n’est pas fourni, l’heure actuelle renvoyée par :"
"func:`localtime` est utilisée. *format* doit être une chaîne. Si l’un des "
"champs de *t* se situe en dehors de la plage autorisée, une :exc:"
@ -589,8 +589,8 @@ msgid ""
"0 is a legal argument for any position in the time tuple; if it is normally "
"illegal the value is forced to a correct one."
msgstr ""
"0 est un argument légal pour toute position dans le *tuple* temporel ; s’il "
"est normalement illégal, la valeur est forcée à une valeur correcte."
"0 est un argument légal pour toute position dans le *n*-uplet temporel ; "
"s’il est normalement illégal, la valeur est forcée à une valeur correcte."
#: library/time.rst:358
msgid ""
@ -1138,9 +1138,9 @@ msgid ""
"class:`struct_time`, or having elements of the wrong type, a :exc:"
"`TypeError` is raised."
msgstr ""
"Lorsqu’un *tuple* de longueur incorrecte est passé à une fonction acceptant "
"une :class:`struct_time`, ou comportant des éléments de type incorrect, une "
"exception :exc:`TypeError` est levé."
"Lorsqu’un *n*-uplet de longueur incorrecte est passé à une fonction "
"acceptant une :class:`struct_time`, ou comportant des éléments de type "
"incorrect, une exception :exc:`TypeError` est levé."
#: library/time.rst:561
msgid ""
@ -1574,10 +1574,10 @@ msgid ""
"the second is the name of the local DST timezone. If no DST timezone is "
"defined, the second string should not be used. See note below."
msgstr ""
"Un *tuple* de deux chaînes : la première est le nom du fuseau horaire local "
"autre que DST, la seconde est le nom du fuseau horaire DST local. Si aucun "
"fuseau horaire DST n’est défini, la deuxième chaîne ne doit pas être "
"utilisée. Voir note ci-dessous."
"Une paire de chaînes : la première est le nom du fuseau horaire local autre "
"que DST, la seconde est le nom du fuseau horaire DST local. Si aucun fuseau "
"horaire DST n’est défini, la deuxième chaîne ne doit pas être utilisée. Voir "
"note ci-dessous."
#: library/time.rst:860
msgid ""

18
library/tokenize.po
View file

@ -85,10 +85,10 @@ msgstr ""
"chaîne, un couple d'entiers ``(srow, scol)`` indiquant la ligne et la "
"colonne où le *token* commence, un couple d'entiers ``(erow, ecol)`` "
"indiquant la ligne et la colonne où il se termine, puis la ligne dans "
"laquelle il a été trouvé. La ligne donnée (le dernier élément du *tuple*) "
"laquelle il a été trouvé. La ligne donnée (le dernier élément du *n*-uplet) "
"est la ligne \"logique\", les *continuation lines* étant incluses. Le "
"*tuple* est renvoyé sous forme de :term:`named tuple` dont les noms sont : "
"``type string start end line``."
"quintuplet est renvoyé sous forme d'un :term:`n-uplet nommé<named tuple>` "
"dont les noms des 5 champs sont : ``type string start end line``."
#: library/tokenize.rst:46
msgid ""
@ -97,18 +97,18 @@ msgid ""
"tokens. For all other token types ``exact_type`` equals the named tuple "
"``type`` field."
msgstr ""
"Le :term:`named tuple` a une propriété additionnelle appelée ``exact_type`` "
"qui contient le type exact de l'opérateur pour les jetons :data:`~token."
"OP` . Pour tous les autres types de jetons, ``exact_type`` est égal au "
"champ ``type`` du tuple nommé."
"Le :term:`n-uplet nommé<named tuple>` a une propriété additionnelle appelée "
"``exact_type`` qui contient le type exact de l'opérateur pour les jetons :"
"data:`~token.OP`. Pour tous les autres types de jetons, ``exact_type`` est "
"égal au champ ``type`` du *n*-uplet nommé."
#: library/tokenize.rst:51
msgid "Added support for named tuples."
msgstr "Soutien ajouté pour *tuples* nommé."
msgstr "prise en charge des *n*-uplets nommés."
#: library/tokenize.rst:54
msgid "Added support for ``exact_type``."
msgstr "Soutien ajouté pour ``exact_type``."
msgstr "prise en charge de ``exact_type``."
#: library/tokenize.rst:57
msgid ""

12
library/turtle.po
View file

@ -857,7 +857,7 @@ msgstr "un entier supérieur ou égal à 1 (si fourni)"
#: library/turtle.rst:512
msgid "a colorstring or a numeric color tuple"
msgstr "une chaîne qui désigne une couleur ou un n-uplet de couleur numérique"
msgstr "une chaîne qui désigne une couleur ou un triplet de couleur numérique"
#: library/turtle.rst:514
msgid ""
@ -1070,13 +1070,13 @@ msgstr "`\"pendown\"` : ``True`` / ``False``"
#: library/turtle.rst:841
msgid "\"pencolor\": color-string or color-tuple"
msgstr ""
"`\"pencolor\"` : chaîne de caractères ou n-uplet désignant la couleur du "
"`\"pencolor\"` : chaîne de caractères ou triplet désignant la couleur du "
"pinceau"
#: library/turtle.rst:842
msgid "\"fillcolor\": color-string or color-tuple"
msgstr ""
"`\"fillcolor\"` : chaîne de caractères ou n-uplet pour la couleur de "
"`\"fillcolor\"` : chaîne de caractères ou triplet pour la couleur de "
"remplissage"
#: library/turtle.rst:843
@ -1713,7 +1713,7 @@ msgstr "nombre entier positif, nouvelle hauteur du canevas, en pixels"
#: library/turtle.rst:1657
msgid "colorstring or color-tuple, new background color"
msgstr ""
"chaîne de caractères indiquant la couleur ou n-uplet de couleurs, nouvelle "
"chaîne de caractères indiquant la couleur ou triplet de couleurs, nouvelle "
"couleur de fond"
#: library/turtle.rst:1659
@ -2167,7 +2167,7 @@ msgstr "\"polygon\""
#: library/turtle.rst:2151
msgid "a polygon-tuple, i.e. a tuple of pairs of coordinates"
msgstr ""
"un polygone n-uplet, c'est-à-dire un n-uplet constitué de paires (chaque "
"un polygone *n*-uplet, c'est-à-dire un *n*-uplet constitué de paires (chaque "
"paire définissant des coordonnées)"
#: library/turtle.rst:2152
@ -2192,7 +2192,7 @@ msgstr ""
#: library/turtle.rst:2159
msgid "a polygon, i.e. a tuple of pairs of numbers"
msgstr "un polygone, c.-à-d. un n-uplet de paires de nombres"
msgstr "un polygone, c.-à-d. un *n*-uplet de paires de nombres"
#: library/turtle.rst:2160
msgid "a color the *poly* will be filled with"

13
library/typing.po
View file

@ -570,9 +570,9 @@ msgid ""
"first item of type X and the second of type Y. The type of the empty tuple "
"can be written as ``Tuple[()]``."
msgstr ""
"Type « n-uplet » ; ``Tuple[X, Y]`` est le type d'un n-uplet à deux éléments "
"avec le premier élément de type X et le second de type Y. Le type du n-uplet "
"vide peut être écrit comme ``Tuple[()]``."
"Type « *n*-uplet » ; ``Tuple[X, Y]`` est le type d'un *n*-uplet à deux "
"éléments avec le premier élément de type X et le second de type Y. Le type "
"du *n*-uplet vide peut être écrit comme ``Tuple[()]``."
#: library/typing.rst:503
msgid ""
@ -590,9 +590,10 @@ msgid ""
"ellipsis, e.g. ``Tuple[int, ...]``. A plain :data:`Tuple` is equivalent to "
"``Tuple[Any, ...]``, and in turn to :class:`tuple`."
msgstr ""
"Pour spécifier un n-uplet de longueur variable et de type homogène, utilisez "
"une ellipse, par exemple ``Tuple[int, ....]``. Un n-uplet :data:`Tuple` est "
"équivalent à ``Tuple[Any, ....]`` et, à son tour, à :class:`tuple`."
"Pour spécifier un *n*-uplet de longueur variable et de type homogène, "
"utilisez une ellipse, par exemple ``Tuple[int, ....]``. Un *n*-uplet :data:"
"`Tuple` est équivalent à ``Tuple[Any, ....]`` et, à son tour, à :class:"
"`tuple`."
#: library/typing.rst:511
msgid ":class:`builtins.tuple <tuple>` now supports ``[]``. See :pep:`585`."

12
library/unittest.mock.po
View file

@ -724,9 +724,9 @@ msgid ""
msgstr ""
"C'est soit ``None`` (si le simulacre n'a pas été appelé), soit les arguments "
"avec lesquels le simulacre a été appelé en dernier. Le retour est sous la "
"forme d'un tuple : le premier élément est l'ensemble des arguments ordonnés "
"avec lequel le simulacre a été appelé (ou un tuple vide) et le second "
"élément est l'ensemble des arguments nommés (ou un dictionnaire vide)."
"forme d'un *n*-uplet : le premier élément est l'ensemble des arguments "
"ordonnés avec lequel le simulacre a été appelé (ou un *n*-uplet vide) et le "
"second élément est l'ensemble des arguments nommés (ou un dictionnaire vide)."
#: library/unittest.mock.rst:644
msgid ""
@ -737,9 +737,9 @@ msgid ""
msgstr ""
"L'attribut :attr:`call_args`, ainsi que les éléments des listes :attr:"
"`call_args_list`, :attr:`method_calls` et :attr:`mock_calls` sont des "
"objets :data:`call`. Ce sont des tuples, que l'on peut dépaqueter afin de "
"faire des affirmations plus complexes sur chacun des arguments. Voir :ref:"
"`appels comme tuples <calls-as-tuples>`."
"objets :data:`call`. Ce sont des *n*-uplets, que l'on peut dépaqueter afin "
"de faire des affirmations plus complexes sur chacun des arguments. Voir :ref:"
"`appels comme *n*-uplets <calls-as-tuples>`."
#: library/unittest.mock.rst:650
msgid "Added ``args`` and ``kwargs`` properties."

28
library/unittest.po
View file

@ -1369,7 +1369,7 @@ msgid ""
"methods>`)."
msgstr ""
"En outre, si *first* et *second* ont exactement le même type et sont de type "
"*liste*, *tuple*, *dict*, *set*, *frozenset* ou *str* ou tout autre type de "
"*list*, *tuple*, *dict*, *set*, *frozenset* ou *str* ou tout autre type de "
"sous classe enregistrée dans :meth:`addTypeEqualityFunc`. La fonction "
"égalité spécifique au type sera appelée pour générer une erreur plus utile "
"(voir aussi :ref:`liste des méthodes spécifiques de type <type-specific-"
@ -1438,9 +1438,9 @@ msgid ""
"exact type, use :func:`assertIs(type(obj), cls) <assertIs>`."
msgstr ""
"Vérifie que *obj* est (ou n'est pas) une instance de *cls* (Ce qui peut être "
"une classe ou un tuple de classes, comme utilisée par :func:`isinstance`). "
"Pour vérifier le type exact, utilisez :func:`assertIs(type(obj), cls) "
"<assertIs>`."
"une classe ou un *n*-uplet de classes, comme utilisée par :func:"
"`isinstance`). Pour vérifier le type exact, utilisez :func:"
"`assertIs(type(obj), cls) <assertIs>`."
#: library/unittest.rst:932
msgid ""
@ -1521,7 +1521,7 @@ msgstr ""
"n'importe quel argument positionnel ou nommé qui est également passé à :meth:"
"`assertRaises`. Le test réussit si *exception* est levée, est en erreur si "
"une autre exception est levée, ou en échec si aucune exception n'est levée. "
"Pour capturer une exception d'un groupe d'exceptions, un n-uplet contenant "
"Pour capturer une exception d'un groupe d'exceptions, un *n*-uplet contenant "
"les classes d'exceptions peut être passé à *exception*."
#: library/unittest.rst:964
@ -1605,7 +1605,7 @@ msgstr ""
"n'importe quel argument positionnel ou nommé qui est également passé à :meth:"
"`assertWarns`. Le test passe si *warning* est déclenché et échoue s'il ne "
"l'est pas. Toute exception est une erreur. Pour capturer un avertissement "
"dans un ensemble d'avertissements, un n-uplet contenant les classes "
"dans un ensemble d'avertissements, un *n*-uplet contenant les classes "
"d'avertissement peut être passé à *warnings*."
#: library/unittest.rst:1030
@ -1992,7 +1992,7 @@ msgstr ":meth:`assertTupleEqual(a, b) <TestCase.assertTupleEqual>`"
#: library/unittest.rst:1267
msgid "tuples"
msgstr "n-uplets"
msgstr "*n*-uplets"
#: library/unittest.rst:1270
msgid ":meth:`assertSetEqual(a, b) <TestCase.assertSetEqual>`"
@ -2050,11 +2050,11 @@ msgid ""
"also raised if either of the parameters are of the wrong type. These methods "
"are used by default when comparing lists or tuples with :meth:`assertEqual`."
msgstr ""
"Vérifie que deux listes ou deux n-uplets sont égaux. Si ce n'est pas le "
"Vérifie que deux listes ou deux *n*-uplets sont égaux. Si ce n'est pas le "
"cas, un message d'erreur qui ne montre que les différences entre les deux "
"est généré. Une erreur est également signalée si l'un ou l'autre des "
"paramètres n'est pas du bon type. Ces méthodes sont utilisées par défaut "
"pour comparer des listes ou des n-uplets avec :meth:`assertEqual`."
"pour comparer des listes ou des *n*-uplets avec :meth:`assertEqual`."
#: library/unittest.rst:1317
msgid ""
@ -3311,7 +3311,7 @@ msgid ""
"traceback)``."
msgstr ""
"Appelé lorsque le cas de test *test* soulève une exception inattendue. *err* "
"est un n-uplet de la même forme que celle renvoyée par :func:`sys."
"est un *n*-uplet de la même forme que celle renvoyée par :func:`sys."
"exc_info` : ``(type, valeur, traceback)``."
#: library/unittest.rst:2042
@ -3320,7 +3320,7 @@ msgid ""
"instance's :attr:`errors` attribute, where *formatted_err* is a formatted "
"traceback derived from *err*."
msgstr ""
"L'implémentation par défaut ajoute un n-uplet ``(test, formatted_err)`` à "
"L'implémentation par défaut ajoute un *n*-uplet ``(test, formatted_err)`` à "
"l'attribut :attr:`errors` de l'instance, où *formatted_err* est une trace "
"formatée à partir de *err*."
@ -3339,7 +3339,7 @@ msgid ""
"instance's :attr:`failures` attribute, where *formatted_err* is a formatted "
"traceback derived from *err*."
msgstr ""
"L'implémentation par défaut ajoute un n-uplet ``(test, formatted_err)`` à "
"L'implémentation par défaut ajoute un *n*-uplet ``(test, formatted_err)`` à "
"l'attribut :attr:`errors` de l'instance, où *formatted_err* est une trace "
"formatée à partir de *err*."
@ -3364,7 +3364,7 @@ msgid ""
"The default implementation appends a tuple ``(test, reason)`` to the "
"instance's :attr:`skipped` attribute."
msgstr ""
"L'implémentation par défaut ajoute un n-uplet ``(test, raison)`` à "
"L'implémentation par défaut ajoute un *n*-uplet ``(test, raison)`` à "
"l'attribut :attr:`skipped` de l'instance."
#: library/unittest.rst:2075
@ -3381,7 +3381,7 @@ msgid ""
"instance's :attr:`expectedFailures` attribute, where *formatted_err* is a "
"formatted traceback derived from *err*."
msgstr ""
"L'implémentation par défaut ajoute un n-uplet ``(test, formatted_err)`` à "
"L'implémentation par défaut ajoute un *n*-uplet ``(test, formatted_err)`` à "
"l'attribut :attr:`errors` de l'instance, où *formatted_err* est une trace "
"formatée à partir de *err*."

8
library/uuid.po
View file

@ -94,9 +94,9 @@ msgid ""
msgstr ""
"Produit un UUID à partir soit d'une chaîne de 32 chiffres hexadécimaux, soit "
"une chaîne de 16 octets gros-boutiste (argument *bytes*), soit une chaîne de "
"16 octets petit-boutiste (argument *bytes_le*), soit un n-uplet de six "
"entiers (32-bit *time_low*, 16-bit *time_mid*, 16-bit *time_hi_version*, 8-"
"bit *clock_seq_hi_variant*, 8-bit *clock_seq_low*, 48-bit *node*) (argument "
"16 octets petit-boutiste (argument *bytes_le*), soit un sextuplet d'entiers "
"(32-bit *time_low*, 16-bit *time_mid*, 16-bit *time_hi_version*, 8-bit "
"*clock_seq_hi_variant*, 8-bit *clock_seq_low*, 48-bit *node*) (argument "
"*fields*), soit un unique entier sur 128 bits (argument *int*). Lorsque la "
"fonction reçoit une chaîne de chiffres hexadécimaux, les accolades, les "
"tirets et le préfixe URN sont facultatifs. Par exemple, toutes les "
@ -162,7 +162,7 @@ msgid ""
"A tuple of the six integer fields of the UUID, which are also available as "
"six individual attributes and two derived attributes:"
msgstr ""
"Un n-uplet contenant les six champs entiers de l'UUID, également accessibles "
"Un sextuplet contenant les champs entiers de l'UUID, également accessibles "
"en tant que six attributs individuels et deux attributs dérivés :"
#: library/uuid.rst:99

7
library/warnings.po
View file

@ -889,9 +889,10 @@ msgstr ""
"<warning-filter>`. L'entrée est insérée à l'avant par défaut ; si *append* "
"est vrai, elle est insérée à la fin. Il vérifie le type des arguments, "
"compile les expressions régulières *message* et *module*, et les insère sous "
"forme de tuple dans la liste des filtres d'avertissements. Les entrées plus "
"proches du début de la liste ont priorité sur les entrées plus loin dans la "
"liste. Les arguments omis ont par défaut une valeur qui correspond à tout."
"forme de *n*-uplet dans la liste des filtres d'avertissements. Les entrées "
"plus proches du début de la liste ont priorité sur les entrées plus loin "
"dans la liste. Les arguments omis ont par défaut une valeur qui correspond "
"à tout."
#: library/warnings.rst:477
msgid ""

6
library/wave.po
View file

@ -307,9 +307,9 @@ msgid ""
"compname)``, with values valid for the :meth:`set\\*` methods. Sets all "
"parameters."
msgstr ""
"Le *tuple* doit être ``(nchannels, sampwidth, framerate, nframes, comptype, "
"compname)``, avec des valeurs valides pour les méthodes :meth:`set\\*`. Tous "
"les paramètres sont obligatoires et doivent être définis."
"Le sextuplet doit être ``(nchannels, sampwidth, framerate, nframes, "
"comptype, compname)``, avec des valeurs valides pour les méthodes :meth:`set"
"\\*`. Tous les paramètres sont obligatoires et doivent être définis."
#: library/wave.rst:216
msgid ""

6
library/zipfile.po
View file

@ -111,9 +111,9 @@ msgstr ""
"getinfo` et :meth:`.infolist` des objets :class:`ZipFile`. La plupart des "
"utilisateurs du module :mod:`zipfile` n'ont pas besoin de créer ces "
"instances mais d'utiliser celles créées par ce module. *filename* doit être "
"le nom complet du membre de l'archive et *date_time* doit être un *tuple* "
"contenant six champs qui décrit la date de dernière modification du "
"fichier ; les champs sont décrits dans la section :ref:`zipinfo-objects`."
"le nom complet du membre de l'archive et *date_time* doit être un sextuplet "
"décrivant la date de dernière modification du fichier ; les champs sont "
"décrits dans la section :ref:`zipinfo-objects`."
#: library/zipfile.rst:84
msgid ""

20
reference/compound_stmts.po
View file

@ -187,8 +187,8 @@ msgid ""
"sequence (such as a string, tuple or list) or other iterable object:"
msgstr ""
"L'instruction :keyword:`for` est utilisée pour itérer sur les éléments d'une "
"séquence (par exemple une chaîne, un tuple ou une liste) ou un autre objet "
"itérable :"
"séquence (par exemple une chaîne, un *n*-uplet ou une liste) ou un autre "
"objet itérable :"
#: reference/compound_stmts.rst:159
msgid ""
@ -317,7 +317,7 @@ msgstr ""
"avec une expression, cette expression est évaluée et la clause correspond si "
"l'objet résultant est « compatible » avec l'exception. Un objet est réputé "
"compatible avec une exception s'il est la classe ou une classe de base de "
"l'objet exception ou si c'est un tuple contenant un élément qui est "
"l'objet exception ou si c'est un *n*-uplet contenant un élément qui est "
"compatible avec l'exception."
#: reference/compound_stmts.rst:259
@ -778,13 +778,13 @@ msgstr ""
"tous les paramètres mentionnés dans la liste des paramètres, soit à partir "
"d'arguments positionnels, d'arguments par mots-clés ou de valeurs par "
"défaut. S'il y a un paramètre de la forme \"``*identifier``\", il est "
"initialisé à un tuple recevant les paramètres positionnels en surplus, la "
"valeur par défaut étant le tuple vide. S'il y a un paramètre de la forme "
"\"``**identifier``\", il est initialisé à un nouveau tableau associatif "
"ordonné qui récupère tous les arguments par mot-clé en surplus, la valeur "
"par défaut étant un tableau associatif vide. Les paramètres après \"``*``\" "
"ou \"``*identifier``\" sont forcément des paramètres par mot-clé et ne "
"peuvent être passés qu'en utilisant des arguments par mot-clé."
"initialisé à un *n*-uplet recevant les paramètres positionnels en surplus, "
"la valeur par défaut étant le *n*-uplet vide. S'il y a un paramètre de la "
"forme \"``**identifier``\", il est initialisé à un nouveau tableau "
"associatif ordonné qui récupère tous les arguments par mot-clé en surplus, "
"la valeur par défaut étant un tableau associatif vide. Les paramètres après "
"\"``*``\" ou \"``*identifier``\" sont forcément des paramètres par mot-clé "
"et ne peuvent être passés qu'en utilisant des arguments par mot-clé."
#: reference/compound_stmts.rst:608
msgid ""

78
reference/datamodel.po
View file

@ -91,8 +91,8 @@ msgstr ""
"être modifié. Ainsi, l'immuabilité n'est pas strictement équivalente au fait "
"d'avoir une valeur non modifiable, c'est plus subtil. La muabilité d'un "
"objet est définie par son type ; par exemple, les nombres, les chaînes de "
"caractères et les tuples sont immuables alors que les dictionnaires et les "
"listes sont muables."
"caractères et les *n*-uplets sont immuables alors que les dictionnaires et "
"les listes sont muables."
#: reference/datamodel.rst:65
msgid ""
@ -176,14 +176,14 @@ msgid ""
msgstr ""
"Certains objets contiennent des références à d'autres objets ; on les "
"appelle *conteneurs*. Comme exemples de conteneurs, nous pouvons citer les "
"tuples, les listes et les dictionnaires. Les références sont parties "
"*n*-uplets, les listes et les dictionnaires. Les références sont parties "
"intégrantes de la valeur d'un conteneur. Dans la plupart des cas, lorsque "
"nous parlons de la valeur d'un conteneur, nous parlons des valeurs, pas des "
"identifiants des objets contenus ; cependant, lorsque nous parlons de la "
"muabilité d'un conteneur, seuls les identifiants des objets immédiatement "
"contenus sont concernés. Ainsi, si un conteneur immuable (comme un tuple) "
"contient une référence à un objet muable, sa valeur change si cet objet "
"muable est modifié."
"contenus sont concernés. Ainsi, si un conteneur immuable (comme un *n*-"
"uplet) contient une référence à un objet muable, sa valeur change si cet "
"objet muable est modifié."
#: reference/datamodel.rst:106
msgid ""
@ -538,7 +538,7 @@ msgstr ""
#: reference/datamodel.rst:323
msgid "Tuples"
msgstr "*n*-uplets (ou tuples)"
msgstr "*n*-uplets (*tuples* en anglais)"
#: reference/datamodel.rst:318
msgid ""
@ -549,13 +549,13 @@ msgid ""
"usable for grouping of expressions). An empty tuple can be formed by an "
"empty pair of parentheses."
msgstr ""
"Les éléments d'un tuple sont n'importe quels objets Python. Les tuples de "
"deux ou plus éléments sont formés par une liste d'expressions dont les "
"éléments sont séparés par des virgules. Un tuple composé d'un seul élément "
"(un « singleton ») est formé en suffixant une expression avec une virgule "
"(une expression en tant que telle ne crée pas un tuple car les parenthèses "
"doivent rester disponibles pour grouper les expressions). Un tuple vide peut "
"être formé à l'aide d'une paire de parenthèses vide."
"Les éléments d'un *n*-uplet peuvent être n'importe quel objet Python. Les "
"*n*-uplets de deux éléments ou plus sont formés par une liste d'expressions "
"dont les éléments sont séparés par des virgules. Un *n*-uplet composé d'un "
"seul élément (un « singleton ») est formé en suffixant une expression avec "
"une virgule (une expression en tant que telle ne crée pas un *n*-uplet car "
"les parenthèses doivent rester disponibles pour grouper les expressions). Un "
"*n*-uplet vide est formé à l'aide d'une paire de parenthèses vide."
#: reference/datamodel.rst:332
msgid "Bytes"
@ -933,7 +933,7 @@ msgid ""
"``None`` or a tuple of cells that contain bindings for the function's free "
"variables. See below for information on the ``cell_contents`` attribute."
msgstr ""
"``None`` ou tuple de cellules qui contient un lien pour chaque variable "
"``None`` ou *n*-uplet de cellules qui contient un lien pour chaque variable "
"libre de la fonction. Voir ci-dessous pour les informations relatives à "
"l'attribut ``cell_contents``."
@ -1446,8 +1446,8 @@ msgstr ""
"Attributs spéciaux : :attr:`~definition.__name__` est le nom de la classe ; :"
"attr:`__module__` est le nom du module dans lequel la classe est définie ; :"
"attr:`~object.__dict__` est le dictionnaire contenant l'espace de nommage de "
"la classe ; :attr:`~class.__bases__` est un tuple contenant les classes de "
"base, dans l'ordre d'apparition dans la liste des classes de base ; :attr:"
"la classe ; :attr:`~class.__bases__` est un *n*-uplet contenant les classes "
"de base, dans l'ordre d'apparition dans la liste des classes de base ; :attr:"
"`__doc__` est le texte de documentation de la classe (ou ``None`` s’il n’y "
"en a pas) ; :attr:`__annotations__` (optionnel) est un dictionnaire "
"contenant les :term:`annotations de variables <variable annotation>` "
@ -1620,21 +1620,21 @@ msgstr ""
"défaut) ; :attr:`co_kwonlyargcount` est le nombre d'arguments par mots-clés "
"(y compris les arguments avec des valeurs par défaut) ; :attr:`co_nlocals` "
"est le nombre de variables locales utilisées par la fonction (y compris les "
"arguments) ; :attr:`co_varnames` est un n-uplet contenant les noms des "
"arguments) ; :attr:`co_varnames` est un *n*-uplet contenant les noms des "
"variables locales (en commençant par les noms des arguments) ; :attr:"
"`co_cellvars` est un n-uplet contenant les noms des variables locales qui "
"`co_cellvars` est un *n*-uplet contenant les noms des variables locales qui "
"sont référencées par des fonctions imbriquées ; :attr:`co_freevars` est un "
"tuple contenant les noms des variables libres ; :attr:`co_code` est une "
"*n*-uplet contenant les noms des variables libres ; :attr:`co_code` est une "
"chaîne représentant la séquence des instructions de code intermédiaire ; :"
"attr:`co_consts` est un n-uplet contenant les littéraux utilisés par le code "
"intermédiaire ; :attr:`co_names` est un n-uplet contenant les noms utilisés "
"par le code intermédiaire ; :attr:`co_filename` est le nom de fichier à "
"partir duquel le code a été compilé ; :attr:`co_firstlineno` est numéro de "
"la première ligne de la fonction ; :attr:`co_lnotab` est une chaîne codant "
"la correspondance entre les décalages du code intermédiaire et les numéros "
"de ligne (pour plus de détails, voir le code source de l'interpréteur) ; :"
"attr:`co_stacksize` est la taille de pile requise ; :attr:`co_flags` est un "
"entier qui code différents drapeaux pour l'interpréteur."
"attr:`co_consts` est un *n*-uplet contenant les littéraux utilisés par le "
"code intermédiaire ; :attr:`co_names` est un *n*-uplet contenant les noms "
"utilisés par le code intermédiaire ; :attr:`co_filename` est le nom de "
"fichier à partir duquel le code a été compilé ; :attr:`co_firstlineno` est "
"numéro de la première ligne de la fonction ; :attr:`co_lnotab` est une "
"chaîne codant la correspondance entre les décalages du code intermédiaire et "
"les numéros de ligne (pour plus de détails, voir le code source de "
"l'interpréteur) ; :attr:`co_stacksize` est la taille de pile requise ; :attr:"
"`co_flags` est un entier qui code différents drapeaux pour l'interpréteur."
#: reference/datamodel.rst:948
msgid ""
@ -1799,7 +1799,7 @@ msgstr ""
"est inséré devant l'objet trace courant à chaque nouveau niveau. Quand il "
"entre dans le gestionnaire d'exception, la pile d'appels est rendue "
"accessible au programme (voir la section :ref:`try`). Elle est accessible "
"par le troisième élément du tuple renvoyé par ``sys.exc_info()`` et comme "
"par le troisième élément du triplet renvoyé par ``sys.exc_info()`` et comme "
"attribut ``__traceback__`` de l'exception qui est traitée."
#: reference/datamodel.rst:1051
@ -1898,8 +1898,8 @@ msgid ""
msgstr ""
"Cette méthode prend un argument entier *length* et calcule les informations "
"de la tranche que l'objet découpe décrit s'il est appliqué à une séquence de "
"*length* éléments. Elle renvoie un tuple de trois entiers ; respectivement, "
"ce sont les indices de *début* et *fin* ainsi que le *pas* de découpe. Les "
"*length* éléments. Elle renvoie un triplet d'entiers ; respectivement, ce "
"sont les indices de *début* et *fin* ainsi que le *pas* de découpe. Les "
"indices manquants ou en dehors sont gérés de manière cohérente avec les "
"tranches normales."
@ -2416,8 +2416,8 @@ msgstr ""
"seule propriété requise est que les objets qui sont égaux pour la "
"comparaison doivent avoir la même valeur de hachage ; il est conseillé de "
"mélanger les valeurs de hachage des composants d'un objet qui jouent un rôle "
"de la comparaison des objets, en les plaçant dans un n-uplet dont on calcule "
"l'empreinte. Par exemple ::"
"de la comparaison des objets, en les plaçant dans un *n*-uplet dont on "
"calcule l'empreinte. Par exemple ::"
#: reference/datamodel.rst:1421
msgid ""
@ -3356,10 +3356,10 @@ msgid ""
msgstr ""
"Si une classe de base qui apparaît dans la définition d'une classe n'est pas "
"une instance de :class:`type`, alors Python y recherche une méthode "
"``__mro_entries__``. S'il la trouve, il l'appelle avec le tuple original des "
"classes de bases. Cette méthode doit renvoyer un tuple de classes qui est "
"utilisé à la place de la classe de base. Le tuple peut être vide, dans ce "
"cas la classe de base originale est ignorée."
"``__mro_entries__``. S'il la trouve, il l'appelle avec le *n*-uplet original "
"des classes de bases. Cette méthode doit renvoyer un *n*-uplet de classes "
"qui est utilisé à la place de la classe de base. Le *n*-uplet peut être "
"vide, dans ce cas la classe de base originale est ignorée."
#: reference/datamodel.rst:2119
msgid ":pep:`560` - Core support for typing module and generic types"
@ -3792,7 +3792,7 @@ msgid ""
msgstr ""
"Les fonctions suivantes peuvent être définies pour implémenter des objets "
"conteneurs. Les conteneurs sont habituellement des séquences (telles que les "
"tuples ou les listes) ou des tableaux de correspondances (comme les "
"*n*-uplets ou les listes) ou des tableaux de correspondances (comme les "
"dictionnaires), mais ils peuvent aussi représenter d'autres conteneurs. Le "
"premier ensemble de méthodes est utilisé soit pour émuler une séquence, soit "
"pour émuler un tableau de correspondances ; la différence est que, pour une "

48
reference/expressions.po
View file

@ -214,8 +214,8 @@ msgid ""
msgstr ""
"Une liste d'expressions entre parenthèses produit ce que la liste de ces "
"expressions produirait : si la liste contient au moins une virgule, elle "
"produit un n-uplet (type *tuple*) ; sinon, elle produit l'expression elle-"
"même (qui constitue donc elle-même la liste d'expressions)."
"produit un *n*-uplet (type *n*-uplet) ; sinon, elle produit l'expression "
"elle-même (qui constitue donc elle-même la liste d'expressions)."
#: reference/expressions.rst:146
msgid ""
@ -223,10 +223,10 @@ msgid ""
"immutable, the same rules as for literals apply (i.e., two occurrences of "
"the empty tuple may or may not yield the same object)."
msgstr ""
"Une paire de parenthèses vide produit un objet n-uplet vide. Comme les n-"
"Une paire de parenthèses vide produit un objet *n*-uplet vide. Comme les n-"
"uplets sont immuables, la même règle que pour les littéraux s'applique "
"(c'est-à-dire que deux occurrences du n-uplet vide peuvent, ou pas, produire "
"le même objet)."
"(c'est-à-dire que deux occurrences du *n*-uplet vide peuvent, ou pas, "
"produire le même objet)."
#: reference/expressions.rst:154
msgid ""
@ -235,11 +235,11 @@ msgid ""
"*are* required --- allowing unparenthesized \"nothing\" in expressions would "
"cause ambiguities and allow common typos to pass uncaught."
msgstr ""
"Notez que les *tuples* ne sont pas créés par les parenthèses mais par "
"l'utilisation de la virgule. L'exception est le tuple vide, pour lequel les "
"parenthèses *sont requises* (autoriser que « rien » ne soit pas parenthésé "
"dans les expressions aurait généré des ambigüités et aurait permis à "
"certaines coquilles de passer inaperçu)."
"Notez que les *n*-uplets ne sont pas créés par les parenthèses mais par "
"l'utilisation de la virgule. L'exception est le *n*-uplet vide, pour lequel "
"les parenthèses *sont requises* (autoriser que « rien » ne soit pas "
"parenthésé dans les expressions aurait généré des ambigüités et aurait "
"permis à certaines coquilles de passer inaperçu)."
#: reference/expressions.rst:163
msgid "Displays for lists, sets and dictionaries"
@ -1238,7 +1238,7 @@ msgid ""
"mapping (dictionary) object:"
msgstr ""
"Une sélection (*subscription* dans la grammaire formelle ci-dessous) désigne "
"un élément dans un objet séquence (chaîne, n-uplet ou liste) ou tableau de "
"un élément dans un objet séquence (chaîne, *n*-uplet ou liste) ou tableau de "
"correspondances (dictionnaire) :"
#: reference/expressions.rst:805
@ -1268,7 +1268,7 @@ msgstr ""
"(*expression_list* dans la grammaire formelle ci-dessous) doit pouvoir être "
"évaluée comme un objet dont la valeur est une des clés du tableau de "
"correspondances et la sélection désigne la valeur qui correspond à cette clé "
"(la liste d'expressions est un n-uplet sauf si elle comporte exactement un "
"(la liste d'expressions est un *n*-uplet sauf si elle comporte exactement un "
"élément)."
#: reference/expressions.rst:816
@ -1366,7 +1366,7 @@ msgstr ""
"indicée (en utilisant la même méthode :meth:`__getitem__` que pour les "
"sélections normales) avec une clé qui est construite à partir de la liste de "
"tranches (*slice_list* dans la grammaire), de cette manière : si la liste de "
"tranches contient au moins une virgule (``,``), la clé est un n-uplet "
"tranches contient au moins une virgule (``,``), la clé est un *n*-uplet "
"contenant la conversion des éléments de la tranche ; sinon, la conversion du "
"seul élément de la tranche est la clé. La conversion d'un élément de tranche "
"qui est une expression est cette expression. La conversion d'une tranche en "
@ -1481,8 +1481,8 @@ msgstr ""
"S'il y a plus d'arguments positionnels que de *slots* de paramètres formels, "
"une exception :exc:`TypeError` est levée, à moins qu'un paramètre formel "
"n'utilise la syntaxe ``*identifier`` ; dans ce cas, le paramètre formel "
"reçoit un n-uplet contenant les arguments positionnels en supplément (ou un "
"n-uplet vide s'il n'y avait pas d'arguments positionnel en trop)."
"reçoit un *n*-uplet contenant les arguments positionnels en supplément (ou "
"un *n*-uplet vide s'il n'y avait pas d'arguments positionnel en trop)."
#: reference/expressions.rst:968
msgid ""
@ -2422,7 +2422,7 @@ msgstr ""
"``x not in s`` renvoie la négation de ``x in s``. Tous les types séquences "
"et ensembles natifs gèrent ces opérateurs, ainsi que les dictionnaires pour "
"lesquels :keyword:`!in` teste si dictionnaire possède une clé donnée. Pour "
"les types conteneurs tels que les listes, n-uplets (*tuple*), ensembles "
"les types conteneurs tels que les listes, *n*-uplets (*tuple*), ensembles "
"(*set*), ensembles figés (*frozen set*), dictionnaires (*dict*) ou "
"*collections.deque*, l’expression ``x in y`` est équivalente à ``any(x is e "
"or x == e for e in y)``."
@ -2521,7 +2521,7 @@ msgstr ""
"utilisées par des instructions de contrôle du flux d'exécution, les valeurs "
"suivantes sont considérées comme fausses : ``False``, ``None``, zéro quel "
"que soit le type, la chaîne vide et tout conteneur vide (y compris les "
"chaînes, n-uplets, listes, dictionnaires, ensembles, ensembles figés). "
"chaînes, *n*-uplets, listes, dictionnaires, ensembles, ensembles figés). "
"Toutes les autres valeurs sont considérées comme vraies. Les objets "
"allogènes peuvent personnaliser leur table de vérité en implémentant une "
"méthode :meth:`__bool__`."
@ -2658,9 +2658,9 @@ msgid ""
"expressions in the list. The expressions are evaluated from left to right."
msgstr ""
"Sauf lorsqu'elle fait partie d'un agencement de liste ou d'ensemble, une "
"liste d'expressions qui contient au moins une virgule produit un n-uplet "
"(*tuple*). La longueur du n-uplet est le nombre d'expressions dans la liste. "
"Les expressions sont évaluées de la gauche vers la droite."
"liste d'expressions qui contient au moins une virgule produit un *n*-uplet. "
"La longueur du *n*-uplet est le nombre d'expressions dans la liste. Les "
"expressions sont évaluées de la gauche vers la droite."
#: reference/expressions.rst:1757
msgid ""
@ -2672,7 +2672,7 @@ msgstr ""
"Un astérisque ``*`` indique :dfn:`dépaquetage d'itérable` (*iterable "
"unpacking* en anglais). Son opérande doit être un :term:`iterable`. "
"L'itérable est développé en une séquence d'éléments qui sont inclus dans un "
"nouvel objet *tuple*, *list* ou *set* à l'emplacement du dépaquetage."
"nouvel objet *n*-uplet, liste ou ensemble à l'emplacement du dépaquetage."
#: reference/expressions.rst:1762
msgid ""
@ -2691,9 +2691,9 @@ msgid ""
msgstr ""
"La virgule finale est nécessaire pour créer un singleton (c'est-à-dire un n-"
"uplet composé d'un seul élément) : elle est optionnelle dans tous les autres "
"cas. Une expression seule sans virgule finale ne crée pas un n-uplet mais "
"produit la valeur de cette expression (pour créer un *tuple* vide, utilisez "
"une paire de parenthèses vide : ``()``)."
"cas. Une expression seule sans virgule finale ne crée pas un *n*-uplet mais "
"produit la valeur de cette expression (pour créer un *n*-uplet vide, "
"utilisez une paire de parenthèses vide : ``()``)."
#: reference/expressions.rst:1777
msgid "Evaluation order"

6
reference/simple_stmts.po
View file

@ -97,7 +97,7 @@ msgid ""
msgstr ""
"Une assignation évalue la liste d'expressions (gardez en mémoire que ce peut "
"être une simple expression ou une liste dont les éléments sont séparés par "
"des virgules, cette dernière produisant un n-uplet) et assigne l'unique "
"des virgules, cette dernière produisant un *n*-uplet) et assigne l'unique "
"objet résultant à chaque liste cible, de la gauche vers la droite."
#: reference/simple_stmts.rst:108
@ -434,7 +434,7 @@ msgid ""
"possible *in-place* behavior, the binary operation performed by augmented "
"assignment is the same as the normal binary operations."
msgstr ""
"À l'exception de l'assignation de tuples et de cibles multiples dans une "
"À l'exception de l'assignation de *n*-uplets et de cibles multiples dans une "
"seule instruction, l'assignation effectuée par une assignation augmentée est "
"traitée de la même manière qu'une assignation normale. De même, à "
"l'exception du comportement possible *sur place*, l'opération binaire "
@ -557,7 +557,7 @@ msgid ""
msgstr ""
"Dorénavant, côté droit des assignations annotées, peuvent figurer les mêmes "
"expressions que pour les assignations normales. Auparavant, certaines "
"expressions (comme des n-uplets sans parenthèse englobante) généraient des "
"expressions (comme des *n*-uplets sans parenthèse englobante) généraient des "
"erreurs de syntaxe."
#: reference/simple_stmts.rst:378

2
tutorial/classes.po
View file

@ -122,7 +122,7 @@ msgstr ""
"utilisés (dans divers contextes) pour faire référence à un même objet. Ce "
"concept est connu sous le nom d'alias dans d'autres langages. Il n'apparaît "
"pas au premier coup d'œil en Python et il peut être ignoré tant qu'on "
"travaille avec des types de base immuables (nombres, chaînes, tuples). "
"travaille avec des types de base immuables (nombres, chaînes, *n*-uplets). "
"Cependant, les alias peuvent produire des effets surprenants sur la "
"sémantique d'un code Python mettant en jeu des objets muables comme les "
"listes, les dictionnaires et la plupart des autres types. En général, leur "

4
tutorial/controlflow.po
View file

@ -867,7 +867,7 @@ msgid ""
msgstr ""
"Pour terminer, l'option la moins fréquente consiste à indiquer qu'une "
"fonction peut être appelée avec un nombre arbitraire d'arguments. Ces "
"arguments sont intégrés dans un n-uplet (voir :ref:`tut-tuples`). Avant le "
"arguments sont intégrés dans un *n*-uplet (voir :ref:`tut-tuples`). Avant le "
"nombre variable d'arguments, zéro ou plus arguments normaux peuvent "
"apparaître ::"
@ -897,7 +897,7 @@ msgid ""
"the arguments out of a list or tuple::"
msgstr ""
"La situation inverse intervient lorsque les arguments sont déjà dans une "
"liste ou un n-uplet mais doivent être séparés pour un appel de fonction "
"liste ou un *n*-uplet mais doivent être séparés pour un appel de fonction "
"nécessitant des arguments positionnés séparés. Par exemple, la primitive :"
"func:`range` attend des arguments *start* et *stop* distincts. S'ils ne sont "
"pas disponibles séparément, écrivez l'appel de fonction en utilisant "

56
tutorial/datastructures.po
View file

@ -286,7 +286,7 @@ msgid ""
"If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), "
"it must be parenthesized. ::"
msgstr ""
"Si l'expression est un n-uplet (c'est-à-dire ``(x, y)`` dans cet exemple), "
"Si l'expression est un *n*-uplet (c'est-à-dire ``(x, y)`` dans cet exemple), "
"elle doit être entourée par des parenthèses ::"
#: tutorial/datastructures.rst:280
@ -400,14 +400,14 @@ msgstr ""
"Ce sont deux exemples de *séquences* (voir :ref:`typesseq`). Comme Python "
"est un langage en constante évolution, d'autres types de séquences y seront "
"peut-être ajoutés. Il existe également un autre type standard de séquence : "
"le *tuple* (ou n-uplet, dénomination que nous utiliserons dans la suite de "
"le *tuple* (ou *n*-uplet, dénomination que nous utiliserons dans la suite de "
"cette documentation)."
#: tutorial/datastructures.rst:379
msgid ""
"A tuple consists of a number of values separated by commas, for instance::"
msgstr ""
"Un n-uplet consiste en différentes valeurs séparées par des virgules, par "
"Un *n*-uplet consiste en différentes valeurs séparées par des virgules, par "
"exemple ::"
#: tutorial/datastructures.rst:401
@ -419,13 +419,13 @@ msgid ""
"the individual items of a tuple, however it is possible to create tuples "
"which contain mutable objects, such as lists."
msgstr ""
"Comme vous pouvez le voir, les n-uplets sont toujours affichés entre "
"parenthèses, de façon à ce que des n-uplets imbriqués soient interprétés "
"Comme vous pouvez le voir, les *n*-uplets sont toujours affichés entre "
"parenthèses, de façon à ce que des *n*-uplets imbriqués soient interprétés "
"correctement ; ils peuvent être saisis avec ou sans parenthèses, même si "
"celles-ci sont souvent nécessaires (notamment lorsqu'un n-uplet fait partie "
"d'une expression plus longue). Il n'est pas possible d'affecter de valeur à "
"un élément d'un n-uplet ; par contre, il est possible de créer des n-uplets "
"contenant des objets muables, comme des listes."
"celles-ci sont souvent nécessaires (notamment lorsqu'un *n*-uplet fait "
"partie d'une expression plus longue). Il n'est pas possible d'affecter de "
"valeur à un élément d'un *n*-uplet ; par contre, il est possible de créer "
"des *n*-uplets contenant des objets muables, comme des listes."
#: tutorial/datastructures.rst:408
msgid ""
@ -437,7 +437,7 @@ msgid ""
"`mutable`, and their elements are usually homogeneous and are accessed by "
"iterating over the list."
msgstr ""
"Si les n-uplets peuvent sembler similaires aux listes, ils sont souvent "
"Si les *n*-uplets peuvent sembler similaires aux listes, ils sont souvent "
"utilisés dans des cas différents et pour des raisons différentes. Les n-"
"uplets sont :term:`immuable`\\s et contiennent souvent des séquences "
"hétérogènes d'éléments qui sont accédés par « dissociation » (*unpacking* en "
@ -454,12 +454,12 @@ msgid ""
"constructed by following a value with a comma (it is not sufficient to "
"enclose a single value in parentheses). Ugly, but effective. For example::"
msgstr ""
"Un problème spécifique est la construction de n-uplets ne contenant aucun ou "
"un seul élément : la syntaxe a quelques tournures spécifiques pour s'en "
"accommoder. Les n-uplets vides sont construits par une paire de parenthèses "
"vides ; un n-uplet avec un seul élément est construit en faisant suivre la "
"valeur par une virgule (il n'est pas suffisant de placer cette valeur entre "
"parenthèses). Pas très joli, mais efficace. Par exemple ::"
"Un problème spécifique est la construction de *n*-uplets ne contenant aucun "
"ou un seul élément : la syntaxe a quelques tournures spécifiques pour s'en "
"accommoder. Les *n*-uplets vides sont construits par une paire de "
"parenthèses vides ; un *n*-uplet avec un seul élément est construit en "
"faisant suivre la valeur par une virgule (il n'est pas suffisant de placer "
"cette valeur entre parenthèses). Pas très joli, mais efficace. Par exemple ::"
#: tutorial/datastructures.rst:431
msgid ""
@ -468,9 +468,9 @@ msgid ""
"together in a tuple. The reverse operation is also possible::"
msgstr ""
"L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple d'un "
"*d'agrégation de n-uplet* (*tuple packing* en anglais) : les valeurs "
"``12345``, ``54321`` et ``hello !`` sont agrégées ensemble dans un n-uplet. "
"L'opération inverse est aussi possible ::"
"*d'agrégation de *n*-uplet* (*tuple packing* en anglais) : les valeurs "
"``12345``, ``54321`` et ``hello !`` sont agrégées ensemble dans un *n*-"
"uplet. L'opération inverse est aussi possible ::"
#: tutorial/datastructures.rst:437
msgid ""
@ -485,7 +485,7 @@ msgstr ""
"séquence placée à droite de l'expression. Cette dissociation requiert autant "
"de variables dans la partie gauche qu'il y a d'éléments dans la séquence. "
"Notez également que cette affectation multiple est juste une combinaison "
"entre une agrégation de n-uplet et une dissociation de séquence."
"entre une agrégation de *n*-uplet et une dissociation de séquence."
#: tutorial/datastructures.rst:447
msgid "Sets"
@ -552,13 +552,13 @@ msgstr ""
"associatifs ». À la différence des séquences, qui sont indexées par des "
"nombres, les dictionnaires sont indexés par des *clés*, qui peuvent être de "
"n'importe quel type immuable ; les chaînes de caractères et les nombres "
"peuvent toujours être des clés. Des n-uplets peuvent être utilisés comme "
"clés s'ils ne contiennent que des chaînes, des nombres ou des n-uplets ; si "
"un n-uplet contient un objet muable, de façon directe ou indirecte, il ne "
"peut pas être utilisé comme une clé. Vous ne pouvez pas utiliser des listes "
"comme clés, car les listes peuvent être modifiées en place en utilisant des "
"affectations par position, par tranches ou via des méthodes comme :meth:"
"`append` ou :meth:`extend`."
"peuvent toujours être des clés. Des *n*-uplets peuvent être utilisés comme "
"clés s'ils ne contiennent que des chaînes, des nombres ou des *n*-uplets ; "
"si un *n*-uplet contient un objet muable, de façon directe ou indirecte, il "
"ne peut pas être utilisé comme une clé. Vous ne pouvez pas utiliser des "
"listes comme clés, car les listes peuvent être modifiées en place en "
"utilisant des affectations par position, par tranches ou via des méthodes "
"comme :meth:`append` ou :meth:`extend`."
#: tutorial/datastructures.rst:507
msgid ""
@ -613,7 +613,7 @@ msgid ""
"key-value pairs::"
msgstr ""
"Le constructeur :func:`dict` fabrique un dictionnaire directement à partir "
"d'une liste de paires clé-valeur stockées sous la forme de n-uplets ::"
"d'une liste de paires clé-valeur stockées sous la forme de *n*-uplets ::"
#: tutorial/datastructures.rst:551
msgid ""

2
tutorial/errors.po
View file

@ -211,7 +211,7 @@ msgstr ""
"que les exceptions qui interviennent dans la clause `!try` correspondante, "
"pas dans d'autres gestionnaires de la même instruction :keyword:`!try`. Mais "
"une même clause ``except`` peut citer plusieurs exceptions sous la forme "
"d'un tuple entre parenthèses, comme dans cet exemple ::"
"d'un *n*-uplet entre parenthèses, comme dans cet exemple ::"
#: tutorial/errors.rst:123
msgid ""

2
tutorial/stdlib.po
View file

@ -256,7 +256,7 @@ msgid ""
"`timeit` module quickly demonstrates a modest performance advantage::"
msgstr ""
"Par exemple, pour échanger deux variables, il peut être tentant d'utiliser "
"l'empaquetage et le dépaquetage de tuples plutôt que la méthode "
"l'empaquetage et le dépaquetage de *n*-uplets plutôt que la méthode "
"traditionnelle. Le module :mod:`timeit` montre rapidement le léger gain de "
"performance obtenu ::"

12
whatsnew/2.0.po
View file

@ -453,8 +453,8 @@ msgstr ""
"Le module :mod:`codecs` contient des fonctions pour rechercher les codages "
"existants et en enregistrer de nouveaux. À moins que vous ne souhaitiez "
"implémenter un nouvel encodage, vous utiliserez le plus souvent la fonction "
"``codecs.lookup(encoding)``, qui renvoie un n-uplet à 4 éléments : "
"``(encode_func, decode_func, stream_reader, stream_writer)``."
"``codecs.lookup(encoding)``, qui renvoie un quadruplet : ``(encode_func, "
"decode_func, stream_reader, stream_writer)``."
#: whatsnew/2.0.rst:209
msgid ""
@ -478,10 +478,10 @@ msgid ""
"bit string was consumed."
msgstr ""
"*decode_func* est l’opposé de *encode_func*, en prenant une chaîne de "
"caractères à 8 bits et le retour d’un n-uplet de longueur 2 ``(ustring, "
"longueur)``, composé de la chaîne Unicode résultante *ustring* et l’entier "
"*length* indiquant combien de caractères de la chaîne de caractères à 8 bits "
"ont été consommés."
"caractères à 8 bits et le retour d’une paire ``(ustring, longueur)``, "
"composé de la chaîne Unicode résultante *ustring* et l’entier *length* "
"indiquant combien de caractères de la chaîne de caractères à 8 bits ont été "
"consommés."
#: whatsnew/2.0.rst:219
msgid ""

2
whatsnew/2.4.po
View file

@ -629,7 +629,7 @@ msgstr ""
#: whatsnew/2.4.rst:555
msgid ""
"You can also provide tuples containing the sign, the mantissa represented "
"You can also provide *tuples* containing the sign, the mantissa represented "
"as a tuple of decimal digits, and the exponent::"
msgstr ""

2
whatsnew/2.5.po
View file

@ -2403,7 +2403,7 @@ msgid ""
msgstr ""
"À la place, utilisez la capacité DB-API de substitution des paramètres. "
"Placez un ``?`` comme indicateur partout où vous voulez utiliser une valeur, "
"puis fournissez un *tuple* de valeurs comme second argument de la méthode :"
"puis fournissez un *n*-uplet de valeurs comme second argument de la méthode :"
"meth:`~Cursor.execute`. D'autres modules de base de données peuvent utiliser "
"un espace réservé différent, tel que ``%s`` ou ``:1``. Par exemple ::"