"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, ``()``."

"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."

"Les tuples implémentent toutes les opérations :ref:`communes <typesseq-"

"common>` des séquences."

"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."

msgstr "*Ranges*"

"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`."

"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."

"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``."

"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``."

"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."

"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`."

msgstr "Exemples avec *range* ::"

"*range* implémente toutes les opérations :ref:`communes <typesseq-common>` "

"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)."

"La valeur du paramètre *start* (ou ``0`` si le paramètre n'a pas été fourni)"

msgstr "La valeur du paramètre *stop*"

"La valeur du paramètre *step* (ou ``1`` si le paramètre n'a pas été fourni)"

"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)."

"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`):"

"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)``.)"

"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."

"Les attributs :attr:`~range.start`, :attr:`~range.stop` et :attr:`~range."

"step`."

msgstr "Type Séquence de Texte --- :class:`str`"

"Les données textuelles en Python est manipulé avec des objets :class:`str` "

"ou :dfn:`strings`. Les chaînes sont des :ref:`séquences <typesseq>` "

"immuables depoints de code Unicode. Les chaînes littérales peuvent être "

"écrites de différentes manières :"

msgstr "Les guillemets simples : ``'autorisent les \"guillemets\"'``"

msgstr "Les guillemets : ``\"autorisent les guillemets 'simples'\"``."

"Guillemets triples : ``'''Trois guillemets simples'''``, ``\"\"\"Trois "

"guillemets\"\"\"``"

"Les chaînes entre triple guillemets peuvent couvrir plusieurs lignes - tous "

"les espaces associés seront inclus dans la chaîne littérale."

"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\"``."

"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."

"Les chaînes peuvent également être créés à partir d'autres objets à l'aide "

"du constructeur :class:`str`."

"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]``."