python-docs-fr/tutorial/datastructures.po
Julien Palard 0d4bffbcf9 s/mutable/muable/
Long debate between those words. We could use "modifiable" too but the
binary relation between "immuable" and "modifiable" is less clear.

"muable" was in the 6th edition of the dictionnary of the Académie
française.
2017-10-27 17:43:57 +02:00

837 lines
39 KiB
Plaintext

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-05-27 19:40+0200\n"
"PO-Revision-Date: 2017-10-27 17:34+0200\n"
"Last-Translator: Julien Palard <julien@palard.fr>\n"
"Language-Team: \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.0.4\n"
#: ../Doc/tutorial/datastructures.rst:5
msgid "Data Structures"
msgstr "Structures de données"
#: ../Doc/tutorial/datastructures.rst:7
msgid ""
"This chapter describes some things you've learned about already in more "
"detail, and adds some new things as well."
msgstr ""
"Ce chapitre reprend plus en détail quelques point déjà décrits précédemment, "
"et introduit également de nouvelles notions."
#: ../Doc/tutorial/datastructures.rst:13
msgid "More on Lists"
msgstr "Compléments sur les listes"
#: ../Doc/tutorial/datastructures.rst:15
msgid ""
"The list data type has some more methods. Here are all of the methods of "
"list objects:"
msgstr ""
"Le type liste dispose de méthodes supplémentaires. Voici la liste complète "
"des méthodes des objets de type liste :"
#: ../Doc/tutorial/datastructures.rst:22
msgid ""
"Add an item to the end of the list. Equivalent to ``a[len(a):] = [x]``."
msgstr ""
"Ajoute un élément à la fin de la liste. Equivalent à ``a[len(a):] = [x]``."
#: ../Doc/tutorial/datastructures.rst:28
msgid ""
"Extend the list by appending all the items from the iterable. Equivalent to "
"``a[len(a):] = iterable``."
msgstr ""
"Étend la liste en y ajoutant tous les éléments de l'itérable. Équivalent à "
"``a[len(a):] = iterable``."
#: ../Doc/tutorial/datastructures.rst:35
msgid ""
"Insert an item at a given position. The first argument is the index of the "
"element before which to insert, so ``a.insert(0, x)`` inserts at the front "
"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)``."
#: ../Doc/tutorial/datastructures.rst:43
msgid ""
"Remove the first item from the list whose value is *x*. It is an error if "
"there is no such item."
msgstr ""
"Supprime de la liste le premier élément dont la valeur est *x*. Une "
"exception est levée s'il existe aucun élément avec cette valeur."
#: ../Doc/tutorial/datastructures.rst:50
msgid ""
"Remove the item at the given position in the list, and return it. If no "
"index is specified, ``a.pop()`` removes and returns the last item in the "
"list. (The square brackets around the *i* in the method signature denote "
"that the parameter is optional, not that you should type square brackets at "
"that position. You will see this notation frequently in the Python Library "
"Reference.)"
msgstr ""
"Enlève de la liste l'élément situé à la position indiquée, et le renvoie en "
"valeur de retour. Si aucune position n'est indiqué, ``a.pop()`` enlève et "
"renvoie le dernier élément de la liste (les crochets autour du *i* dans la "
"signature de la méthode indiquent bien que ce paramètre est facultatif, et "
"non que vous devez placer des crochets dans votre code ! Vous retrouverez "
"cette notation fréquemment dans le Guide de Référence de la Bibliothèque "
"Python)."
#: ../Doc/tutorial/datastructures.rst:60
msgid "Remove all items from the list. Equivalent to ``del a[:]``."
msgstr "Supprime tous les éléments de la liste, équivalent à ``del a[:]``."
#: ../Doc/tutorial/datastructures.rst:66
msgid ""
"Return zero-based index in the list of the first item whose value is *x*. "
"Raises a :exc:`ValueError` if there is no such item."
msgstr ""
"Renvoie la position du premier élément de la liste ayant la valeur *x* (en "
"commençant par zéro). Une exception :exc:`ValueError` est levée si aucun "
"élément n'est trouvé."
#: ../Doc/tutorial/datastructures.rst:69
msgid ""
"The optional arguments *start* and *end* are interpreted as in the slice "
"notation and are used to limit the search to a particular subsequence of the "
"list. The returned index is computed relative to the beginning of the full "
"sequence rather than the *start* argument."
msgstr ""
"Les arguments optionnels *start* et *end* sont interprétés de la même "
"manière que dans la notation des tranches, et sont utilisés pour limiter la "
"recherche à une sous-séquence particulière. L'index renvoyé est calculé "
"relativement au début de la séquence complète, et non relativement à *start*."
#: ../Doc/tutorial/datastructures.rst:78
msgid "Return the number of times *x* appears in the list."
msgstr "Renvoie le nombre d'éléments ayant la valeur *x* dans la liste."
#: ../Doc/tutorial/datastructures.rst:84
msgid ""
"Sort the items of the list in place (the arguments can be used for sort "
"customization, see :func:`sorted` for their explanation)."
msgstr ""
"Trie les éléments sur place, (les arguments peuvent personaliser le tri, "
"voir :func:`sorted` pour leur explication)."
#: ../Doc/tutorial/datastructures.rst:91
msgid "Reverse the elements of the list in place."
msgstr "Inverse l'ordre des éléments de la liste, sur place."
#: ../Doc/tutorial/datastructures.rst:97
msgid "Return a shallow copy of the list. Equivalent to ``a[:]``."
msgstr "Renvoie une copie superficielle de la liste. Équivalent à ``a[:]``."
#: ../Doc/tutorial/datastructures.rst:100
msgid "An example that uses most of the list methods::"
msgstr "L'exemple suivant utilise la plupart des méthodes des listes : ::"
#: ../Doc/tutorial/datastructures.rst:123
msgid ""
"You might have noticed that methods like ``insert``, ``remove`` or ``sort`` "
"that only modify the list have no return value printed -- they return the "
"default ``None``. [1]_ This is a design principle for all mutable data "
"structures in Python."
msgstr ""
"Vous avez probablement remarqué que les méthodes tel que ``insert``, "
"``remove`` ou ``sort``, qui ne font que modifier la liste, ne renvoient pas "
"de valeur mais ``None``. [1]_ C'est un principe respecté par toutes les "
"structures de données variables en Python."
#: ../Doc/tutorial/datastructures.rst:132
msgid "Using Lists as Stacks"
msgstr "Utiliser les listes comme des piles"
#: ../Doc/tutorial/datastructures.rst:137
msgid ""
"The list methods make it very easy to use a list as a stack, where the last "
"element added is the first element retrieved (\"last-in, first-out\"). To "
"add an item to the top of the stack, use :meth:`append`. To retrieve an "
"item from the top of the stack, use :meth:`pop` without an explicit index. "
"For example::"
msgstr ""
"Les méthodes des listes rendent très facile leur utilisation comme des "
"piles, où le dernier élément ajouté est le premier récupéré (\"dernier "
"entré, premier sorti\", ou LIFO pour \"last-in, first-out\"). Pour ajouter "
"un élément sur la pile, utilisez la méthode :meth:`append`. Pour récupérer "
"l'objet au sommet de la pile, utilisez la méthode :meth:`pop`, sans "
"indicateur de position. Par exemple : ::"
#: ../Doc/tutorial/datastructures.rst:162
msgid "Using Lists as Queues"
msgstr "Utiliser les listes comme des files"
#: ../Doc/tutorial/datastructures.rst:166
msgid ""
"It is also possible to use a list as a queue, where the first element added "
"is the first element retrieved (\"first-in, first-out\"); however, lists are "
"not efficient for this purpose. While appends and pops from the end of list "
"are fast, doing inserts or pops from the beginning of a list is slow "
"(because all of the other elements have to be shifted by one)."
msgstr ""
"Il est également possible d'utiliser une liste comme une file, où le premier "
"élément ajouté est le premier récupéré (\"premier entré, premier sorti\", ou "
"FIFO pour \"first-in, first-out\") ; touefois, les listes ne sont pas très "
"efficaces pour 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)."
#: ../Doc/tutorial/datastructures.rst:172
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 donc la classe :class:`collections."
"deque` qui a été conçue pour fournir des opérations d'ajouts et de retraits "
"rapides aux deux extrémités. Par exemple : ::"
#: ../Doc/tutorial/datastructures.rst:190
msgid "List Comprehensions"
msgstr "Compréhensions de listes"
#: ../Doc/tutorial/datastructures.rst:192
msgid ""
"List comprehensions provide a concise way to create lists. Common "
"applications are to make new lists where each element is the result of some "
"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 concice. 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."
#: ../Doc/tutorial/datastructures.rst:197
msgid "For example, assume we want to create a list of squares, like::"
msgstr ""
"Par exemple, supposons que l'on veuille créer une liste de carrés, comme : ::"
#: ../Doc/tutorial/datastructures.rst:206
msgid ""
"Note that this creates (or overwrites) a variable named ``x`` that still "
"exists after the loop completes. We can calculate the list of squares "
"without any side effects using::"
msgstr ""
"Notez que cela créé (ou écrase) une variable nommée ``x`` qui existe "
"toujours après l'exécution de la boucle. On peut calculer une liste de "
"carrés sans effet de bord, avec : ::"
#: ../Doc/tutorial/datastructures.rst:212
msgid "or, equivalently::"
msgstr "ou : ::"
#: ../Doc/tutorial/datastructures.rst:216
msgid "which is more concise and readable."
msgstr "qui est plus court et lisible."
#: ../Doc/tutorial/datastructures.rst:218
msgid ""
"A list comprehension consists of brackets containing an expression followed "
"by a :keyword:`for` clause, then zero or more :keyword:`for` or :keyword:"
"`if` clauses. The result will be a new list resulting from evaluating the "
"expression in the context of the :keyword:`for` and :keyword:`if` clauses "
"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 en crochets contenant une expression "
"suivie par une clause :keyword:`for`, puis par zéro ou plus clauses :keyword:"
"`for` ou :keyword:`if`. Le résultat sera une nouvelle liste résultat de "
"l'évaluation de l'expression dans le contexte des clauses :keyword:`for` et :"
"keyword:`if` qui la suivent. Par exemple, cette compréhension de liste "
"combine les éléments de deux listes s'ils ne sont pas égaux : ::"
#: ../Doc/tutorial/datastructures.rst:228
msgid "and it's equivalent to::"
msgstr "et c'est équivaent à : ::"
#: ../Doc/tutorial/datastructures.rst:239
msgid ""
"Note how the order of the :keyword:`for` and :keyword:`if` statements is the "
"same in both these snippets."
msgstr ""
"Notez que l'ordre des instructions :keyword:`for` et :keyword:`if` est le "
"même dans ces différents extraits de code."
#: ../Doc/tutorial/datastructures.rst:242
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 tuple (c'est à dire ``(x, y)`` dans cet exemple), "
"elle doit être entourée par des parenthèses : ::"
#: ../Doc/tutorial/datastructures.rst:273
msgid ""
"List comprehensions can contain complex expressions and nested functions::"
msgstr ""
"Les compréhensions de listes peuvent contenir des expressions complexes et "
"des fonctions imbriquées : ::"
#: ../Doc/tutorial/datastructures.rst:280
msgid "Nested List Comprehensions"
msgstr "Compréhensions de listes imbriquées"
#: ../Doc/tutorial/datastructures.rst:282
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."
#: ../Doc/tutorial/datastructures.rst:285
msgid ""
"Consider the following example of a 3x4 matrix implemented as a list of 3 "
"lists of length 4::"
msgstr ""
"Voyez l'exemple suivant d'une matrice de 3x4, implémentée sous la forme de 3 "
"listes de 4 éléments : ::"
#: ../Doc/tutorial/datastructures.rst:294
msgid "The following list comprehension will transpose rows and columns::"
msgstr ""
"Cette compréhension de liste va transposer les lignes et les colonnes : ::"
#: ../Doc/tutorial/datastructures.rst:299
msgid ""
"As we saw in the previous section, the nested listcomp is evaluated in the "
"context of the :keyword:`for` that follows it, so this example is equivalent "
"to::"
msgstr ""
"Comme on l'a vu dans la section précédente, la compréhension de liste "
"imbriquée est évaluée dans le contexte de l'instruction :keyword:`for` qui "
"la suit, donc cet exemple est équivalent à : ::"
#: ../Doc/tutorial/datastructures.rst:310
msgid "which, in turn, is the same as::"
msgstr "lequel à son tour est équivalent à : ::"
#: ../Doc/tutorial/datastructures.rst:323
msgid ""
"In the real world, you should prefer built-in functions to complex flow "
"statements. The :func:`zip` function would do a great job for this use case::"
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 : ::"
#: ../Doc/tutorial/datastructures.rst:329
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 cette ligne."
#: ../Doc/tutorial/datastructures.rst:334
msgid "The :keyword:`del` statement"
msgstr "L'instruction :keyword:`del`"
#: ../Doc/tutorial/datastructures.rst:336
msgid ""
"There is a way to remove an item from a list given its index instead of its "
"value: the :keyword:`del` statement. This differs from the :meth:`pop` "
"method which returns a value. The :keyword:`del` statement can also be used "
"to remove slices from a list or clear the entire list (which we did earlier "
"by assignment of an empty list to the slice). For example::"
msgstr ""
"Il existe un moyen de retirer un élément d'une liste à partir de sa position "
"au lieu de sa valeur : l'instruction :keyword:`del`. Elle diffère de la "
"méthode :meth:`pop` qui, elle, renvoie une valeur. L'instruction :keyword:"
"`del` peut également être utilisée pour supprimer des tranches d'une liste "
"ou la vider complètement (ce que nous avions fait auparavent en affectant "
"une liste vide à la tranche). Par exemple : ::"
#: ../Doc/tutorial/datastructures.rst:353
msgid ":keyword:`del` can also be used to delete entire variables::"
msgstr ""
":keyword:`del` peut aussi être utilisée pour supprimer des variables : ::"
#: ../Doc/tutorial/datastructures.rst:357
msgid ""
"Referencing the name ``a`` hereafter is an error (at least until another "
"value is assigned to it). We'll find other uses for :keyword:`del` later."
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."
#: ../Doc/tutorial/datastructures.rst:364
msgid "Tuples and Sequences"
msgstr "Tuples et séquences"
#: ../Doc/tutorial/datastructures.rst:366
msgid ""
"We saw that lists and strings have many common properties, such as indexing "
"and slicing operations. They are two examples of *sequence* data types "
"(see :ref:`typesseq`). Since Python is an evolving language, other sequence "
"data types may be added. There is also another standard sequence data type: "
"the *tuple*."
msgstr ""
"Nous avons vu que les listes et les chaînes de caractères ont beaucoup de "
"propriétés en commun, comme l'indexation et les opérations sur des tranches. "
"Ce sont deux exemple 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*."
#: ../Doc/tutorial/datastructures.rst:372
msgid ""
"A tuple consists of a number of values separated by commas, for instance::"
msgstr ""
"Un tuple consiste en différentes valeurs séparées par des virgules, comme "
"par exemple : ::"
#: ../Doc/tutorial/datastructures.rst:394
msgid ""
"As you see, on output tuples are always enclosed in parentheses, so that "
"nested tuples are interpreted correctly; they may be input with or without "
"surrounding parentheses, although often parentheses are necessary anyway (if "
"the tuple is part of a larger expression). It is not possible to assign to "
"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, à l'affichage les tuples sont toujours encadrés "
"par des parenthèses, de façon à ce que des tuples imbriqués soient "
"interprétés correctement ; ils peuvent être entrés avec ou sans parenthèses, "
"même si celles-ci sont souvent nécessaires (notamment lorsqu'un tuple fait "
"partie d'une expression plus longue). Il n'est pas possible d'affecter de "
"valeur à un élément d'un tuple ; par contre, il est possible de créer des "
"tuples contenant des objets muables, comme des listes."
#: ../Doc/tutorial/datastructures.rst:401
msgid ""
"Though tuples may seem similar to lists, they are often used in different "
"situations and for different purposes. Tuples are :term:`immutable`, and "
"usually contain a heterogeneous sequence of elements that are accessed via "
"unpacking (see later in this section) or indexing (or even by attribute in "
"the case of :func:`namedtuples <collections.namedtuple>`). Lists are :term:"
"`mutable`, and their elements are usually homogeneous and are accessed by "
"iterating over the list."
msgstr ""
"Si les tuples peuvent sembler similaires aux listes, ils sont souvent "
"utilisés dans des cas différents et pour des raisons différentes. Les tuples "
"sont :term:`immuable`\\s et contiennent souvent des séquences hétérogènes "
"d'éléments qui sont accédés par \"déballage\" (voir plus loin) ou indexation "
"(ou même par attributs dans le cas des :func:`namedtuples <collections."
"namedtuple>`). Les listes sont souvent :term:`muable <muable>`, et "
"contiennent des éléments homogènes qui sont accédés par itération sur la "
"liste."
#: ../Doc/tutorial/datastructures.rst:409
msgid ""
"A special problem is the construction of tuples containing 0 or 1 items: the "
"syntax has some extra quirks to accommodate these. Empty tuples are "
"constructed by an empty pair of parentheses; a tuple with one item is "
"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 tuples ne contenant aucun ou "
"un seul élément : la syntaxe a quelques tournures spécifiques pour s'en "
"accomoder. Les tuples vides sont construits par une paire de parenthèses "
"vides ; un tuple 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 : ::"
#: ../Doc/tutorial/datastructures.rst:424
msgid ""
"The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple "
"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 *emballage "
"de tuple* : les valeurs ``12345``, ``54321`` et ``hello !`` sont emballées "
"ensemble dans un tuple. L'opération inverse est aussi possible : ::"
#: ../Doc/tutorial/datastructures.rst:430
msgid ""
"This is called, appropriately enough, *sequence unpacking* and works for any "
"sequence on the right-hand side. Sequence unpacking requires that there are "
"as many variables on the left side of the equals sign as there are elements "
"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 *déballage de "
"séquence* et fonctionne pour toute séquence placée à droite de l'expression. "
"Ce déballage 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 un emballage de tuple et un déballage de "
"séquence."
#: ../Doc/tutorial/datastructures.rst:440
msgid "Sets"
msgstr "Les ensembles"
#: ../Doc/tutorial/datastructures.rst:442
msgid ""
"Python also includes a data type for *sets*. A set is an unordered "
"collection with no duplicate elements. Basic uses include membership "
"testing and eliminating duplicate entries. Set objects also support "
"mathematical operations like union, intersection, difference, and symmetric "
"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 suppressons "
"de doublons. Les ensembles supportent également les opérations mathématiques "
"comme les unions, intersections, différences et différences symétriques."
#: ../Doc/tutorial/datastructures.rst:447
msgid ""
"Curly braces or the :func:`set` function can be used to create sets. Note: "
"to create an empty set you have to use ``set()``, not ``{}``; the latter "
"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éé un dictionnaire vide. Utilisez plutôt ``set()``."
#: ../Doc/tutorial/datastructures.rst:451
msgid "Here is a brief demonstration::"
msgstr "Voici une brève démonstration : ::"
#: ../Doc/tutorial/datastructures.rst:476
msgid ""
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
"are also supported::"
msgstr ""
"Tout comme les :ref:`comprehensions de listes <tut-listcomps>`, il est "
"possibled'écrire des comprehensions d'ensembles : ::"
#: ../Doc/tutorial/datastructures.rst:487
msgid "Dictionaries"
msgstr "Dictionnaires"
#: ../Doc/tutorial/datastructures.rst:489
msgid ""
"Another useful data type built into Python is the *dictionary* (see :ref:"
"`typesmapping`). Dictionaries are sometimes found in other languages as "
"\"associative memories\" or \"associative arrays\". Unlike sequences, which "
"are indexed by a range of numbers, dictionaries are indexed by *keys*, which "
"can be any immutable type; strings and numbers can always be keys. Tuples "
"can be used as keys if they contain only strings, numbers, or tuples; if a "
"tuple contains any mutable object either directly or indirectly, it cannot "
"be used as a key. You can't use lists as keys, since lists can be modified "
"in place using index assignments, slice assignments, or methods like :meth:"
"`append` and :meth:`extend`."
msgstr ""
"Un autre type de donnée très utile, natif dans Python, est le *dictionnaire* "
"(voir :ref:`typesmapping`). Ces dictionnaires sont parfois présents dans "
"d'autres langages sous le nom de \"mémoires associatives\" ou de \"tableaux "
"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 tuples peuvent être utilisés comme clés "
"s'ils ne contiennent que des chaînes, des nombres ou des tuples ; si un "
"tuple 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`."
#: ../Doc/tutorial/datastructures.rst:500
msgid ""
"It is best to think of a dictionary as an unordered set of *key: value* "
"pairs, with the requirement that the keys are unique (within one "
"dictionary). A pair of braces creates an empty dictionary: ``{}``. Placing a "
"comma-separated list 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 non "
"ordonnés 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 en sortie."
#: ../Doc/tutorial/datastructures.rst:506
msgid ""
"The main operations on a dictionary are storing a value with some key and "
"extracting the value given the key. It is also possible to delete a key:"
"value pair with ``del``. If you store using a key that is already in use, "
"the old value associated with that key is forgotten. It is an error to "
"extract a value using a non-existent key."
msgstr ""
"Les principales opérations effectuées sur un dictionnaire consistent à "
"stocker une valeur pour une clé et à extraire la valeur correspondant à une "
"clé. Il est également possible de supprimer une paire clé:valeur avec "
"``del``. Si vous stockez une valeur pour une clé qui est déjà utilisée, "
"l'ancienne valeur associée à cette clé est perdue. Si vous tentez d'extraire "
"une valeur associée à une clé qui n'existe pas, une exception est levée."
#: ../Doc/tutorial/datastructures.rst:512
msgid ""
"Performing ``list(d.keys())`` on a dictionary returns a list of all the keys "
"used in the dictionary, in arbitrary order (if you want it sorted, just use "
"``sorted(d.keys())`` instead). [2]_ To check whether a single key is in the "
"dictionary, use the :keyword:`in` keyword."
msgstr ""
"Exécuter ``list(d.keys())`` sur un dictionnaire ``d`` renvoie une liste de "
"toutes lesclés utilisées dans le dictionnaire, dans un ordre arbitraire (si "
"vous voulez qu'elles soient triées, utilisez ``sorted(d.keys())``). [2]_ "
"Pour tester si une clé est dans le dictionnaire, utilisez le mot-clé :"
"keyword:`in`."
#: ../Doc/tutorial/datastructures.rst:517
msgid "Here is a small example using a dictionary::"
msgstr "Voici un petit exemple utilisant un dictionnaire : ::"
#: ../Doc/tutorial/datastructures.rst:538
msgid ""
"The :func:`dict` constructor builds dictionaries directly from sequences of "
"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 tuples : ::"
#: ../Doc/tutorial/datastructures.rst:544
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 : ::"
#: ../Doc/tutorial/datastructures.rst:550
msgid ""
"When the keys are simple strings, it is sometimes easier to specify pairs "
"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 : ::"
#: ../Doc/tutorial/datastructures.rst:560
msgid "Looping Techniques"
msgstr "Techniques de boucles"
#: ../Doc/tutorial/datastructures.rst:562
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:"
"`items` ::"
#: ../Doc/tutorial/datastructures.rst:572
msgid ""
"When looping through a sequence, the position index and corresponding value "
"can be retrieved at the same time using the :func:`enumerate` function. ::"
msgstr ""
"Lorsque vous itérez 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`."
#: ../Doc/tutorial/datastructures.rst:582
msgid ""
"To loop over two or more sequences at the same time, the entries can be "
"paired with the :func:`zip` function. ::"
msgstr ""
"Pour faire des boucles sur deux séquences ou plus en même temps, les "
"éléments peuvent être associés par la fonction :func:`zip` ::"
#: ../Doc/tutorial/datastructures.rst:594
msgid ""
"To loop over a sequence in reverse, first specify the sequence in a forward "
"direction and then call the :func:`reversed` function. ::"
msgstr ""
"Pour faire une boucle sur une séquence inversée, commencez par créer la "
"séquence dans son ordre normal, puis appliquez la fonction :func:"
"`reversed` ::"
#: ../Doc/tutorial/datastructures.rst:606
msgid ""
"To loop over a sequence in sorted order, use the :func:`sorted` function "
"which returns a new sorted list while leaving the source unaltered. ::"
msgstr ""
"Pour faire une boucle sur une séquence triée, utilisez la fonction :func:"
"`sorted`, qui renvoie une nouvelle liste triée sans altérer la source : ::"
#: ../Doc/tutorial/datastructures.rst:618
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 changer une liste pendant son itération, "
"cependant, c'est souvent plus simple et plus sûr de créer une nouvelle liste "
"à la place. ::"
#: ../Doc/tutorial/datastructures.rst:635
msgid "More on Conditions"
msgstr "Plus d'informations sur les conditions"
#: ../Doc/tutorial/datastructures.rst:637
msgid ""
"The conditions used in ``while`` and ``if`` statements can contain any "
"operators, not just comparisons."
msgstr ""
"Les conditions utilisées dans une instruction ``while`` ou ``if`` peuvent "
"contenir n'importe quel opérateur, pas seulement des comparaisons."
#: ../Doc/tutorial/datastructures.rst:640
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 "
"whether two objects are really the same object; this only matters for "
"mutable objects like lists. All comparison operators have the same "
"priority, which is lower than that of all numerical operators."
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 "
"comparaison ont la même priorité, qui est plus faible que celle des "
"opérateurs numériques."
#: ../Doc/tutorial/datastructures.rst:646
msgid ""
"Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` "
"is less than ``b`` and moreover ``b`` equals ``c``."
msgstr ""
"Les comparaison peuvent être enchaînées. Par exemple, ``a < b == c`` teste "
"si ``a`` est inférieur ou égal à ``b`` et par ailleurs si ``b`` est égal à "
"``c``."
#: ../Doc/tutorial/datastructures.rst:649
msgid ""
"Comparisons may be combined using the Boolean operators ``and`` and ``or``, "
"and the outcome of a comparison (or of any other Boolean expression) may be "
"negated with ``not``. These have lower priorities than comparison "
"operators; between them, ``not`` has the highest priority and ``or`` the "
"lowest, so that ``A and not B or C`` is equivalent to ``(A and (not B)) or "
"C``. As always, parentheses can be used to express the desired composition."
msgstr ""
"Les comparaisons peuvent être combinées en utilisant les opérateurs booléens "
"``and`` et ``or``, le résultat d'une comparaison (ou de toute expression "
"booléenne) pouvant être inversé avec ``not``. Ces opérateurs ont une "
"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."
#: ../Doc/tutorial/datastructures.rst:656
msgid ""
"The Boolean operators ``and`` and ``or`` are so-called *short-circuit* "
"operators: their arguments are evaluated from left to right, and evaluation "
"stops as soon as the outcome is determined. For example, if ``A`` and ``C`` "
"are true but ``B`` is false, ``A and B and C`` does not evaluate the "
"expression ``C``. When used as a general value and not as a Boolean, the "
"return value of a short-circuit operator is the last evaluated argument."
msgstr ""
"Les opérateurs booléens ``and`` et ``or`` sont appelés opérateurs *en "
"circuit court* : leurs arguments sont évalués de la gauche vers la droite, "
"et l'évaluation s'arrête dès que le résultat est déterminé. Par exemple, si "
"``A`` et ``C`` sont vrais et ``B`` est faux, ``A and B and C`` n'évalue pas "
"l'expression ``C``. Lorsqu'elle est utilisée en tant que valeur et non en "
"tant que booléen, la valeur de retour d'un opérateur en circuit court est "
"celle du dernier argument évalué."
#: ../Doc/tutorial/datastructures.rst:663
msgid ""
"It is possible to assign the result of a comparison or other Boolean "
"expression to a variable. For example, ::"
msgstr ""
"Il est possible d'affecter le résultat d'une comparaison ou d'une autre "
"expression booléenne à une variable. Par exemple : ::"
#: ../Doc/tutorial/datastructures.rst:671
msgid ""
"Note that in Python, unlike C, assignment cannot occur inside expressions. C "
"programmers may grumble about this, but it avoids a common class of problems "
"encountered in C programs: typing ``=`` in an expression when ``==`` was "
"intended."
msgstr ""
"Notez qu'en Python, à la différence du C, des affectations ne peuvent pas "
"intervenir à l'intérieur d'expressions. Les programmeurs C râleront peut-"
"être après cela, mais cela évite des erreurs fréquentes que l'on rencontre "
"en C, lorsque l'expression ``=`` est placée alors qu'une expression ``==`` "
"était attendue."
#: ../Doc/tutorial/datastructures.rst:680
msgid "Comparing Sequences and Other Types"
msgstr "Comparer des séquences avec d'autres types"
#: ../Doc/tutorial/datastructures.rst:682
msgid ""
"Sequence objects may be compared to other objects with the same sequence "
"type. The comparison uses *lexicographical* ordering: first the first two "
"items are compared, and if they differ this determines the outcome of the "
"comparison; if they are equal, the next two items are compared, and so on, "
"until either sequence is exhausted. If two items to be compared are "
"themselves sequences of the same type, the lexicographical comparison is "
"carried out recursively. If all items of two sequences compare equal, the "
"sequences are considered equal. If one sequence is an initial sub-sequence "
"of the other, the shorter sequence is the smaller (lesser) one. "
"Lexicographical ordering for strings uses the Unicode code point number to "
"order individual characters. Some examples of comparisons between sequences "
"of the same type::"
msgstr ""
"Des séquences peuvent être comparées avec d'autres séquences du même type. "
"La comparaison utilise un ordre *lexicographique* : les deux premiers "
"éléments de chaque séquence sont comparés, et s'ils diffèrent cela détermine "
"le résultat de la comparaison ; s'ils sont égaux, les deux éléments suivants "
"sont comparés à leur tour, et ainsi de suite jusqu'à ce que l'une des "
"séquences soit épuisée. Si deux éléments à comparer sont eux-mêmes des "
"séquences du même type, alors la comparaison lexicographique est effectuée "
"récursivement. Si tous les éléments des deux séquences sont égaux, les deux "
"séquences sont alors considérées comme égales. Si une séquence est une sous-"
"séquence de l'autre, la séquence la plus courte est celle dont la valeur est "
"inférieure. La comparaison lexicographique des chaînes de caractères utilise "
"le code Unicode des caractères. Voici quelques exemples de comparaisons "
"entre séquences de même type : ::"
#: ../Doc/tutorial/datastructures.rst:702
msgid ""
"Note that comparing objects of different types with ``<`` or ``>`` is legal "
"provided that the objects have appropriate comparison methods. For example, "
"mixed numeric types are compared according to their numeric value, so 0 "
"equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, "
"the interpreter will raise a :exc:`TypeError` exception."
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ées via leur valeur numérique, donc 0 est égal à "
"0,0, etc. Dans les autres cas, au lieu de donner un ordre imprévisible, "
"l'interpréteur lancera une exception :exc:`TypeError`."
#: ../Doc/tutorial/datastructures.rst:710
msgid "Footnotes"
msgstr "Notes"
#: ../Doc/tutorial/datastructures.rst:711
msgid ""
"Other languages may return the mutated object, which allows method chaining, "
"such as ``d->insert(\"a\")->remove(\"b\")->sort();``."
msgstr ""
"D'autres langages pourraient renvoie l'objet modifié, qui permet de chaîner "
"les méthodes, tel que : ``d->insert(\"a\")->remove(\"b\")->sort();``."
#: ../Doc/tutorial/datastructures.rst:714
msgid ""
"Calling ``d.keys()`` will return a :dfn:`dictionary view` object. It "
"supports operations like membership test and iteration, but its contents are "
"not independent of the original dictionary -- it is only a *view*."
msgstr ""
"Appeler ``d.keys()`` renvoie un objet :dfn:`dictionary view`, qui gère les "
"opérations du type test d'appartenance (``in``) et l'itération. Mais son "
"contenu n'est pas indépendant du dictionnaire d'origine, c'est une simple "
"*vue*."