forked from AFPy/python-docs-fr
Traduction « tuple » par « n-uplet ». (#1490)
This commit is contained in:
parent
f258f328ef
commit
97353f195e
|
@ -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
|
||||
========================== ===============================================
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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()`."
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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
1
dict
|
@ -161,6 +161,7 @@ slot
|
|||
smalltalk
|
||||
sqlite
|
||||
surprenamment
|
||||
sextuplet
|
||||
sérialisable
|
||||
sérialisables
|
||||
sérialiser
|
||||
|
|
|
@ -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*"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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."
|
||||
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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()``) ::"
|
||||
|
|
|
@ -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))``."
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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`."
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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)."
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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 ::"
|
||||
|
||||
|
|
|
@ -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 à ::"
|
||||
|
|
|
@ -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."
|
||||
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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."
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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."
|
||||
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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."
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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."
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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."
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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`."
|
||||
|
|
|
@ -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."
|
||||
|
|
|
@ -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*."
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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 "
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ::"
|
||||
|
||||
|
|
|
@ -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 ""
|
||||
|
|
|
@ -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 ""
|
||||
|
||||
|
|
|
@ -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 ::"
|
||||
|
||||
|
|
Loading…
Reference in New Issue
Block a user