From a726fe75bc5826efea2b061a34f85283113f7008 Mon Sep 17 00:00:00 2001 From: Julien Palard Date: Mon, 21 Mar 2016 22:24:03 +0100 Subject: [PATCH] Working on library.po/stdtypes.rst --- library.po | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 91 insertions(+), 6 deletions(-) diff --git a/library.po b/library.po index e52ced77..a4f5a7c9 100644 --- a/library.po +++ b/library.po @@ -106608,6 +106608,13 @@ msgid "" "3)``. If no argument is given, the constructor creates a new empty tuple, " "``()``." msgstr "" +"Le constructeur construit un tuple dont les éléments sont les mêmes et dans " +"le même ordre que les éléments de *iterable*. *iterable* peut être soit une " +"séquence, un conteneur qui supporte l'itération, soit un itérateur. Si " +"*iterable* est déjà un tuple, il est retourné inchangé. Par exemple, " +"``tuple('abc')`` retourne ``('a', 'b', 'c')`` et ``tuple( [1, 2, 3] )`` " +"retourne ``(1, 2, 3)``. Si aucun argument est donné, le constructeur crée un " +"nouveau tuple vide, ``()``." #: ../Doc/library/stdtypes.rst:1228 msgid "" @@ -106617,12 +106624,20 @@ msgid "" "function call with three arguments, while ``f((a, b, c))`` is a function " "call with a 3-tuple as the sole argument." msgstr "" +"Notez que c'est en fait la virgule qui fait un tuple, pas les parenthèses. " +"Les parenthèses sont facultatives, sauf dans le cas du tuple vide, ou quand " +"ils sont nécessaires pour éviter l'ambiguïté syntaxique. Par exemple, ``f(a, " +"b, c)`` est un appel de fonction avec trois arguments, alors que ``f((a, b, " +"c))`` est un appel de fonction avec un tuple de trois éléments comme unique " +"argument." #: ../Doc/library/stdtypes.rst:1234 msgid "" "Tuples implement all of the :ref:`common ` sequence " "operations." msgstr "" +"Les tuples implémentent toutes les opérations :ref:`communes ` des séquences." #: ../Doc/library/stdtypes.rst:1237 msgid "" @@ -106630,16 +106645,22 @@ msgid "" "access by index, :func:`collections.namedtuple` may be a more appropriate " "choice than a simple tuple object." msgstr "" +"Pour les collections hétérogènes de données où l'accès par nom est plus " +"clair que l'accès par index, :func:`collections.namedtuple` peut être un " +"choix plus approprié qu'un simple tuple." #: ../Doc/library/stdtypes.rst:1245 msgid "Ranges" -msgstr "" +msgstr "*Ranges*" #: ../Doc/library/stdtypes.rst:1249 msgid "" "The :class:`range` type represents an immutable sequence of numbers and is " "commonly used for looping a specific number of times in :keyword:`for` loops." msgstr "" +"Le type :class:`range` représente une séquence immuable de nombres et est " +"couramment utilisé pour itérer un certain nombre de fois dans les boucles :" +"keyword:`for`." #: ../Doc/library/stdtypes.rst:1256 msgid "" @@ -106649,12 +106670,19 @@ msgid "" "*start* argument is omitted, it defaults to ``0``. If *step* is zero, :exc:" "`ValueError` is raised." msgstr "" +"Les arguments du constructeur de *range* doivent être des entiers (des :" +"class:`int` ou tout autre objet qui implémente la méthode spéciale " +"``__index__``). La valeur par défaut de l'argument *step* est ``1``. La " +"valeur par défaut de l'argument *start* est ``0``. Si *step* est égal à " +"zéro, une exception :exc:`ValueError` est levée." #: ../Doc/library/stdtypes.rst:1262 msgid "" "For a positive *step*, the contents of a range ``r`` are determined by the " "formula ``r[i] = start + step*i`` where ``i >= 0`` and ``r[i] < stop``." msgstr "" +"Pour un *step* positif, le contenu d'un *range* ``r`` est déterminé par la " +"formule ``r[i] = start + step*i`` où ``i >= 0`` et ``r[i] < stop``." #: ../Doc/library/stdtypes.rst:1266 msgid "" @@ -106662,6 +106690,9 @@ msgid "" "formula ``r[i] = start + step*i``, but the constraints are ``i >= 0`` and " "``r[i] > stop``." msgstr "" +"Pour un *step* négatif, le contenu du *range* est toujours déterminé par la " +"formule ``r[i] = start + step*i``, mais les contraintes sont ``i >= 0`` et " +"``r[i] > stop``." #: ../Doc/library/stdtypes.rst:1270 msgid "" @@ -106669,6 +106700,10 @@ msgid "" "Ranges do support negative indices, but these are interpreted as indexing " "from the end of the sequence determined by the positive indices." msgstr "" +"Un objet *range* sera vide si ``r[0]`` ne répond pas à la contrainte de " +"valeur. Les *range* prennent en charge les indices négatifs, mais ceux-ci " +"sont interprétées comme une indexation de la fin de la séquence déterminée " +"par les indices positifs." #: ../Doc/library/stdtypes.rst:1275 msgid "" @@ -106676,10 +106711,13 @@ msgid "" "permitted but some features (such as :func:`len`) may raise :exc:" "`OverflowError`." msgstr "" +"Les *range* contenant des valeurs absolues plus grandes que :data:`sys." +"maxsize`sont permises, mais certaines fonctionnalités (comme :func:`len`) " +"peuvent lever :exc:`OverflowError`." #: ../Doc/library/stdtypes.rst:1279 msgid "Range examples::" -msgstr "" +msgstr "Exemples avec *range* ::" #: ../Doc/library/stdtypes.rst:1296 msgid "" @@ -106688,22 +106726,29 @@ msgid "" "objects can only represent sequences that follow a strict pattern and " "repetition and concatenation will usually violate that pattern)." msgstr "" +"*range* implémente toutes les opérations :ref:`communes ` " +"des séquences sauf la concaténation et la répétition (en raison du fait que " +"les *range* ne peuvent représenter que des séquences qui respectent un motif " +"strict et que la répétition et la concaténation les feraient dévier de ce " +"motif)." #: ../Doc/library/stdtypes.rst:1303 msgid "" "The value of the *start* parameter (or ``0`` if the parameter was not " "supplied)" msgstr "" +"La valeur du paramètre *start* (ou ``0`` si le paramètre n'a pas été fourni)" #: ../Doc/library/stdtypes.rst:1308 msgid "The value of the *stop* parameter" -msgstr "" +msgstr "La valeur du paramètre *stop*" #: ../Doc/library/stdtypes.rst:1312 msgid "" "The value of the *step* parameter (or ``1`` if the parameter was not " "supplied)" msgstr "" +"La valeur du paramètre *step* (ou ``1`` si le paramètre n'a pas été fourni)" #: ../Doc/library/stdtypes.rst:1315 msgid "" @@ -106713,6 +106758,11 @@ msgid "" "it only stores the ``start``, ``stop`` and ``step`` values, calculating " "individual items and subranges as needed)." msgstr "" +"L'avantage du type :class:`range` sur une :class:`list` classique ou :class:" +"`tuple` est qu'un objet :class:`range` prendra toujours la même (petite) " +"quantité de mémoire, peu importe la taille de la gamme qu'elle représente " +"(car elle ne stocke que les valeurs ``start``, ``stop`` et ``step`` , le " +"calcul des éléments individuels et les sous-*range* au besoin)." #: ../Doc/library/stdtypes.rst:1321 msgid "" @@ -106720,6 +106770,10 @@ msgid "" "provide features such as containment tests, element index lookup, slicing " "and support for negative indices (see :ref:`typesseq`):" msgstr "" +"Les *range* implémentent la classe de base abstraite :class:`collections.abc." +"Sequence`, et offrent des fonctionnalités telles que les tests " +"d'appartenance (avec *in*) , de recherche par index, le tranchage et ils " +"gerent les indices négatifs (voir :ref:`typesseq`):" #: ../Doc/library/stdtypes.rst:1341 msgid "" @@ -106730,6 +106784,12 @@ msgid "" "and :attr:`~range.step` attributes, for example ``range(0) == range(2, 1, " "3)`` or ``range(0, 3, 2) == range(0, 4, 2)``.)" msgstr "" +"Comparer des *range* avec ``==`` et ``!=`` les compare comme des séquences. " +"Soit deux objets *range* sont considérées comme égaux si ils représentent la " +"même séquence de valeurs. (Notez que deux objets *range* dits égaux " +"pourraient avoir leurs attributs :attr:`~range.start`, :attr:`~range.stop` " +"et :attr:`~range.step` différents, par exemple ``range(0) == range(2, 1, " +"3)`` ou ``range(0, 3, 2) == range(0, 4, 2)``.)" #: ../Doc/library/stdtypes.rst:1348 msgid "" @@ -106737,6 +106797,9 @@ msgid "" "class:`int` objects for membership in constant time instead of iterating " "through all items." msgstr "" +"Implémente la classe de base abstraite *Sequence*. Supporte le *slicing* et " +"les indices négatifs. Tester l'appartenance d'un :class:`int` en temps " +"constant au lieu d'itérer tous les éléments." #: ../Doc/library/stdtypes.rst:1354 msgid "" @@ -106749,10 +106812,12 @@ msgid "" "The :attr:`~range.start`, :attr:`~range.stop` and :attr:`~range.step` " "attributes." msgstr "" +"Les attributs :attr:`~range.start`, :attr:`~range.stop` et :attr:`~range." +"step`." #: ../Doc/library/stdtypes.rst:1372 msgid "Text Sequence Type --- :class:`str`" -msgstr "" +msgstr "Type Séquence de Texte --- :class:`str`" #: ../Doc/library/stdtypes.rst:1374 msgid "" @@ -106760,26 +106825,34 @@ msgid "" "`strings`. Strings are immutable :ref:`sequences ` of Unicode code " "points. String literals are written in a variety of ways:" msgstr "" +"Les données textuelles en Python est manipulé avec des objets :class:`str` " +"ou :dfn:`strings`. Les chaînes sont des :ref:`séquences ` " +"immuables depoints de code Unicode. Les chaînes littérales peuvent être " +"écrites de différentes manières :" #: ../Doc/library/stdtypes.rst:1379 msgid "Single quotes: ``'allows embedded \"double\" quotes'``" -msgstr "" +msgstr "Les guillemets simples : ``'autorisent les \"guillemets\"'``" #: ../Doc/library/stdtypes.rst:1380 msgid "Double quotes: ``\"allows embedded 'single' quotes\"``." -msgstr "" +msgstr "Les guillemets : ``\"autorisent les guillemets 'simples'\"``." #: ../Doc/library/stdtypes.rst:1381 msgid "" "Triple quoted: ``'''Three single quotes'''``, ``\"\"\"Three double quotes" "\"\"\"``" msgstr "" +"Guillemets triples : ``'''Trois guillemets simples'''``, ``\"\"\"Trois " +"guillemets\"\"\"``" #: ../Doc/library/stdtypes.rst:1383 msgid "" "Triple quoted strings may span multiple lines - all associated whitespace " "will be included in the string literal." msgstr "" +"Les chaînes entre triple guillemets peuvent couvrir plusieurs lignes - tous " +"les espaces associés seront inclus dans la chaîne littérale." #: ../Doc/library/stdtypes.rst:1386 msgid "" @@ -106787,6 +106860,9 @@ msgid "" "whitespace between them will be implicitly converted to a single string " "literal. That is, ``(\"spam \" \"eggs\") == \"spam eggs\"``." msgstr "" +"Les chaînes littérales qui font partie d'une seule expression et ont " +"seulement des espaces entre elles sont implicitement converties en une seule " +"chaîne littérale. Autrement dit, ``(\"spam \" \"eggs\") == \"spam eggs\"``." #: ../Doc/library/stdtypes.rst:1390 msgid "" @@ -106794,18 +106870,27 @@ msgid "" "including supported escape sequences, and the ``r`` (\"raw\") prefix that " "disables most escape sequence processing." msgstr "" +"Voir :ref:`strings` pour plus d'informations sur les différentes formes de " +"chaînes littérales, y compris des séquences d'échappement prises en charge, " +"et le préfixe``r`` (*raw* (brut)) préfixe qui désactive la plupart des " +"traitements de séquence d'échappement." #: ../Doc/library/stdtypes.rst:1394 msgid "" "Strings may also be created from other objects using the :class:`str` " "constructor." msgstr "" +"Les chaînes peuvent également être créés à partir d'autres objets à l'aide " +"du constructeur :class:`str`." #: ../Doc/library/stdtypes.rst:1397 msgid "" "Since there is no separate \"character\" type, indexing a string produces " "strings of length 1. That is, for a non-empty string *s*, ``s[0] == s[0:1]``." msgstr "" +"Comme il n'y a pas de type \"caractère\" distinct, l'indexation d'une chaîne " +"produit des chaînes de longueur 1. Autrement dit, pour une chaîne non vide " +"*s*, ``s[0] == s[0:1]``." #: ../Doc/library/stdtypes.rst:1403 msgid ""