python-docs-fr/tutorial/datastructures.po

891 lines
42 KiB
Plaintext
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\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 points déjà décrits précédemment "
"et introduit également de nouvelles notions."
#: ../Doc/tutorial/datastructures.rst:14
msgid "More on Lists"
msgstr "Compléments sur les listes"
#: ../Doc/tutorial/datastructures.rst:16
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 toutes les méthodes "
"des objets de type liste :"
#: ../Doc/tutorial/datastructures.rst:23
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 ; équivalent à ``a[len(a):] = [x]``."
#: ../Doc/tutorial/datastructures.rst:29
msgid ""
"Extend the list by appending all the items in the given list; equivalent to "
"``a[len(a):] = L``."
msgstr ""
"Étend la liste en y ajoutant tous les éléments de la liste fournie ; "
"équivalent à ``a[len(a):] = L``."
#: ../Doc/tutorial/datastructures.rst:36
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:44
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:51
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 spécifiée, ``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 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:61
msgid ""
"Return the index in the list of the first item whose value is *x*. It is an "
"error if there is no such item."
msgstr ""
"Retourne la position du premier élément de la liste ayant la valeur *x*. Une "
"exception est levée s'il n'existe aucun élément avec cette valeur."
#: ../Doc/tutorial/datastructures.rst:68
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:74
msgid ""
"Sort the items of the list in place (the arguments can be used for sort "
"customization, see :func:`sorted` for their explanation)."
msgstr ""
"Classe les éléments sur place (les arguments peuvent personnaliser le "
"classement, voir :func:`sorted` pour leur explication)."
#: ../Doc/tutorial/datastructures.rst:81
msgid "Reverse the elements of the list, in place."
msgstr "Inverse l'ordre des éléments de la liste, en place."
#: ../Doc/tutorial/datastructures.rst:83
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:108
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 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."
#: ../Doc/tutorial/datastructures.rst:117
msgid "Using Lists as Stacks"
msgstr "Utilisation des listes comme des piles"
#: ../Doc/tutorial/datastructures.rst:122
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* en anglais). 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:147
msgid "Using Lists as Queues"
msgstr "Utilisation des listes comme des files"
#: ../Doc/tutorial/datastructures.rst:151
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*) ; 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)."
#: ../Doc/tutorial/datastructures.rst:157
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 : ::"
#: ../Doc/tutorial/datastructures.rst:175
msgid "Functional Programming Tools"
msgstr "Outils de programmation fonctionnelle"
#: ../Doc/tutorial/datastructures.rst:177
msgid ""
"There are three built-in functions that are very useful when used with "
"lists: :func:`filter`, :func:`map`, and :func:`reduce`."
msgstr ""
"Il existe trois fonctions primitives qui sont très utiles lorsqu'elles sont "
"utilisées avec des listes : :func:`filter`, :func:`map` et :func:`reduce`."
#: ../Doc/tutorial/datastructures.rst:180
msgid ""
"``filter(function, sequence)`` returns a sequence consisting of those items "
"from the sequence for which ``function(item)`` is true. If *sequence* is a :"
"class:`str`, :class:`unicode` or :class:`tuple`, the result will be of the "
"same type; otherwise, it is always a :class:`list`. For example, to compute "
"a sequence of numbers divisible by 3 or 5::"
msgstr ""
"``filter(function, sequence)`` retourne une séquence composée des éléments "
"de la séquence initiale pour lesquels la fonction ``function(item)`` est "
"vraie. Si *sequence* est de type :class:`str`, :class:`unicode`, ou :class:"
"`tuple`, le résultat sera du même type ; sinon, il sera toujours de type :"
"class:`list`. Par exemple, pour construire une séquence de nombres "
"divisibles par 2 ou 5 ::"
#: ../Doc/tutorial/datastructures.rst:191
msgid ""
"``map(function, sequence)`` calls ``function(item)`` for each of the "
"sequence's items and returns a list of the return values. For example, to "
"compute some cubes::"
msgstr ""
"``map(function, sequence)`` appelle ``function(item)`` pour chaque élément "
"de la séquence et retourne une liste contenant l'ensemble des résultats. Par "
"exemple, pour calculer des cubes ::"
#: ../Doc/tutorial/datastructures.rst:200
msgid ""
"More than one sequence may be passed; the function must then have as many "
"arguments as there are sequences and is called with the corresponding item "
"from each sequence (or ``None`` if some sequence is shorter than another). "
"For example::"
msgstr ""
"Plus d'une séquence peut être passée en paramètre ; dans ce cas, la fonction "
"doit avoir autant d'arguments qu'il y a de séquences, et elle sera appelée "
"avec l'élément correspondant de chaque séquence (ou ``None`` si certaines "
"séquences sont plus courtes que d'autres)."
#: ../Doc/tutorial/datastructures.rst:211
msgid ""
"``reduce(function, sequence)`` returns a single value constructed by calling "
"the binary function *function* on the first two items of the sequence, then "
"on the result and the next item, and so on. For example, to compute the sum "
"of the numbers 1 through 10::"
msgstr ""
"``reduce(function, sequence)`` retourne une seule valeur construire en "
"appelant la fonction *function* avec comme paramètres les deux premiers "
"éléments de la séquence, puis le premier résultat et l'élément suivant, et "
"ainsi de suite. Par exemple, pour calculer la somme des nombres de 1 à 10 ::"
#: ../Doc/tutorial/datastructures.rst:221
msgid ""
"If there's only one item in the sequence, its value is returned; if the "
"sequence is empty, an exception is raised."
msgstr ""
"S'il n'y a qu'un seul élément dans la séquence, sa valeur est retournée ; si "
"la séquence est vide, une exception est levée."
#: ../Doc/tutorial/datastructures.rst:224
msgid ""
"A third argument can be passed to indicate the starting value. In this case "
"the starting value is returned for an empty sequence, and the function is "
"first applied to the starting value and the first sequence item, then to the "
"result and the next item, and so on. For example, ::"
msgstr ""
"Un troisième paramètre peut être ajouté pour indiquer la valeur de départ. "
"Dans ce cas, cette valeur est retournée dans le cas d'une séquence vide ; "
"sinon, la fonction est d'abord appelée avec comme paramètres cette valeur de "
"départ et le premier élément de la séquence, puis ce premier résultat et "
"l'élément suivant, et ainsi de suite. Par exemple ::"
#: ../Doc/tutorial/datastructures.rst:238
msgid ""
"Don't use this example's definition of :func:`sum`: since summing numbers is "
"such a common need, a built-in function ``sum(sequence)`` is already "
"provided, and works exactly like this."
msgstr ""
"N'utilisez pas la fonction :func:`sum` fournie dans cet exemple. Effectuer "
"des sommes de nombres est un besoin tellement courant qu'il existe une "
"fonction native ``sum(sequence)`` qui fait exactement la même chose."
#: ../Doc/tutorial/datastructures.rst:245
msgid "List Comprehensions"
msgstr "Compréhensions de listes"
#: ../Doc/tutorial/datastructures.rst:247
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 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."
#: ../Doc/tutorial/datastructures.rst:252
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:261
msgid "We can obtain the same result with::"
msgstr "On peut obtenir le même résultat avec ::"
#: ../Doc/tutorial/datastructures.rst:265
msgid ""
"This is also equivalent to ``squares = map(lambda x: x**2, range(10))``, but "
"it's more concise and readable."
msgstr ""
"C'est également l'équivalent de ``squares = map(lambda x: x**2, "
"range(10))``, mais en plus concis et plus lisible."
#: ../Doc/tutorial/datastructures.rst:268
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 à 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` 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:278
msgid "and it's equivalent to:"
msgstr "et c'est équivaent à : ::"
#: ../Doc/tutorial/datastructures.rst:289
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:292
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:323
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:331
msgid "Nested List Comprehensions"
msgstr "Compréhensions de listes imbriquées"
#: ../Doc/tutorial/datastructures.rst:333
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:336
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 3 par 4, implémentée sous la forme "
"de 3 listes de 4 éléments : ::"
#: ../Doc/tutorial/datastructures.rst:345
msgid "The following list comprehension will transpose rows and columns::"
msgstr "Cette compréhension de liste transpose les lignes et les colonnes : ::"
#: ../Doc/tutorial/datastructures.rst:350
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 nous l'avons 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:361
msgid "which, in turn, is the same as::"
msgstr "lequel à son tour est équivalent à : ::"
#: ../Doc/tutorial/datastructures.rst:375
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:381
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."
#: ../Doc/tutorial/datastructures.rst:386
msgid "The :keyword:`del` statement"
msgstr "L'instruction :keyword:`del`"
#: ../Doc/tutorial/datastructures.rst:388
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 auparavant en affectant "
"une liste vide à la tranche). Par exemple : ::"
#: ../Doc/tutorial/datastructures.rst:405
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:409
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:416
msgid "Tuples and Sequences"
msgstr "Tuples et séquences"
#: ../Doc/tutorial/datastructures.rst:418
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:424
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:446
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, les tuples sont toujours affichés entre "
"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:453
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:461
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 "
"accommoder. 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:476
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:482
msgid ""
"This is called, appropriately enough, *sequence unpacking* and works for any "
"sequence on the right-hand side. Sequence unpacking requires the list of "
"variables on the left to have the same number of elements as the length of "
"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:492
msgid "Sets"
msgstr "Ensembles"
#: ../Doc/tutorial/datastructures.rst:494
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 suppressions "
"de doublons. Les ensembles savent également effectuer les opérations "
"mathématiques telles que les unions, intersections, différences et "
"différences symétriques."
#: ../Doc/tutorial/datastructures.rst:499
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ée un dictionnaire vide. Utilisez plutôt ``set()``."
#: ../Doc/tutorial/datastructures.rst:503
msgid "Here is a brief demonstration::"
msgstr "Voici une brève démonstration : ::"
#: ../Doc/tutorial/datastructures.rst:529
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 : ::"
#: ../Doc/tutorial/datastructures.rst:540
msgid "Dictionaries"
msgstr "Dictionnaires"
#: ../Doc/tutorial/datastructures.rst:542
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:553
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."
#: ../Doc/tutorial/datastructures.rst:559
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 opérations classiques 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:565
msgid ""
"The :meth:`keys` method of a dictionary object returns a list of all the "
"keys used in the dictionary, in arbitrary order (if you want it sorted, just "
"apply the :func:`sorted` function to it). To check whether a single key is "
"in the dictionary, use the :keyword:`in` keyword."
msgstr ""
"La méthode :meth:`keys` d'un dictionnaire retourne une liste de toutes les "
"clés utilisées dans le dictionnaire, dans un ordre arbitraire (si vous "
"voulez qu'elle soit triée, appliquez-lui la fonction :func:`sorted`). Pour "
"tester si une clé est dans le dictionnaire, utilisez le mot-clé :keyword:"
"`in`."
#: ../Doc/tutorial/datastructures.rst:570
msgid "Here is a small example using a dictionary::"
msgstr "Voici un petit exemple utilisant un dictionnaire : ::"
#: ../Doc/tutorial/datastructures.rst:587
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:593
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:599
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:609
msgid "Looping Techniques"
msgstr "Techniques de boucles"
#: ../Doc/tutorial/datastructures.rst:611
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:621
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:633
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 en sens inverse sur une séquence, commencez par "
"spécifier la séquence dans son ordre normal, puis appliquez la fonction :"
"func:`reversed` ::"
#: ../Doc/tutorial/datastructures.rst:645
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 selon un certain classement sur une séquence, utilisez "
"la fonction :func:`sorted`, elle renvoie une nouvelle liste classée sans "
"altérer la source : ::"
#: ../Doc/tutorial/datastructures.rst:657
msgid ""
"When looping through dictionaries, the key and corresponding value can be "
"retrieved at the same time using the :meth:`iteritems` 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:"
"`iteritems` ::"
#: ../Doc/tutorial/datastructures.rst:667
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. ::"
#: ../Doc/tutorial/datastructures.rst:684
msgid "More on Conditions"
msgstr "Plus d'informations sur les conditions"
#: ../Doc/tutorial/datastructures.rst:686
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:689
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:695
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 ou égal à ``b`` et si, de plus, ``b`` égale ``c``."
#: ../Doc/tutorial/datastructures.rst:698
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:705
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:712
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:720
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'on tape ``=`` alors que l'on voulait faire un test avec "
"``==``."
#: ../Doc/tutorial/datastructures.rst:729
msgid "Comparing Sequences and Other Types"
msgstr "Comparer des séquences avec d'autres types"
#: ../Doc/tutorial/datastructures.rst:731
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 ASCII ordering for 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 "
"l'ordre ASCII des caractères. Voici quelques exemples de comparaisons entre "
"séquences de même type : ::"
#: ../Doc/tutorial/datastructures.rst:751
msgid ""
"Note that comparing objects of different types is legal. The outcome is "
"deterministic but arbitrary: the types are ordered by their name. Thus, a "
"list is always smaller than a string, a string is always smaller than a "
"tuple, etc. [#]_ Mixed numeric types are compared according to their numeric "
"value, so 0 equals 0.0, etc."
msgstr ""
"La comparaison d'objets de types différents est autorisée. Le résultat est "
"déterminé mais arbitraire : les types sont ordonnés par leur nom. Ainsi, une "
"liste (type ``list``) est toujours inférieure à une chaîne de caractères "
"(type ``str``), une chaîne de caractères toujours inférieure à un tuple... "
"[#]_ Des types numériques mélangés sont comparés en fonction de leur valeur "
"numérique, donc 0 est égal à 0.0, etc."
#: ../Doc/tutorial/datastructures.rst:759
msgid "Footnotes"
msgstr "Notes"
#: ../Doc/tutorial/datastructures.rst:760
msgid ""
"The rules for comparing objects of different types should not be relied "
"upon; they may change in a future version of the language."
msgstr ""
"Les règles de comparaison d'objets de types différents ne doivent pas être "
"considérées comme fiables ; elles peuvent être amenées à changer dans une "
"future version du langage."