Tutoriel sur les tuples Python

Tuples versus listes

Comme vous l'aurez remarqué, les tuples ressemblent beaucoup aux listes. En réalité, on peut les considérer comme des listes immuables : une fois un tuple créé, vous ne pouvez ni supprimer ni modifier les valeurs des éléments qu'il contient. Vous ne pouvez pas non plus y ajouter de nouvelles valeurs. Voyez plutôt :

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]

# Ajouter un nombre au tuple
numbers_tuple.append(6)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-26-e47776d745ce> in <module>()
      3 
      4 # Append a number to the tuple
----> 5 numbers_tuple.append(6)


AttributeError: 'tuple' object has no attribute 'append'

Cela lève une erreur car on ne peut ni supprimer des éléments d'un tuple ni y ajouter de nouvelles valeurs, contrairement à une liste.

# Ajouter des nombres à la liste
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)

# Supprimer un nombre de la liste
numbers_list.remove(7)
print(numbers_list)

[1, 2, 3, 4, 5, 6, 8]

Mais pourquoi utiliser des tuples s'ils sont immuables ?

Non seulement ils offrent un accès en "lecture seule" aux données, mais ils sont aussi plus rapides que les listes. Considérez le code suivant :

import timeit
timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)

0.0018976779974764213

timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)

0.019868606992531568

Que signifie vraiment « immuable » pour les tuples ?

Selon la documentation officielle de Python, un objet immuable est « un objet à valeur fixe ». Mais « valeur » est un terme assez vague ; le terme plus juste pour les tuples serait « id ». L'« id » est l'identité de l'emplacement d'un objet en mémoire.

Regardons cela d'un peu plus près :

# Tuple 'n_tuple' avec une liste comme l'un de ses éléments.
n_tuple = (1, 1, [3,4])

# Les éléments ayant la même valeur ont le même id.
id(n_tuple[0]) == id(n_tuple[1])

True

# Les éléments de valeurs différentes ont des id différents.
id(n_tuple[0]) == id(n_tuple[2])

False

id(n_tuple[0])

4297148528

id(n_tuple[2])

4359711048

n_tuple.append(5)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-40-3cd258e024ff> in <module>()
----> 1 n_tuple.append(5)


AttributeError: 'tuple' object has no attribute 'append'

On ne peut pas ajouter d'élément à un tuple, d'où l'erreur ci-dessus. C'est pourquoi le tuple est dit immuable. En revanche, vous pouvez faire ceci :

n_tuple[2].append(5)
n_tuple

(1, 1, [3, 4, 5])

Vous pouvez donc modifier la structure contenue dans le tuple. Comment le tuple peut-il encore être qualifié d'immuable ?

Parce que l'id de la liste à l'intérieur du tuple reste le même, même après y avoir ajouté 5.

id(n_tuple[2])

4359711048

En résumé :

Certains tuples (qui ne contiennent que des objets immuables : chaînes de caractères, etc.) sont effectivement immuables, tandis que d'autres (qui contiennent un ou plusieurs objets muables : listes, etc.) peuvent changer. Le sujet fait souvent débat chez les Pythonistas et nécessite des bases plus solides pour être totalement compris. Cet article explore le sujet plus en profondeur. Pour l'heure, disons simplement que les tuples sont généralement considérés comme immuables.

• Vous ne pouvez pas ajouter d'éléments à un tuple en raison de son immutabilité. Il n'existe pas de méthode append() ou extend() pour les tuples,
• Vous ne pouvez pas non plus supprimer d'éléments d'un tuple. Il n'existe pas de méthode remove() ou pop(),
• Vous pouvez rechercher des éléments dans un tuple puisque cela ne le modifie pas.
• Vous pouvez aussi utiliser l'opérateur in pour vérifier la présence d'un élément dans un tuple.

Ainsi, si vous définissez un ensemble constant de valeurs et que vous ne faites que l'itérer, préférez un tuple à une liste. Ce sera plus rapide et plus sûr, car les tuples agissent comme des données "protégées en écriture".

Pour en savoir plus sur les listes Python, consultez ce tutoriel !

Opérations courantes sur les tuples

Python propose plusieurs façons de manipuler les tuples. Voyons les plus importantes avec des exemples.

Slicing de tuple

Le premier élément d'un tuple est indexé à 0. Comme pour les listes Python, vous pouvez utiliser les index avec des crochets [] pour accéder aux éléments d'un tuple :

numbers = (0,1,2,3,4,5)
numbers[0]

0

Vous pouvez également utiliser des indices négatifs avec les tuples :

numbers[-1]

5

L'indexation sert à obtenir un élément individuel, tandis que le slicing permet d'obtenir un sous-ensemble d'éléments. Lorsque vous indiquez une plage à extraire, on parle de slicing par plage. Le format général est :

[Index de début (inclus) : index de fin (exclu) : pas]

Ici, pas est un paramètre optionnel, par défaut à 1.

# L'élément à l'index 4 est exclu
numbers[1:4]

(1, 2, 3)

# Renvoie tous les éléments du tuple
numbers[:]

(0, 1, 2, 3, 4, 5)

# Pas = 2
numbers[::2]

(0, 2, 4)

Astuce : vous pouvez aussi utiliser un pas négatif pour inverser le tuple.

numbers[::-1]

(5, 4, 3, 2, 1, 0)

Addition de tuples

Vous pouvez combiner des tuples pour former un nouveau tuple. L'opération d'addition effectue simplement une concaténation.

x = (1,2,3,4)
y = (5,6,7,8)

# Combiner deux tuples pour former un nouveau tuple
z = x + y 

print(z)

(1, 2, 3, 4, 5, 6, 7, 8)

y = [5,6,7,8]
z = x + y
print(z)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-55-d352c6414a4c> in <module>()
      1 y = [5,6,7,8]
----> 2 z = x + y
      3 print(z)


TypeError: can only concatenate tuple (not "list") to tuple

Vous ne pouvez additionner ou combiner que des types identiques. Tenter de concaténer un tuple et une liste provoque donc une erreur.

Multiplication de tuples

La multiplication entraîne simplement la répétition du tuple.

x = (1,2,3,4)
z = x*2
print(z)

(1, 2, 3, 4, 1, 2, 3, 4)

Fonctions utiles avec les tuples

À la différence des listes Python, les tuples n'ont pas de méthodes telles que append(), remove(), extend(), insert() ou pop() en raison de leur nature immuable. En revanche, de nombreuses autres fonctions intégrées permettent de travailler avec les tuples :

count() et len()

count() renvoie le nombre d'occurrences d'un élément dans un tuple.

a = [1,2,3,4,5,5]
a.count(5)

2

Avec la fonction len(), vous obtenez la longueur du tuple :

a = (1,2,3,4,5)
print(len(a))

5

any()

Vous pouvez utiliser any() pour savoir si un tuple est considéré comme vrai en contexte booléen. La fonction renvoie True s'il contient au moins un élément, sinon False.

a = (1,)
print(any(a))

True

Notez la virgule , dans la déclaration du tuple a ci-dessus. Si vous n'ajoutez pas de virgule lors de l'initialisation d'un seul élément, Python considère qu'il s'agit simplement d'une expression entre parenthèses (sans créer de tuple). Pensez donc à ajouter une virgule pour un tuple à un seul élément.

Pour revenir à any() : en contexte booléen, la valeur précise importe peu. Un tuple vide est faux, tout tuple avec au moins un élément est vrai.

b = ()
print(any(b))

False

Cette fonction est utile si vous utilisez un tuple dans votre programme et souhaitez vérifier qu'il est bien renseigné.

tuple()

Utilisez tuple() pour convertir un type de données en tuple. Par exemple, dans l'extrait ci-dessous, vous convertissez une liste Python en tuple.

a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))

<class 'tuple'>

min() et max()

max() renvoie le plus grand élément du tuple, tandis que min() renvoie le plus petit. Exemple :

print(max(a))
print(min(a))

5
A

Vous pouvez aussi les utiliser avec des tuples contenant des chaînes de caractères.

# La chaîne 'Apple' est automatiquement convertie en une séquence de caractères.
a = ('Apple') 
print(max(a))

p

sum()

Cette fonction renvoie la somme des éléments d'un tuple. Elle ne s'applique qu'aux valeurs numériques.

sum(a)

28

sorted()

Pour obtenir les éléments d'un tuple dans l'ordre trié, utilisez sorted(), comme dans l'exemple suivant :

a = (6,7,4,2,1,5,3)
sorted(a)

[1, 2, 3, 4, 5, 6, 7]

Notez que le type de retour est une liste, et non un tuple. La séquence du tuple d'origine « a » n'est pas modifiée et son type reste un tuple.

Bonus : assigner plusieurs valeurs

Un atout pratique des tuples est de permettre l'attribution de plusieurs valeurs en une seule opération. Exemple :

a = (1,2,3)
(one,two,three) = a
print(one)

1

a est un tuple de trois éléments et (one,two,three) est un tuple de trois variables. L'assignation de (one,two,three) au tuple a affecte, dans l'ordre, chaque valeur de a à chacune des variables : one, two et three. C'est très utile lorsque vous devez répartir une séquence de valeurs stockée dans un tuple.

Bravo !

Vous êtes arrivé au bout de ce tutoriel sur les tuples ! En chemin, vous avez découvert ce que sont les tuples Python, comment les initialiser, quelles sont les opérations les plus courantes pour les manipuler, ainsi que les fonctions essentielles pour mieux exploiter ces structures de données Python. En bonus, vous avez appris à assigner plusieurs valeurs à la fois à l'aide de tuples.