Tuples en

À propos de Tuples

Un tuple est une collection immuable d'éléments en séquence.

Comme la plupart des collections (voir les types intégrés list, dict et set), les tuples peuvent contenir n'importe quel type de données (ou plusieurs), y compris d'autres tuples. Les éléments d'un tuple peuvent être parcourus à l'aide de la construction for item in <tuple>. Si tu as besoin à la fois de l'indice et de la valeur d'un élément, tu peux utiliser for index, item in enumerate(<tuple>).

Comme pour toute séquence, on peut accéder aux éléments d'un tuple via la notation entre crochets, avec un 0-based index depuis la gauche ou un -1-based index depuis la droite. On peut copier un tuple en entier ou en partie via la notation de tranche ou avec <tuple>.copy(), et les tuples prennent en charge toutes les opérations communes aux séquences. Étant immuables, les tuples ne prennent pas en charge les opérations sur les séquences mutables.

Les tuples occupent très peu d'espace mémoire comparés aux autres types de collections et ont un temps d'accès constant (O(1)) lorsqu'on utilise un indice. Cependant, ils ne peuvent pas être redimensionnés, triés ou modifiés une fois créés, ce qui les rend moins flexibles lorsqu'on a besoin de modifier ou de mettre à jour fréquemment les données. Si des mises à jour ou des extensions fréquentes sont nécessaires, une list, un collections.deque ou un array.array pourrait être une meilleure structure de données.

Construction d'un tuple

Un tuple peut être créé de plusieurs façons : soit avec le constructeur de la classe tuple, soit avec la déclaration (<element_1>, <element_2>) (le littéral de tuple).

Utilise le constructeur tuple() vide ou avec un itérable :

>>> no_elements = tuple()
()

# The constructor *requires* an iterable, so single elements must be passed in a list or another tuple.
>>> one_element = tuple([16])
(16,)

Les strings sont itérables, donc passer une seule str comme argument au constructeur tuple() peut donner des résultats surprenants :

# String elements (characters) are iterated through and added to the tuple
>>> multiple_elements_string = tuple("Timbuktu")
('T', 'i', 'm', 'b', 'u', 'k', 't', 'u')

D'autres itérables voient aussi leurs éléments ajoutés un par un :

>>> multiple_elements_list = tuple(["Parrot", "Bird", 334782])
("Parrot", "Bird", 334782)

>>> multiple_elements_set = tuple({2, 3, 5, 7, 11})
(2,3,5,7,11)

Par défaut, l'itération d'un dict porte sur les clés. Pour inclure à la fois les clés et les valeurs dans un tuple créé à partir d'un dictionnaire, utilise <dict>.items(), qui renvoie un itérateur de tuples (key, value).

>>> source_data = {"fish": "gold", "monkey": "brown"}

>>> multiple_elements_dict_1 = tuple(source_data)
('fish', 'monkey')

>>> multiple_elements_dict_2 = tuple(source_data.items())
(('fish', 'gold'), ('monkey', 'brown'))

Déclare un tuple comme littéral :

Comme le constructeur tuple() ne prend que des itérables (ou rien) comme arguments, il est bien plus simple de créer un tuple à un seul élément avec la méthode littérale.

>>> no_elements = ()
()

>>> one_element = ("Guava",)
("Guava",)

À noter que, généralement, les parenthèses ne sont pas nécessaires pour créer un littéral de tuple, seules les virgules le sont. Cependant, utiliser (<element_1>, <element_2>) est considéré comme plus lisible dans la plupart des cas. Les parenthèses sont également nécessaires en cas d'ambiguïté, par exemple pour un tuple vide ou à un seul élément, ou lorsqu'une fonction prend un tuple en argument.

>>> elements_separated_with_commas = "Parrot", "Bird", 334782
("Parrot", "Bird", 334782)

>>> elements_with_commas_and_parentheses = ("Triangle", 60, 60, 60)
("Triangle", 60, 60, 60)

D'autres structures de données peuvent être incluses comme éléments de tuple, y compris d'autres tuples.

>>> nested_data_structures = ({"fish": "gold", "monkey": "brown", "parrot" : "grey"}, ("fish", "mammal", "bird"))
({"fish": "gold", "monkey": "brown", "parrot" : "grey"}, ("fish", "mammal", "bird"))

>>> nested_data_structures_1 = (["fish", "gold", "monkey", "brown", "parrot", "grey"], ("fish", "mammal", "bird"))
(["fish", "gold", "monkey", "brown", "parrot", "grey"], ("fish", "mammal", "bird"))

On peut concaténer des tuples à l'aide de l'opérateur plus +, qui déplie chaque tuple pour créer un nouveau tuple combiné.

>>> new_via_concatenate = ("George", 5) + ("cat", "Tabby")
("George", 5, "cat", "Tabby")

#likewise, using the multiplication operator * is the equivalent of using + n times
>>> first_group = ("cat", "dog", "elephant")

>>> multiplied_group = first_group * 3
('cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant')

Accéder aux données

Les éléments à l'intérieur d'un tuple (comme pour les autres types de séquences str et list) sont accessibles via la notation entre crochets. Les indices peuvent aller de left --> right (en commençant à zéro) ou de right --> left (en commençant à -1). On peut aussi copier un tuple en entier ou en partie via la notation de tranche ou avec <tuple>.copy().

>>> student_info = ("Alyssa", "grade 3", "female", 8)

#name is at index 0 or index -4
>>> student_name = student_info[0]
Alyssa

>>> student_name = student_info[-4]
Alyssa

#age is at index 3 or index -1
>>> student_age_1 = student_info[3]
8

>>> student_age_2 = student_info[-1]
8

Itération sur les éléments

Les éléments à l'intérieur d'un tuple peuvent être parcourus dans une boucle avec la syntaxe for item in <tuple>. Si tu as besoin à la fois des indices et des valeurs, tu peux utiliser for index, item in enumerate(<tuple>).

>>> student_info = ("Alyssa", "grade 3", "female", 8)
>>> for item in student_info:
...   print(item)
...
Alyssa
grade 3
female
8

>>> for index, item in enumerate(student_info):
...  print("Index is: " + str(index) + ", value is: " + str(item) + ".")
...
Index is: 0, value is: Alyssa.
Index is: 1, value is: grade 3.
Index is: 2, value is: female.
Index is: 3, value is: 8.

Les tuples comme information homogène

Les tuples sont souvent utilisés comme des enregistrements contenant des données organisationnellement ou conceptuellement homogènes, traitées comme une seule unité d'information, même si les éléments individuels sont de types de données hétérogènes.

>>> student_info = ("Alyssa", "grade 3", "female", 8)

Les tuples sont aussi utilisés lorsqu'on a besoin de séquences de données homogènes et immuables pour la hashability, le stockage dans un set ou la création de clés dans un dictionnaire.

À noter que, bien que les tuples soient dans la plupart des cas immuables, comme ils peuvent contenir n'importe quelle structure de données ou objet, ils peuvent devenir mutables si l'un de leurs éléments est d'un type mutable. Utiliser un type de données mutable dans un tuple rend le tuple englobant non hachable.

>>> cmyk_color_map = {
        (.69, .3, .48, .1) : ("Teal 700", (59, 178, 146), 0x3BB292),
        (0, .5, 1, 0) : ("Pantone 151", (247, 127, 1), 0xF77F01),
        (.37, .89, 0, .44) : ("Pantone 267", (89, 16, 142), 0x59108E),
        (0, 1, .46, .45) : ("Pantone 228", (140, 0, 76), 0x8C004C)
    }

>>> unique_rgb_colors = {
        (59, 178, 146),
        (247, 127, 1),
        (89, 16, 142),
        (140, 0, 76),
        (76, 0, 140)
     }

>>> teal_700 = hash((59, 178, 146))

>>> teal_700 = hash(("Pantone 228", [(140, 0, 76), 0x8C004C]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Tuples étendus et types de données associés

Les tuples sont souvent utilisés comme des enregistrements, mais on ne peut accéder aux données qu'ils contiennent que par position ou par indice. La classe namedtuple() du module collections étend les fonctionnalités de base des tuples pour permettre d'accéder aux éléments par nom. De plus, on peut adapter une dataclass pour obtenir une fonctionnalité similaire d'attributs nommés, avec quelques avantages et inconvénients.