forked from AFPy/python-docs-fr
Relecture de tutorial/datastructures (#1753)
Co-authored-by: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com>
This commit is contained in:
parent
eac1fed73f
commit
9aeda18cd3
|
@ -6,14 +6,14 @@ msgstr ""
|
||||||
"Project-Id-Version: Python 3\n"
|
"Project-Id-Version: Python 3\n"
|
||||||
"Report-Msgid-Bugs-To: \n"
|
"Report-Msgid-Bugs-To: \n"
|
||||||
"POT-Creation-Date: 2021-05-19 22:36+0200\n"
|
"POT-Creation-Date: 2021-05-19 22:36+0200\n"
|
||||||
"PO-Revision-Date: 2020-09-30 14:26+0200\n"
|
"PO-Revision-Date: 2021-08-07 11:51+0200\n"
|
||||||
"Last-Translator: Jules Lasne <jules.lasne@gmail.com>\n"
|
"Last-Translator: Antoine Wecxsteen\n"
|
||||||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||||||
"Language: fr\n"
|
"Language: fr\n"
|
||||||
"MIME-Version: 1.0\n"
|
"MIME-Version: 1.0\n"
|
||||||
"Content-Type: text/plain; charset=UTF-8\n"
|
"Content-Type: text/plain; charset=UTF-8\n"
|
||||||
"Content-Transfer-Encoding: 8bit\n"
|
"Content-Transfer-Encoding: 8bit\n"
|
||||||
"X-Generator: Poedit 2.4.1\n"
|
"X-Generator: Poedit 2.3\n"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:5
|
#: tutorial/datastructures.rst:5
|
||||||
msgid "Data Structures"
|
msgid "Data Structures"
|
||||||
|
@ -37,7 +37,7 @@ msgid ""
|
||||||
"list objects:"
|
"list objects:"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Le type liste dispose de méthodes supplémentaires. Voici toutes les méthodes "
|
"Le type liste dispose de méthodes supplémentaires. Voici toutes les méthodes "
|
||||||
"des objets de type liste :"
|
"des objets liste :"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:22
|
#: tutorial/datastructures.rst:22
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -60,9 +60,9 @@ msgid ""
|
||||||
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
|
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Insère un élément à la position indiquée. Le premier argument est la "
|
"Insère un élément à la position indiquée. Le premier argument est la "
|
||||||
"position de l'élément courant avant lequel l'insertion doit s'effectuer, "
|
"position de l'élément avant lequel l'insertion doit s'effectuer, donc ``a."
|
||||||
"donc ``a.insert(0, x)`` insère l'élément en tête de la liste et ``a."
|
"insert(0, x)`` insère l'élément en tête de la liste et ``a.insert(len(a), "
|
||||||
"insert(len(a), x)`` est équivalent à ``a.append(x)``."
|
"x)`` est équivalent à ``a.append(x)``."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:43
|
#: tutorial/datastructures.rst:43
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -145,10 +145,10 @@ msgid ""
|
||||||
"default ``None``. [1]_ This is a design principle for all mutable data "
|
"default ``None``. [1]_ This is a design principle for all mutable data "
|
||||||
"structures in Python."
|
"structures in Python."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Vous avez probablement remarqué que les méthodes telles que ``insert``, "
|
"Vous avez probablement remarqué que les méthodes qui ne font que modifier la "
|
||||||
"``remove`` ou ``sort``, qui ne font que modifier la liste, n'affichent pas "
|
"liste, comme ``insert``, ``remove`` ou ``sort`, n'affichent pas de valeur de "
|
||||||
"de valeur de retour (elles renvoient ``None``) [1]_. C'est un principe "
|
"retour (elles renvoient ``None``) [1]_. C'est un principe respecté par "
|
||||||
"respecté par toutes les structures de données variables en Python."
|
"toutes les structures de données muables en Python."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:128
|
#: tutorial/datastructures.rst:128
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -158,9 +158,9 @@ msgid ""
|
||||||
"types. Also, there are some types that don't have a defined ordering "
|
"types. Also, there are some types that don't have a defined ordering "
|
||||||
"relation. For example, ``3+4j < 5+7j`` isn't a valid comparison."
|
"relation. For example, ``3+4j < 5+7j`` isn't a valid comparison."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Une autre chose que vous remarquerez peut-être est que toutes les données ne "
|
"Vous avez peut-être remarqué aussi que certaines données ne peuvent pas être "
|
||||||
"peuvent pas être ordonnées ou comparées. Par exemple, ``[None, 'hello', "
|
"ordonnées ni comparées. Par exemple, la liste ``[None, 'hello', 10]`` ne "
|
||||||
"10]`` ne sera pas ordonné parce que les entiers ne peuvent pas être comparés "
|
"peut pas être ordonnée parce que les entiers ne peuvent pas être comparés "
|
||||||
"aux chaînes de caractères et *None* ne peut pas être comparé à d'autres "
|
"aux chaînes de caractères et *None* ne peut pas être comparé à d'autres "
|
||||||
"types. En outre, il existe certains types qui n'ont pas de relation d'ordre "
|
"types. En outre, il existe certains types qui n'ont pas de relation d'ordre "
|
||||||
"définie. Par exemple, ``3+4j < 5+7j`` n'est pas une comparaison valide."
|
"définie. Par exemple, ``3+4j < 5+7j`` n'est pas une comparaison valide."
|
||||||
|
@ -200,22 +200,22 @@ msgstr ""
|
||||||
"élément ajouté est le premier récupéré (« premier entré, premier sorti » ou "
|
"élément ajouté est le premier récupéré (« premier entré, premier sorti » ou "
|
||||||
"FIFO pour *first-in, first-out*) ; toutefois, les listes ne sont pas très "
|
"FIFO pour *first-in, first-out*) ; toutefois, les listes ne sont pas très "
|
||||||
"efficaces pour réaliser ce type de traitement. Alors que les ajouts et "
|
"efficaces pour réaliser ce type de traitement. Alors que les ajouts et "
|
||||||
"suppressions en fin de liste sont rapides, les opérations d'insertions ou de "
|
"suppressions en fin de liste sont rapides, les insertions ou les retraits en "
|
||||||
"retraits en début de liste sont lentes (car tous les autres éléments doivent "
|
"début de liste sont lents (car tous les autres éléments doivent être décalés "
|
||||||
"être décalés d'une position)."
|
"d'une position)."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:179
|
#: tutorial/datastructures.rst:179
|
||||||
msgid ""
|
msgid ""
|
||||||
"To implement a queue, use :class:`collections.deque` which was designed to "
|
"To implement a queue, use :class:`collections.deque` which was designed to "
|
||||||
"have fast appends and pops from both ends. For example::"
|
"have fast appends and pops from both ends. For example::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Pour implémenter une file, utilisez la classe :class:`collections.deque` qui "
|
"Pour implémenter une file, utilisez plutôt la classe :class:`collections."
|
||||||
"a été conçue pour réaliser rapidement les opérations d'ajouts et de retraits "
|
"deque` qui a été conçue spécialement pour réaliser rapidement les opérations "
|
||||||
"aux deux extrémités. Par exemple ::"
|
"d'ajout et de retrait aux deux extrémités. Par exemple ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:197
|
#: tutorial/datastructures.rst:197
|
||||||
msgid "List Comprehensions"
|
msgid "List Comprehensions"
|
||||||
msgstr "Compréhensions de listes"
|
msgstr "Listes en compréhension"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:199
|
#: tutorial/datastructures.rst:199
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -224,11 +224,11 @@ msgid ""
|
||||||
"operations applied to each member of another sequence or iterable, or to "
|
"operations applied to each member of another sequence or iterable, or to "
|
||||||
"create a subsequence of those elements that satisfy a certain condition."
|
"create a subsequence of those elements that satisfy a certain condition."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Les compréhensions de listes fournissent un moyen de construire des listes "
|
"Les listes en compréhension fournissent un moyen de construire des listes de "
|
||||||
"de manière très concise. Une application classique est la construction de "
|
"manière très concise. Une application classique consiste à construire une "
|
||||||
"nouvelles listes où chaque élément est le résultat d'une opération appliquée "
|
"liste dont les éléments sont les résultats d'une opération appliquée à "
|
||||||
"à chaque élément d'une autre séquence ; ou de créer une sous-séquence des "
|
"chaque élément d'une autre séquence ; une autre consiste à créer une sous-"
|
||||||
"éléments satisfaisant une condition spécifique."
|
"séquence des éléments respectant une condition donnée."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:204
|
#: tutorial/datastructures.rst:204
|
||||||
msgid "For example, assume we want to create a list of squares, like::"
|
msgid "For example, assume we want to create a list of squares, like::"
|
||||||
|
@ -251,7 +251,7 @@ msgstr "ou, de manière équivalente ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:223
|
#: tutorial/datastructures.rst:223
|
||||||
msgid "which is more concise and readable."
|
msgid "which is more concise and readable."
|
||||||
msgstr "qui est plus court et lisible."
|
msgstr "ce qui est plus court et lisible."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:225
|
#: tutorial/datastructures.rst:225
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -262,7 +262,7 @@ msgid ""
|
||||||
"which follow it. For example, this listcomp combines the elements of two "
|
"which follow it. For example, this listcomp combines the elements of two "
|
||||||
"lists if they are not equal::"
|
"lists if they are not equal::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Une compréhension de liste consiste à placer entre crochets une expression "
|
"Une liste en compréhension consiste à placer entre crochets une expression "
|
||||||
"suivie par une clause :keyword:`!for` puis par zéro ou plus clauses :keyword:"
|
"suivie par une clause :keyword:`!for` puis par zéro ou plus clauses :keyword:"
|
||||||
"`!for` ou :keyword:`!if`. Le résultat est une nouvelle liste résultat de "
|
"`!for` ou :keyword:`!if`. Le résultat est une nouvelle liste résultat de "
|
||||||
"l'évaluation de l'expression dans le contexte des clauses :keyword:`!for` "
|
"l'évaluation de l'expression dans le contexte des clauses :keyword:`!for` "
|
||||||
|
@ -287,26 +287,26 @@ msgid ""
|
||||||
"it must be parenthesized. ::"
|
"it must be parenthesized. ::"
|
||||||
msgstr ""
|
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 ::"
|
"elle doit être mise entre parenthèses ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:280
|
#: tutorial/datastructures.rst:280
|
||||||
msgid ""
|
msgid ""
|
||||||
"List comprehensions can contain complex expressions and nested functions::"
|
"List comprehensions can contain complex expressions and nested functions::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Les compréhensions de listes peuvent contenir des expressions complexes et "
|
"Les listes en compréhension peuvent contenir des expressions complexes et "
|
||||||
"des fonctions imbriquées ::"
|
"des fonctions imbriquées ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:287
|
#: tutorial/datastructures.rst:287
|
||||||
msgid "Nested List Comprehensions"
|
msgid "Nested List Comprehensions"
|
||||||
msgstr "Compréhensions de listes imbriquées"
|
msgstr "Listes en compréhensions imbriquées"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:289
|
#: tutorial/datastructures.rst:289
|
||||||
msgid ""
|
msgid ""
|
||||||
"The initial expression in a list comprehension can be any arbitrary "
|
"The initial expression in a list comprehension can be any arbitrary "
|
||||||
"expression, including another list comprehension."
|
"expression, including another list comprehension."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"La première expression dans une compréhension de liste peut être n'importe "
|
"La première expression dans une liste en compréhension peut être n'importe "
|
||||||
"quelle expression, y compris une autre compréhension de liste."
|
"quelle expression, y compris une autre liste en compréhension."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:292
|
#: tutorial/datastructures.rst:292
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -326,13 +326,13 @@ msgid ""
|
||||||
"context of the :keyword:`for` that follows it, so this example is equivalent "
|
"context of the :keyword:`for` that follows it, so this example is equivalent "
|
||||||
"to::"
|
"to::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Comme nous l'avons vu dans la section précédente, la compréhension de liste "
|
"Comme nous l'avons vu dans la section précédente, la liste en compréhension "
|
||||||
"imbriquée est évaluée dans le contexte de l'instruction :keyword:`for` qui "
|
"imbriquée est évaluée dans le contexte de l'instruction :keyword:`for` qui "
|
||||||
"la suit, donc cet exemple est équivalent à ::"
|
"la suit, donc cet exemple est équivalent à ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:317
|
#: tutorial/datastructures.rst:317
|
||||||
msgid "which, in turn, is the same as::"
|
msgid "which, in turn, is the same as::"
|
||||||
msgstr "lequel à son tour est équivalent à ::"
|
msgstr "lequel est lui-même équivalent à ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:330
|
#: tutorial/datastructures.rst:330
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -341,14 +341,14 @@ msgid ""
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Dans des cas concrets, il est toujours préférable d'utiliser des fonctions "
|
"Dans des cas concrets, il est toujours préférable d'utiliser des fonctions "
|
||||||
"natives plutôt que des instructions de contrôle de flux complexes. La "
|
"natives plutôt que des instructions de contrôle de flux complexes. La "
|
||||||
"fonction :func:`zip` ferait dans ce cas un excellent travail ::"
|
"fonction :func:`zip` fait dans ce cas un excellent travail ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:336
|
#: tutorial/datastructures.rst:336
|
||||||
msgid ""
|
msgid ""
|
||||||
"See :ref:`tut-unpacking-arguments` for details on the asterisk in this line."
|
"See :ref:`tut-unpacking-arguments` for details on the asterisk in this line."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Voyez :ref:`tut-unpacking-arguments` pour plus de détails sur l'astérisque "
|
"Voir :ref:`tut-unpacking-arguments` pour plus de détails sur l'astérisque de "
|
||||||
"de cette ligne."
|
"cette ligne."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:341
|
#: tutorial/datastructures.rst:341
|
||||||
msgid "The :keyword:`!del` statement"
|
msgid "The :keyword:`!del` statement"
|
||||||
|
@ -381,11 +381,11 @@ msgid ""
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"À partir de là, référencer le nom ``a`` est une erreur (au moins jusqu'à ce "
|
"À partir de là, référencer le nom ``a`` est une erreur (au moins jusqu'à ce "
|
||||||
"qu'une autre valeur lui soit affectée). Vous trouverez d'autres utilisations "
|
"qu'une autre valeur lui soit affectée). Vous trouverez d'autres utilisations "
|
||||||
"de la fonction :keyword:`del` plus tard."
|
"de la fonction :keyword:`del` dans la suite de ce tutoriel."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:371
|
#: tutorial/datastructures.rst:371
|
||||||
msgid "Tuples and Sequences"
|
msgid "Tuples and Sequences"
|
||||||
msgstr "Tuples et séquences"
|
msgstr "*n*-uplets et séquences"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:373
|
#: tutorial/datastructures.rst:373
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -400,8 +400,7 @@ msgstr ""
|
||||||
"Ce sont deux exemples de *séquences* (voir :ref:`typesseq`). Comme Python "
|
"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 "
|
"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 : "
|
"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 *n*-uplet (*tuple* en anglais)."
|
||||||
"cette documentation)."
|
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:379
|
#: tutorial/datastructures.rst:379
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -424,8 +423,8 @@ msgstr ""
|
||||||
"correctement ; ils peuvent être saisis avec ou sans parenthèses, même si "
|
"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 "
|
"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 "
|
"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 "
|
"valeur à un élément d'un *n*-uplet ; par contre, il est en revanche possible "
|
||||||
"des *n*-uplets contenant des objets muables, comme des listes."
|
"de créer des *n*-uplets contenant des objets muables, comme des listes."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:408
|
#: tutorial/datastructures.rst:408
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -438,13 +437,14 @@ msgid ""
|
||||||
"iterating over the list."
|
"iterating over the list."
|
||||||
msgstr ""
|
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-"
|
"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 "
|
"uplets sont :term:`immuables <immuable>` et contiennent souvent des "
|
||||||
"hétérogènes d'éléments qui sont accédés par « dissociation » (*unpacking* en "
|
"séquences hétérogènes d'éléments auxquelles on accède par "
|
||||||
"anglais, voir plus loin) ou par indice (ou même par attributs dans le cas "
|
"« dissociation » (*unpacking* en anglais, voir plus loin) ou par indice (ou "
|
||||||
"des :func:`namedtuples <collections.namedtuple>`). Les listes sont souvent :"
|
"même par attribut dans le cas des :func:`namedtuples <collections."
|
||||||
"term:`muable <muable>`\\s et contiennent des éléments généralement homogènes "
|
"namedtuple>`). Les listes sont souvent :term:`muables <muable>` et "
|
||||||
"qui sont accédés par itération sur la liste."
|
"contiennent des éléments généralement homogènes auxquels on accède en "
|
||||||
|
"itérant sur la liste."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:416
|
#: tutorial/datastructures.rst:416
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -454,12 +454,12 @@ msgid ""
|
||||||
"constructed by following a value with a comma (it is not sufficient to "
|
"constructed by following a value with a comma (it is not sufficient to "
|
||||||
"enclose a single value in parentheses). Ugly, but effective. For example::"
|
"enclose a single value in parentheses). Ugly, but effective. For example::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Un problème spécifique est la construction de *n*-uplets ne contenant aucun "
|
"La construction de *n*-uplets ne contenant aucun ou un seul élément est un "
|
||||||
"ou un seul élément : la syntaxe a quelques tournures spécifiques pour s'en "
|
"cas particulier : la syntaxe a quelques tournures spécifiques pour le gérer. "
|
||||||
"accommoder. Les *n*-uplets vides sont construits par une paire de "
|
"Un *n*-uplet vide se construit avec une paire de parenthèses vides ; un *n*-"
|
||||||
"parenthèses vides ; un *n*-uplet avec un seul élément est construit en "
|
"uplet avec un seul élément se construit en faisant suivre la valeur par une "
|
||||||
"faisant suivre la valeur par une virgule (il n'est pas suffisant de placer "
|
"virgule (placer cette valeur entre parenthèses ne suffit pas). Pas très "
|
||||||
"cette valeur entre parenthèses). Pas très joli, mais efficace. Par exemple ::"
|
"joli, mais efficace. Par exemple ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:431
|
#: tutorial/datastructures.rst:431
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -467,10 +467,10 @@ msgid ""
|
||||||
"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
|
"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
|
||||||
"together in a tuple. The reverse operation is also possible::"
|
"together in a tuple. The reverse operation is also possible::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple d'un "
|
"L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple *d'agrégation "
|
||||||
"*d'agrégation de *n*-uplet* (*tuple packing* en anglais) : les valeurs "
|
"de *n*-uplet* (*tuple packing* en anglais) : les valeurs ``12345``, "
|
||||||
"``12345``, ``54321`` et ``hello !`` sont agrégées ensemble dans un *n*-"
|
"``54321`` et ``hello !`` sont agrégées ensemble dans un *n*-uplet. "
|
||||||
"uplet. L'opération inverse est aussi possible ::"
|
"L'opération inverse est aussi possible ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:437
|
#: tutorial/datastructures.rst:437
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -480,7 +480,7 @@ msgid ""
|
||||||
"in the sequence. Note that multiple assignment is really just a combination "
|
"in the sequence. Note that multiple assignment is really just a combination "
|
||||||
"of tuple packing and sequence unpacking."
|
"of tuple packing and sequence unpacking."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Ceci est appelé, de façon plus ou moins appropriée, un *dissociation de "
|
"Ceci est appelé, de façon plus ou moins appropriée, une *dissociation de "
|
||||||
"séquence* (*sequence unpacking* en anglais) et fonctionne pour toute "
|
"séquence* (*sequence unpacking* en anglais) et fonctionne pour toute "
|
||||||
"séquence placée à droite de l'expression. Cette dissociation requiert autant "
|
"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. "
|
"de variables dans la partie gauche qu'il y a d'éléments dans la séquence. "
|
||||||
|
@ -500,9 +500,9 @@ msgid ""
|
||||||
"difference."
|
"difference."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Python fournit également un type de donnée pour les *ensembles*. Un ensemble "
|
"Python fournit également un type de donnée pour les *ensembles*. Un ensemble "
|
||||||
"est une collection non ordonnée sans élément dupliqué. Des utilisations "
|
"est une collection non ordonnée sans éléments en double. Un ensemble permet "
|
||||||
"basiques concernent par exemple des tests d'appartenance ou des suppressions "
|
"de réaliser des tests d'appartenance ou des suppressions de doublons de "
|
||||||
"de doublons. Les ensembles savent également effectuer les opérations "
|
"manière simple. Les ensembles savent également effectuer les opérations "
|
||||||
"mathématiques telles que les unions, intersections, différences et "
|
"mathématiques telles que les unions, intersections, différences et "
|
||||||
"différences symétriques."
|
"différences symétriques."
|
||||||
|
|
||||||
|
@ -513,9 +513,10 @@ msgid ""
|
||||||
"creates an empty dictionary, a data structure that we discuss in the next "
|
"creates an empty dictionary, a data structure that we discuss in the next "
|
||||||
"section."
|
"section."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Des accolades ou la fonction :func:`set` peuvent être utilisés pour créer "
|
"On crée des ensembles en appelant avec des accolades ou avec la fonction :"
|
||||||
"des ensembles. Notez que pour créer un ensemble vide, ``{}`` ne fonctionne "
|
"func:`set`. Notez que ``{}`` ne crée pas un ensemble vide, mais un "
|
||||||
"pas, cela crée un dictionnaire vide. Utilisez plutôt ``set()``."
|
"dictionnaire (une structure de données dont nous allons parler dans la "
|
||||||
|
"séquence suivante) vide ; utilisez ``set()`` pour ce cas."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:458
|
#: tutorial/datastructures.rst:458
|
||||||
msgid "Here is a brief demonstration::"
|
msgid "Here is a brief demonstration::"
|
||||||
|
@ -526,8 +527,8 @@ msgid ""
|
||||||
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
|
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
|
||||||
"are also supported::"
|
"are also supported::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Tout comme pour les :ref:`compréhensions de listes <tut-listcomps>`, il est "
|
"Tout comme pour les :ref:`listes en compréhension <tut-listcomps>`, il est "
|
||||||
"possible d'écrire des compréhensions d'ensembles ::"
|
"possible d'écrire des ensembles en compréhension ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:494
|
#: tutorial/datastructures.rst:494
|
||||||
msgid "Dictionaries"
|
msgid "Dictionaries"
|
||||||
|
@ -568,13 +569,12 @@ msgid ""
|
||||||
"of key:value pairs within the braces adds initial key:value pairs to the "
|
"of key:value pairs within the braces adds initial key:value pairs to the "
|
||||||
"dictionary; this is also the way dictionaries are written on output."
|
"dictionary; this is also the way dictionaries are written on output."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Le plus simple est de considérer les dictionnaires comme des ensembles de "
|
"Le plus simple est de voir un dictionnaire comme un ensemble de paires *clé-"
|
||||||
"paires *clé: valeur*, les clés devant être uniques (au sein d'un "
|
"valeur* au sein duquel les clés doivent être uniques. Une paire d'accolades "
|
||||||
"dictionnaire). Une paire d'accolades crée un dictionnaire vide : ``{}``. "
|
"crée un dictionnaire vide : ``{}``. Placer une liste de paires clé-valeur "
|
||||||
"Placer une liste de paires clé:valeur séparées par des virgules à "
|
"séparées par des virgules à l'intérieur des accolades ajoute les valeurs "
|
||||||
"l'intérieur des accolades ajoute les valeurs correspondantes au "
|
"correspondantes au dictionnaire ; c'est également de cette façon que les "
|
||||||
"dictionnaire ; c'est également de cette façon que les dictionnaires sont "
|
"dictionnaires sont affichés."
|
||||||
"affichés."
|
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:513
|
#: tutorial/datastructures.rst:513
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -620,8 +620,8 @@ msgid ""
|
||||||
"In addition, dict comprehensions can be used to create dictionaries from "
|
"In addition, dict comprehensions can be used to create dictionaries from "
|
||||||
"arbitrary key and value expressions::"
|
"arbitrary key and value expressions::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"De plus, il est possible de créer des dictionnaires par compréhension depuis "
|
"De plus, il est possible de créer des dictionnaires en compréhension depuis "
|
||||||
"un jeu de clef et valeurs ::"
|
"un jeu de clés et valeurs ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:557
|
#: tutorial/datastructures.rst:557
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -629,7 +629,7 @@ msgid ""
|
||||||
"using keyword arguments::"
|
"using keyword arguments::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Lorsque les clés sont de simples chaînes de caractères, il est parfois plus "
|
"Lorsque les clés sont de simples chaînes de caractères, il est parfois plus "
|
||||||
"facile de spécifier les paires en utilisant des paramètres nommés ::"
|
"facile de définir les paires en utilisant des paramètres nommés ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:567
|
#: tutorial/datastructures.rst:567
|
||||||
msgid "Looping Techniques"
|
msgid "Looping Techniques"
|
||||||
|
@ -640,8 +640,8 @@ msgid ""
|
||||||
"When looping through dictionaries, the key and corresponding value can be "
|
"When looping through dictionaries, the key and corresponding value can be "
|
||||||
"retrieved at the same time using the :meth:`items` method. ::"
|
"retrieved at the same time using the :meth:`items` method. ::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Lorsque vous faites une boucle sur un dictionnaire, les clés et leurs "
|
"Lorsque vous faites une boucle sur un dictionnaire, la clé et la valeur "
|
||||||
"valeurs peuvent être récupérées en même temps en utilisant la méthode :meth:"
|
"associée peuvent être récupérées en même temps en utilisant la méthode :meth:"
|
||||||
"`items` ::"
|
"`items` ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:579
|
#: tutorial/datastructures.rst:579
|
||||||
|
@ -650,8 +650,8 @@ msgid ""
|
||||||
"can be retrieved at the same time using the :func:`enumerate` function. ::"
|
"can be retrieved at the same time using the :func:`enumerate` function. ::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Lorsque vous faites une boucle sur une séquence, la position et la valeur "
|
"Lorsque vous faites une boucle sur une séquence, la position et la valeur "
|
||||||
"correspondante peuvent être récupérées en même temps en utilisant la "
|
"associée peuvent être récupérées en même temps en utilisant la fonction :"
|
||||||
"fonction :func:`enumerate`. ::"
|
"func:`enumerate`. ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:589
|
#: tutorial/datastructures.rst:589
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -687,18 +687,18 @@ msgid ""
|
||||||
"order. ::"
|
"order. ::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"L'utilisation de la fonction :func:`set` sur une séquence élimine les "
|
"L'utilisation de la fonction :func:`set` sur une séquence élimine les "
|
||||||
"doublons. L'utilisation de la fonction :func:`sorted` en combinaison avec :"
|
"doublons. Combiner les fonctions :func:`sorted` et :func:`set` sur une "
|
||||||
"func:`set` sur une séquence est une façon idiomatique de boucler sur les "
|
"séquence est la façon « canonique » d'itérer sur les éléments uniques d'une "
|
||||||
"éléments uniques d'une séquence dans l'ordre. ::"
|
"séquence dans l'ordre. ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:640
|
#: tutorial/datastructures.rst:640
|
||||||
msgid ""
|
msgid ""
|
||||||
"It is sometimes tempting to change a list while you are looping over it; "
|
"It is sometimes tempting to change a list while you are looping over it; "
|
||||||
"however, it is often simpler and safer to create a new list instead. ::"
|
"however, it is often simpler and safer to create a new list instead. ::"
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Il est parfois tentant de modifier une liste pendant son itération. "
|
"Il est parfois tentant de modifier une liste pendant que l'on itère dessus. "
|
||||||
"Cependant, c'est souvent plus simple et plus sûr de créer une nouvelle liste "
|
"Il est souvent plus simple et plus sûr de créer une nouvelle liste à la "
|
||||||
"à la place. ::"
|
"place. ::"
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:657
|
#: tutorial/datastructures.rst:657
|
||||||
msgid "More on Conditions"
|
msgid "More on Conditions"
|
||||||
|
@ -713,7 +713,6 @@ msgstr ""
|
||||||
"contenir n'importe quel opérateur, pas seulement des comparaisons."
|
"contenir n'importe quel opérateur, pas seulement des comparaisons."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:662
|
#: tutorial/datastructures.rst:662
|
||||||
#, fuzzy
|
|
||||||
msgid ""
|
msgid ""
|
||||||
"The comparison operators ``in`` and ``not in`` check whether a value occurs "
|
"The comparison operators ``in`` and ``not in`` check whether a value occurs "
|
||||||
"(does not occur) in a sequence. The operators ``is`` and ``is not`` compare "
|
"(does not occur) in a sequence. The operators ``is`` and ``is not`` compare "
|
||||||
|
@ -722,8 +721,7 @@ msgid ""
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Les opérateurs de comparaison ``in`` et ``not in`` testent si une valeur est "
|
"Les opérateurs de comparaison ``in`` et ``not in`` testent si une valeur est "
|
||||||
"présente ou non dans une séquence. Les opérateurs ``is`` et ``is not`` "
|
"présente ou non dans une séquence. Les opérateurs ``is`` et ``is not`` "
|
||||||
"testent si deux objets sont vraiment le même objet ; ceci n'est important "
|
"testent si deux objets sont vraiment le même objet. Tous les opérateurs de "
|
||||||
"que pour des objets muables comme des listes. Tous les opérateurs de "
|
|
||||||
"comparaison ont la même priorité, qui est plus faible que celle des "
|
"comparaison ont la même priorité, qui est plus faible que celle des "
|
||||||
"opérateurs numériques."
|
"opérateurs numériques."
|
||||||
|
|
||||||
|
@ -732,8 +730,8 @@ msgid ""
|
||||||
"Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` "
|
"Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` "
|
||||||
"is less than ``b`` and moreover ``b`` equals ``c``."
|
"is less than ``b`` and moreover ``b`` equals ``c``."
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Les comparaisons peuvent être enchaînées. Par exemple, ``a < b == c`` teste "
|
"Les comparaisons peuvent être chaînées. Par exemple, ``a < b == c`` teste si "
|
||||||
"si ``a`` est inférieur à ``b`` et si, de plus, ``b`` égale ``c``."
|
"``a`` est inférieur à ``b`` et si, de plus, ``b`` égale ``c``."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:670
|
#: tutorial/datastructures.rst:670
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -750,8 +748,8 @@ msgstr ""
|
||||||
"priorité inférieure à celle des opérateurs de comparaison ; entre eux, "
|
"priorité inférieure à celle des opérateurs de comparaison ; entre eux, "
|
||||||
"``not`` a la priorité la plus élevée et ``or`` la plus faible, de telle "
|
"``not`` a la priorité la plus élevée et ``or`` la plus faible, de telle "
|
||||||
"sorte que ``A and not B or C`` est équivalent à ``(A and (not B)) or C``. "
|
"sorte que ``A and not B or C`` est équivalent à ``(A and (not B)) or C``. "
|
||||||
"Comme toujours, des parenthèses peuvent être utilisées pour exprimer "
|
"Comme d'habitude, les parenthèses permettent d'exprimer l'instruction "
|
||||||
"l'instruction désirée."
|
"désirée."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:677
|
#: tutorial/datastructures.rst:677
|
||||||
msgid ""
|
msgid ""
|
||||||
|
@ -834,8 +832,8 @@ msgid ""
|
||||||
msgstr ""
|
msgstr ""
|
||||||
"Comparer des objets de type différents avec ``<`` ou ``>`` est autorisé si "
|
"Comparer des objets de type différents avec ``<`` ou ``>`` est autorisé si "
|
||||||
"les objets ont des méthodes de comparaison appropriées. Par exemple, les "
|
"les objets ont des méthodes de comparaison appropriées. Par exemple, les "
|
||||||
"types numériques sont comparés via leur valeur numérique, donc 0 égale 0,0, "
|
"types numériques sont comparés via leur valeur numérique, donc ``0`` égale "
|
||||||
"etc. Dans les autres cas, au lieu de donner un ordre imprévisible, "
|
"``0,0``, etc. Dans les autres cas, au lieu de donner un ordre imprévisible, "
|
||||||
"l'interpréteur lève une exception :exc:`TypeError`."
|
"l'interpréteur lève une exception :exc:`TypeError`."
|
||||||
|
|
||||||
#: tutorial/datastructures.rst:731
|
#: tutorial/datastructures.rst:731
|
||||||
|
|
Loading…
Reference in New Issue