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"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"POT-Creation-Date: 2021-05-19 22:36+0200\n"
|
||||
"PO-Revision-Date: 2020-09-30 14:26+0200\n"
|
||||
"Last-Translator: Jules Lasne <jules.lasne@gmail.com>\n"
|
||||
"PO-Revision-Date: 2021-08-07 11:51+0200\n"
|
||||
"Last-Translator: Antoine Wecxsteen\n"
|
||||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||||
"Language: fr\n"
|
||||
"MIME-Version: 1.0\n"
|
||||
"Content-Type: text/plain; charset=UTF-8\n"
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"X-Generator: Poedit 2.4.1\n"
|
||||
"X-Generator: Poedit 2.3\n"
|
||||
|
||||
#: tutorial/datastructures.rst:5
|
||||
msgid "Data Structures"
|
||||
|
@ -37,7 +37,7 @@ msgid ""
|
|||
"list objects:"
|
||||
msgstr ""
|
||||
"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
|
||||
msgid ""
|
||||
|
@ -60,9 +60,9 @@ msgid ""
|
|||
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
|
||||
msgstr ""
|
||||
"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, "
|
||||
"donc ``a.insert(0, x)`` insère l'élément en tête de la liste et ``a."
|
||||
"insert(len(a), x)`` est équivalent à ``a.append(x)``."
|
||||
"position de l'élément avant lequel l'insertion doit s'effectuer, donc ``a."
|
||||
"insert(0, x)`` insère l'élément en tête de la liste et ``a.insert(len(a), "
|
||||
"x)`` est équivalent à ``a.append(x)``."
|
||||
|
||||
#: tutorial/datastructures.rst:43
|
||||
msgid ""
|
||||
|
@ -145,10 +145,10 @@ msgid ""
|
|||
"default ``None``. [1]_ This is a design principle for all mutable data "
|
||||
"structures in Python."
|
||||
msgstr ""
|
||||
"Vous avez probablement remarqué que les méthodes telles que ``insert``, "
|
||||
"``remove`` ou ``sort``, qui ne font que modifier la liste, n'affichent pas "
|
||||
"de valeur de retour (elles renvoient ``None``) [1]_. C'est un principe "
|
||||
"respecté par toutes les structures de données variables en Python."
|
||||
"Vous avez probablement remarqué que les méthodes qui ne font que modifier la "
|
||||
"liste, comme ``insert``, ``remove`` ou ``sort`, n'affichent pas de valeur de "
|
||||
"retour (elles renvoient ``None``) [1]_. C'est un principe respecté par "
|
||||
"toutes les structures de données muables en Python."
|
||||
|
||||
#: tutorial/datastructures.rst:128
|
||||
msgid ""
|
||||
|
@ -158,9 +158,9 @@ msgid ""
|
|||
"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."
|
||||
msgstr ""
|
||||
"Une autre chose que vous remarquerez peut-être est que toutes les données ne "
|
||||
"peuvent pas être ordonnées ou comparées. Par exemple, ``[None, 'hello', "
|
||||
"10]`` ne sera pas ordonné parce que les entiers ne peuvent pas être comparés "
|
||||
"Vous avez peut-être remarqué aussi que certaines données ne peuvent pas être "
|
||||
"ordonnées ni comparées. Par exemple, la liste ``[None, 'hello', 10]`` ne "
|
||||
"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 "
|
||||
"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."
|
||||
|
@ -200,22 +200,22 @@ msgstr ""
|
|||
"é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 "
|
||||
"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 "
|
||||
"retraits en début de liste sont lentes (car tous les autres éléments doivent "
|
||||
"être décalés d'une position)."
|
||||
"suppressions en fin de liste sont rapides, les insertions ou les retraits en "
|
||||
"début de liste sont lents (car tous les autres éléments doivent être décalés "
|
||||
"d'une position)."
|
||||
|
||||
#: tutorial/datastructures.rst:179
|
||||
msgid ""
|
||||
"To implement a queue, use :class:`collections.deque` which was designed to "
|
||||
"have fast appends and pops from both ends. For example::"
|
||||
msgstr ""
|
||||
"Pour implémenter une file, utilisez la classe :class:`collections.deque` qui "
|
||||
"a été conçue pour réaliser rapidement les opérations d'ajouts et de retraits "
|
||||
"aux deux extrémités. Par exemple ::"
|
||||
"Pour implémenter une file, utilisez plutôt la classe :class:`collections."
|
||||
"deque` qui a été conçue spécialement pour réaliser rapidement les opérations "
|
||||
"d'ajout et de retrait aux deux extrémités. Par exemple ::"
|
||||
|
||||
#: tutorial/datastructures.rst:197
|
||||
msgid "List Comprehensions"
|
||||
msgstr "Compréhensions de listes"
|
||||
msgstr "Listes en compréhension"
|
||||
|
||||
#: tutorial/datastructures.rst:199
|
||||
msgid ""
|
||||
|
@ -224,11 +224,11 @@ msgid ""
|
|||
"operations applied to each member of another sequence or iterable, or to "
|
||||
"create a subsequence of those elements that satisfy a certain condition."
|
||||
msgstr ""
|
||||
"Les compréhensions de listes fournissent un moyen de construire des listes "
|
||||
"de manière très concise. Une application classique est la construction de "
|
||||
"nouvelles listes où chaque élément est le résultat d'une opération appliquée "
|
||||
"à chaque élément d'une autre séquence ; ou de créer une sous-séquence des "
|
||||
"éléments satisfaisant une condition spécifique."
|
||||
"Les listes en compréhension fournissent un moyen de construire des listes de "
|
||||
"manière très concise. Une application classique consiste à construire une "
|
||||
"liste dont les éléments sont les résultats d'une opération appliquée à "
|
||||
"chaque élément d'une autre séquence ; une autre consiste à créer une sous-"
|
||||
"séquence des éléments respectant une condition donnée."
|
||||
|
||||
#: tutorial/datastructures.rst:204
|
||||
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
|
||||
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
|
||||
msgid ""
|
||||
|
@ -262,7 +262,7 @@ msgid ""
|
|||
"which follow it. For example, this listcomp combines the elements of two "
|
||||
"lists if they are not equal::"
|
||||
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:"
|
||||
"`!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` "
|
||||
|
@ -287,26 +287,26 @@ msgid ""
|
|||
"it must be parenthesized. ::"
|
||||
msgstr ""
|
||||
"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
|
||||
msgid ""
|
||||
"List comprehensions can contain complex expressions and nested functions::"
|
||||
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 ::"
|
||||
|
||||
#: tutorial/datastructures.rst:287
|
||||
msgid "Nested List Comprehensions"
|
||||
msgstr "Compréhensions de listes imbriquées"
|
||||
msgstr "Listes en compréhensions imbriquées"
|
||||
|
||||
#: tutorial/datastructures.rst:289
|
||||
msgid ""
|
||||
"The initial expression in a list comprehension can be any arbitrary "
|
||||
"expression, including another list comprehension."
|
||||
msgstr ""
|
||||
"La première expression dans une compréhension de liste peut être n'importe "
|
||||
"quelle expression, y compris une autre compréhension de liste."
|
||||
"La première expression dans une liste en compréhension peut être n'importe "
|
||||
"quelle expression, y compris une autre liste en compréhension."
|
||||
|
||||
#: tutorial/datastructures.rst:292
|
||||
msgid ""
|
||||
|
@ -326,13 +326,13 @@ msgid ""
|
|||
"context of the :keyword:`for` that follows it, so this example is equivalent "
|
||||
"to::"
|
||||
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 "
|
||||
"la suit, donc cet exemple est équivalent à ::"
|
||||
|
||||
#: tutorial/datastructures.rst:317
|
||||
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
|
||||
msgid ""
|
||||
|
@ -341,14 +341,14 @@ msgid ""
|
|||
msgstr ""
|
||||
"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 "
|
||||
"fonction :func:`zip` ferait dans ce cas un excellent travail ::"
|
||||
"fonction :func:`zip` fait dans ce cas un excellent travail ::"
|
||||
|
||||
#: tutorial/datastructures.rst:336
|
||||
msgid ""
|
||||
"See :ref:`tut-unpacking-arguments` for details on the asterisk in this line."
|
||||
msgstr ""
|
||||
"Voyez :ref:`tut-unpacking-arguments` pour plus de détails sur l'astérisque "
|
||||
"de cette ligne."
|
||||
"Voir :ref:`tut-unpacking-arguments` pour plus de détails sur l'astérisque de "
|
||||
"cette ligne."
|
||||
|
||||
#: tutorial/datastructures.rst:341
|
||||
msgid "The :keyword:`!del` statement"
|
||||
|
@ -381,11 +381,11 @@ msgid ""
|
|||
msgstr ""
|
||||
"À 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 "
|
||||
"de la fonction :keyword:`del` plus tard."
|
||||
"de la fonction :keyword:`del` dans la suite de ce tutoriel."
|
||||
|
||||
#: tutorial/datastructures.rst:371
|
||||
msgid "Tuples and Sequences"
|
||||
msgstr "Tuples et séquences"
|
||||
msgstr "*n*-uplets et séquences"
|
||||
|
||||
#: tutorial/datastructures.rst:373
|
||||
msgid ""
|
||||
|
@ -400,8 +400,7 @@ 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 "
|
||||
"cette documentation)."
|
||||
"le *n*-uplet (*tuple* en anglais)."
|
||||
|
||||
#: tutorial/datastructures.rst:379
|
||||
msgid ""
|
||||
|
@ -424,8 +423,8 @@ msgstr ""
|
|||
"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."
|
||||
"valeur à un élément d'un *n*-uplet ; par contre, il est en revanche possible "
|
||||
"de créer des *n*-uplets contenant des objets muables, comme des listes."
|
||||
|
||||
#: tutorial/datastructures.rst:408
|
||||
msgid ""
|
||||
|
@ -438,13 +437,14 @@ msgid ""
|
|||
"iterating over the list."
|
||||
msgstr ""
|
||||
"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 "
|
||||
"anglais, voir plus loin) ou par indice (ou même par attributs dans le cas "
|
||||
"des :func:`namedtuples <collections.namedtuple>`). Les listes sont souvent :"
|
||||
"term:`muable <muable>`\\s et contiennent des éléments généralement homogènes "
|
||||
"qui sont accédés par itération sur la liste."
|
||||
"utilisés dans des cas différents et pour des raisons différentes. Les *n*-"
|
||||
"uplets sont :term:`immuables <immuable>` et contiennent souvent des "
|
||||
"séquences hétérogènes d'éléments auxquelles on accède par "
|
||||
"« dissociation » (*unpacking* en anglais, voir plus loin) ou par indice (ou "
|
||||
"même par attribut dans le cas des :func:`namedtuples <collections."
|
||||
"namedtuple>`). Les listes sont souvent :term:`muables <muable>` et "
|
||||
"contiennent des éléments généralement homogènes auxquels on accède en "
|
||||
"itérant sur la liste."
|
||||
|
||||
#: tutorial/datastructures.rst:416
|
||||
msgid ""
|
||||
|
@ -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 ::"
|
||||
"La construction de *n*-uplets ne contenant aucun ou un seul élément est un "
|
||||
"cas particulier : la syntaxe a quelques tournures spécifiques pour le gérer. "
|
||||
"Un *n*-uplet vide se construit avec une paire de parenthèses vides ; un *n*-"
|
||||
"uplet avec un seul élément se construit en faisant suivre la valeur par une "
|
||||
"virgule (placer cette valeur entre parenthèses ne suffit pas). Pas très "
|
||||
"joli, mais efficace. Par exemple ::"
|
||||
|
||||
#: tutorial/datastructures.rst:431
|
||||
msgid ""
|
||||
|
@ -467,10 +467,10 @@ msgid ""
|
|||
"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
|
||||
"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 ::"
|
||||
"L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple *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 ""
|
||||
|
@ -480,7 +480,7 @@ msgid ""
|
|||
"in the sequence. Note that multiple assignment is really just a combination "
|
||||
"of tuple packing and sequence unpacking."
|
||||
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 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. "
|
||||
|
@ -500,9 +500,9 @@ msgid ""
|
|||
"difference."
|
||||
msgstr ""
|
||||
"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 "
|
||||
"basiques concernent par exemple des tests d'appartenance ou des suppressions "
|
||||
"de doublons. Les ensembles savent également effectuer les opérations "
|
||||
"est une collection non ordonnée sans éléments en double. Un ensemble permet "
|
||||
"de réaliser des tests d'appartenance ou des suppressions de doublons de "
|
||||
"manière simple. Les ensembles savent également effectuer les opérations "
|
||||
"mathématiques telles que les unions, intersections, différences et "
|
||||
"différences symétriques."
|
||||
|
||||
|
@ -513,9 +513,10 @@ msgid ""
|
|||
"creates an empty dictionary, a data structure that we discuss in the next "
|
||||
"section."
|
||||
msgstr ""
|
||||
"Des accolades ou la fonction :func:`set` peuvent être utilisés pour créer "
|
||||
"des ensembles. Notez que pour créer un ensemble vide, ``{}`` ne fonctionne "
|
||||
"pas, cela crée un dictionnaire vide. Utilisez plutôt ``set()``."
|
||||
"On crée des ensembles en appelant avec des accolades ou avec la fonction :"
|
||||
"func:`set`. Notez que ``{}`` ne crée pas un ensemble vide, mais un "
|
||||
"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
|
||||
msgid "Here is a brief demonstration::"
|
||||
|
@ -526,8 +527,8 @@ msgid ""
|
|||
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
|
||||
"are also supported::"
|
||||
msgstr ""
|
||||
"Tout comme pour les :ref:`compréhensions de listes <tut-listcomps>`, il est "
|
||||
"possible d'écrire des compréhensions d'ensembles ::"
|
||||
"Tout comme pour les :ref:`listes en compréhension <tut-listcomps>`, il est "
|
||||
"possible d'écrire des ensembles en compréhension ::"
|
||||
|
||||
#: tutorial/datastructures.rst:494
|
||||
msgid "Dictionaries"
|
||||
|
@ -568,13 +569,12 @@ msgid ""
|
|||
"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."
|
||||
msgstr ""
|
||||
"Le plus simple est de considérer les dictionnaires comme des ensembles de "
|
||||
"paires *clé: valeur*, les clés devant être uniques (au sein d'un "
|
||||
"dictionnaire). Une paire d'accolades crée un dictionnaire vide : ``{}``. "
|
||||
"Placer une liste de paires clé:valeur séparées par des virgules à "
|
||||
"l'intérieur des accolades ajoute les valeurs correspondantes au "
|
||||
"dictionnaire ; c'est également de cette façon que les dictionnaires sont "
|
||||
"affichés."
|
||||
"Le plus simple est de voir un dictionnaire comme un ensemble de paires *clé-"
|
||||
"valeur* au sein duquel les clés doivent être uniques. Une paire d'accolades "
|
||||
"crée un dictionnaire vide : ``{}``. Placer une liste de paires clé-valeur "
|
||||
"séparées par des virgules à l'intérieur des accolades ajoute les valeurs "
|
||||
"correspondantes au dictionnaire ; c'est également de cette façon que les "
|
||||
"dictionnaires sont affichés."
|
||||
|
||||
#: tutorial/datastructures.rst:513
|
||||
msgid ""
|
||||
|
@ -620,8 +620,8 @@ msgid ""
|
|||
"In addition, dict comprehensions can be used to create dictionaries from "
|
||||
"arbitrary key and value expressions::"
|
||||
msgstr ""
|
||||
"De plus, il est possible de créer des dictionnaires par compréhension depuis "
|
||||
"un jeu de clef et valeurs ::"
|
||||
"De plus, il est possible de créer des dictionnaires en compréhension depuis "
|
||||
"un jeu de clés et valeurs ::"
|
||||
|
||||
#: tutorial/datastructures.rst:557
|
||||
msgid ""
|
||||
|
@ -629,7 +629,7 @@ msgid ""
|
|||
"using keyword arguments::"
|
||||
msgstr ""
|
||||
"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
|
||||
msgid "Looping Techniques"
|
||||
|
@ -640,8 +640,8 @@ msgid ""
|
|||
"When looping through dictionaries, the key and corresponding value can be "
|
||||
"retrieved at the same time using the :meth:`items` method. ::"
|
||||
msgstr ""
|
||||
"Lorsque vous faites une boucle sur un dictionnaire, les clés et leurs "
|
||||
"valeurs peuvent être récupérées en même temps en utilisant la méthode :meth:"
|
||||
"Lorsque vous faites une boucle sur un dictionnaire, la clé et la valeur "
|
||||
"associée peuvent être récupérées en même temps en utilisant la méthode :meth:"
|
||||
"`items` ::"
|
||||
|
||||
#: tutorial/datastructures.rst:579
|
||||
|
@ -650,8 +650,8 @@ msgid ""
|
|||
"can be retrieved at the same time using the :func:`enumerate` function. ::"
|
||||
msgstr ""
|
||||
"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 "
|
||||
"fonction :func:`enumerate`. ::"
|
||||
"associée peuvent être récupérées en même temps en utilisant la fonction :"
|
||||
"func:`enumerate`. ::"
|
||||
|
||||
#: tutorial/datastructures.rst:589
|
||||
msgid ""
|
||||
|
@ -687,18 +687,18 @@ msgid ""
|
|||
"order. ::"
|
||||
msgstr ""
|
||||
"L'utilisation de la fonction :func:`set` sur une séquence élimine les "
|
||||
"doublons. L'utilisation de la fonction :func:`sorted` en combinaison avec :"
|
||||
"func:`set` sur une séquence est une façon idiomatique de boucler sur les "
|
||||
"éléments uniques d'une séquence dans l'ordre. ::"
|
||||
"doublons. Combiner les fonctions :func:`sorted` et :func:`set` sur une "
|
||||
"séquence est la façon « canonique » d'itérer sur les éléments uniques d'une "
|
||||
"séquence dans l'ordre. ::"
|
||||
|
||||
#: tutorial/datastructures.rst:640
|
||||
msgid ""
|
||||
"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. ::"
|
||||
msgstr ""
|
||||
"Il est parfois tentant de modifier une liste pendant son itération. "
|
||||
"Cependant, c'est souvent plus simple et plus sûr de créer une nouvelle liste "
|
||||
"à la place. ::"
|
||||
"Il est parfois tentant de modifier une liste pendant que l'on itère dessus. "
|
||||
"Il est souvent plus simple et plus sûr de créer une nouvelle liste à la "
|
||||
"place. ::"
|
||||
|
||||
#: tutorial/datastructures.rst:657
|
||||
msgid "More on Conditions"
|
||||
|
@ -713,7 +713,6 @@ msgstr ""
|
|||
"contenir n'importe quel opérateur, pas seulement des comparaisons."
|
||||
|
||||
#: tutorial/datastructures.rst:662
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"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 "
|
||||
|
@ -722,8 +721,7 @@ msgid ""
|
|||
msgstr ""
|
||||
"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`` "
|
||||
"testent si deux objets sont vraiment le même objet ; ceci n'est important "
|
||||
"que pour des objets muables comme des listes. Tous les opérateurs de "
|
||||
"testent si deux objets sont vraiment le même objet. Tous les opérateurs de "
|
||||
"comparaison ont la même priorité, qui est plus faible que celle des "
|
||||
"opérateurs numériques."
|
||||
|
||||
|
@ -732,8 +730,8 @@ msgid ""
|
|||
"Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` "
|
||||
"is less than ``b`` and moreover ``b`` equals ``c``."
|
||||
msgstr ""
|
||||
"Les comparaisons peuvent être enchaînées. Par exemple, ``a < b == c`` teste "
|
||||
"si ``a`` est inférieur à ``b`` et si, de plus, ``b`` égale ``c``."
|
||||
"Les comparaisons peuvent être chaînées. Par exemple, ``a < b == c`` teste si "
|
||||
"``a`` est inférieur à ``b`` et si, de plus, ``b`` égale ``c``."
|
||||
|
||||
#: tutorial/datastructures.rst:670
|
||||
msgid ""
|
||||
|
@ -750,8 +748,8 @@ msgstr ""
|
|||
"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 "
|
||||
"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 "
|
||||
"l'instruction désirée."
|
||||
"Comme d'habitude, les parenthèses permettent d'exprimer l'instruction "
|
||||
"désirée."
|
||||
|
||||
#: tutorial/datastructures.rst:677
|
||||
msgid ""
|
||||
|
@ -834,8 +832,8 @@ msgid ""
|
|||
msgstr ""
|
||||
"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 "
|
||||
"types numériques sont comparés via leur valeur numérique, donc 0 égale 0,0, "
|
||||
"etc. Dans les autres cas, au lieu de donner un ordre imprévisible, "
|
||||
"types numériques sont comparés via leur valeur numérique, donc ``0`` égale "
|
||||
"``0,0``, etc. Dans les autres cas, au lieu de donner un ordre imprévisible, "
|
||||
"l'interpréteur lève une exception :exc:`TypeError`."
|
||||
|
||||
#: tutorial/datastructures.rst:731
|
||||
|
|
Loading…
Reference in New Issue
Block a user