Comprendre les tuples en Python 3

Introduction

Un tuple est une structure de données qui est une séquence ordonnée d'éléments immuable, ou inchangeable. Étant donné que les tuples sont immuables, leurs valeurs ne peuvent pas être modifiées. L'exemple suivant est un tuple qui se compose de quatre éléments :

Example Tuple
coral = ('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')

Les tuples sont utilisés pour regrouper des données. Chaque élément ou valeur qui se trouve à l'intérieur d'un tuple est appelé un item.

Les tuples ont des valeurs entre parenthèses ( ) séparées par des virgules ,. Les tuples vides apparaîtront comme coral =(), mais les tuples avec au moins une valeur doivent utiliser une virgule comme dans coral=('corail bleu',).

Si nous print() le tuple ci-dessus, nous recevrons la sortie suivante, avec le tuple toujours écrit entre parenthèses :

print(coral)

('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')

Lorsqu'on réfléchit aux tuples Python et à d'autres structures de données qui sont des types de collections, il est utile de considérer toutes les différentes collections que vous avez sur votre ordinateur : votre assortiment de fichiers, vos playlists de chansons, vos favoris de navigateur, vos e-mails, la collection de vidéos auxquelles vous pouvez accéder sur un service de streaming, et plus encore.

Les tuples sont similaires aux listes, mais leurs valeurs ne peuvent pas être modifiées. Pour cette raison, lorsque vous utilisez des tuples dans votre code, vous signalez aux autres que vous n'avez pas l'intention d'apporter des modifications à cette séquence de valeurs. De plus, comme les valeurs ne changent pas, votre code peut être optimisé grâce à l'utilisation de tuples en Python, car le code sera légèrement plus rapide pour les tuples que pour les listes.

Conditions préalables

Vous devez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou serveur. Si vous n'avez pas d'environnement de programmation configuré, vous pouvez consulter les guides d'installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur, approprié à votre système d'exploitation (Ubuntu, CentOS, Debian, etc.).

Indexation des tuples

En tant que séquence ordonnée d'éléments, chaque élément d'un tuple peut être appelé individuellement, par indexation.

Chaque élément correspond à un numéro d'index, qui est une valeur entière, commençant par le numéro d'index 0.

Pour l'exemple de tuple coral au début de ce tutoriel, la répartition de l'index ressemble à ceci :

Le premier élément, la chaîne 'corail bleu' commence à l'index 0, et la liste se termine à l'index 3 avec l'élément 'corail en corne d'élan'.

Parce que chaque élément d'un tuple Python a un numéro d'index correspondant, nous sommes en mesure d'accéder aux éléments.

Maintenant, nous pouvons appeler un élément discret du tuple en nous référant à son numéro d'index :

print(coral[2])

pillar coral

Les numéros d'index pour ce tuple varient de 0 à 3, comme indiqué dans le tableau ci-dessus. Donc, pour appeler chacun des éléments individuellement, nous ferions référence aux numéros d'index de cette manière :

coral[0] = 'blue coral'
coral[1] = 'staghorn coral' 
coral[2] = 'pillar coral' 
coral[3] = 'elkhorn coral'

Si nous appelons le tuple coral avec un numéro d'index supérieur à 3, cela sera hors de portée car ce ne sera pas valide :

print(coral[22])

IndexError: tuple index out of range

En plus des indices positifs, nous pouvons également accéder aux éléments du tuple avec un indice négatif, en comptant à rebours à partir de la fin du tuple, en commençant par -1. Cela est particulièrement utile si nous avons un long tuple et que nous voulons localiser un élément près de la fin du tuple.

Pour le même tuple corail, la décomposition des index négatifs ressemble à ceci :

Ainsi, si nous voulons imprimer l'élément 'corail bleu' en utilisant son numéro d'index négatif, nous pouvons le faire comme ceci :

print(coral[-4])

blue coral

Nous pouvons concaténer des éléments de chaîne dans un tuple avec d'autres chaînes en utilisant l'opérateur + :

print('This reef is made up of ' + coral[1])

This reef is made up of staghorn coral

Nous avons pu concaténer l'élément de chaîne à l'index numéro 0 avec la chaîne 'Ce récif est composé de '. Nous pouvons également utiliser l'opérateur + pour concaténer 2 tuples ou plus ensemble.

Avec des numéros d'index qui correspondent aux éléments d'un tuple, nous pouvons accéder à chaque élément d'un tuple de manière discrète.

Trancher des tuples

Nous pouvons utiliser l'indexation pour extraire quelques éléments du tuple. Les tranches nous permettent d'appeler plusieurs valeurs en créant une plage de numéros d'index séparés par deux-points [x:y].

Disons que nous voulons uniquement imprimer les éléments du milieu de coral, nous pouvons le faire en créant une tranche.

print(coral[1:3])

('staghorn coral', 'pillar coral')

Lors de la création d'une tranche, comme dans [1:3], le premier numéro d'index est l'endroit où la tranche commence (inclusif), et le deuxième numéro d'index est l'endroit où la tranche se termine (exclusif), c'est pourquoi dans notre exemple ci-dessus, les éléments aux positions 1 et 2 sont les éléments qui s'affichent.

Si nous voulons inclure l'une ou l'autre extrémité de la liste, nous pouvons omettre l'un des numéros dans la syntaxe tuple[x:y]. Par exemple, si nous voulons imprimer les 3 premiers éléments du tuple coral — qui seraient 'corail bleu', 'corail cerf de mer', 'corail pilier' — nous pouvons le faire en tapant :

print(coral[:3])

('blue coral', 'staghorn coral', 'pillar coral')

Cela a imprimé le début du tuple, s'arrêtant juste avant l'index 3.

Pour inclure tous les éléments à la fin d'un tuple, nous inverserions la syntaxe :

print(coral[1:])

('staghorn coral', 'pillar coral', 'elkhorn coral')

Nous pouvons également utiliser des indices négatifs lors de la découpe des tuples, similaires aux indices positifs :

print(coral[-3:-1])
print(coral[-2:])

('staghorn coral', 'pillar coral')
('pillar coral', 'elkhorn coral')

Un dernier paramètre que nous pouvons utiliser avec la découpe est appelé stride, qui fait référence au nombre d'éléments à avancer après que le premier élément a été récupéré du tuple.

Jusqu'à présent, nous avons omis le paramètre de pas, et Python par défaut utilise un pas de 1, de sorte que chaque élément entre deux numéros d'index est récupéré.

La syntaxe de cette construction est tuple[x:y:z], où z fait référence au pas. Créons une liste plus grande, puis découpons-la et donnons au pas une valeur de 2 :

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

print(numbers[1:11:2])

(1, 3, 5, 7, 9)

Notre construction numbers[1:11:2] imprime les valeurs entre les index inclusifs de 1 et exclusif de 11, puis la valeur de pas de 2 indique au programme d'imprimer seulement chaque deuxième élément.

Nous pouvons omettre les deux premiers paramètres et utiliser le pas seul comme paramètre avec la syntaxe tuple[::z] :

print(numbers[::3])

(0, 3, 6, 9, 12)

En imprimant le tuple nombres avec un pas de 3, seul chaque troisième élément est imprimé :

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Trancher des tuples avec des indices à la fois positifs et négatifs et indiquer le pas nous donne le contrôle nécessaire pour obtenir le résultat que nous essayons d'atteindre.

Concaténer et multiplier des tuples

Les opérateurs peuvent être utilisés pour concaténer ou multiplier des tuples. La concaténation se fait avec l'opérateur +, et la multiplication se fait avec l'opérateur *.

L'opérateur + peut être utilisé pour concaténer deux tuples ou plus ensemble. Nous pouvons affecter les valeurs de deux tuples existants à un nouveau tuple :

coral = ('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')
kelp = ('wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

coral_kelp = (coral + kelp)

print(coral_kelp)

('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral', 'wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

Parce que l'opérateur + peut concaténer, il peut être utilisé pour combiner des tuples afin de former un nouveau tuple, bien qu'il ne puisse pas modifier un tuple existant.

L'opérateur * peut être utilisé pour multiplier des tuples. Peut-être avez-vous besoin de faire des copies de tous les fichiers dans un répertoire sur un serveur ou de partager une playlist avec des amis — dans ces cas, vous auriez besoin de multiplier des collections de données.

Multiplions le tuple coral par 2 et le tuple kelp par 3, et affectons-les à de nouveaux tuples :

multiplied_coral = coral * 2
multiplied_kelp = kelp * 3

print(multiplied_coral)
print(multiplied_kelp)

('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral', 'blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')
('wakame', 'alaria', 'deep-sea tangle', 'macrocystis', 'wakame', 'alaria', 'deep-sea tangle', 'macrocystis', 'wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

En utilisant l'opérateur *, nous pouvons reproduire nos tuples autant de fois que nous le spécifions, créant ainsi de nouveaux tuples basés sur la séquence de données originale.

Les tuples existants peuvent être concaténés ou multipliés pour former de nouveaux tuples en utilisant les opérateurs + et *.

Fonctions de tuple

Il existe quelques fonctions intégrées que vous pouvez utiliser pour travailler avec des tuples. Examinons-en quelques-unes.

len()

Tout comme avec les chaînes et les listes, nous pouvons calculer la longueur d'un tuple en utilisant len(), où nous passons le tuple comme paramètre, comme dans :

len(coral)

Cette fonction est utile lorsque vous devez imposer des longueurs de collection minimales ou maximales, par exemple, ou pour comparer des données séquencées.

Si nous affichons la longueur de nos tuples kelp et numbers, nous obtiendrons la sortie suivante :

print(len(kelp))
print(len(numbers))

4
13

Nous recevons la sortie ci-dessus car le tuple kelp comporte 4 éléments :

kelp = ('wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

Et le tuple numbers contient 13 éléments :

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

Bien que ces exemples contiennent relativement peu d'éléments, la fonction len() nous offre l'occasion de voir combien d'éléments se trouvent dans de grands tuples.

max() et min()

Lorsque nous travaillons avec des tuples composés d'éléments numériques (y compris des entiers et des flottants), nous pouvons utiliser les fonctions max() et min() pour trouver les valeurs les plus élevées et les plus basses contenues dans le tuple respectif.

Ces fonctions nous permettent d'obtenir des informations sur des données quantitatives, telles que les notes de test, les températures, les prix, etc.

Regardons un tuple composé de flottants :

more_numbers = (11.13, 34.87, 95.59, 82.49, 42.73, 11.12, 95.57)

Pour obtenir le max(), nous passerions le tuple à la fonction, comme dans max(more_numbers). Nous allons combiner cela avec la fonction print() afin que nous puissions afficher nos résultats :

print(max(more_numbers))

95.59

La fonction max() a retourné la valeur la plus élevée de notre tuple.

De la même manière, nous pouvons utiliser la fonction min() :

print(min(more_numbers))

11.12

Ici, le plus petit flottant a été trouvé dans le tuple et imprimé.

Tout comme avec la fonction len(), les fonctions max() et min() peuvent être très utiles lorsqu'on travaille avec des tuples qui contiennent de nombreuses valeurs.

Comment les tuples diffèrent des listes

La principale différence entre les tuples et les listes est qu'ils ne peuvent pas être modifiés. Cela signifie que les éléments ne peuvent pas être ajoutés ou supprimés des tuples, et les éléments ne peuvent pas être remplacés à l'intérieur des tuples.

Vous pouvez cependant concaténer 2 ou plusieurs tuples pour former un nouveau tuple.

Considérons notre tuple coral :

coral = ('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')

Disons que nous voulons remplacer l'élément 'corail bleu' par un autre élément appelé 'corail noir'. Si nous essayons de modifier cette sortie de la même manière que nous le faisons avec une liste, en tapant:

coral[0] = 'black coral'

Nous recevrons une erreur comme notre sortie :

TypeError: 'tuple' object does not support item assignment

C'est parce que les tuples ne peuvent pas être modifiés.

Si nous créons un tuple et décidons que ce dont nous avons vraiment besoin est une liste, nous pouvons le convertir en liste. Pour convertir un tuple en liste, nous pouvons le faire avec list() :

list(coral)

Et maintenant, notre type de données corail sera une liste :

coral = ['blue coral', 'staghorn coral', 'pillar coral']

Nous pouvons voir que le tuple a été converti en liste car les parenthèses ont été remplacées par des crochets.

De même, nous pouvons convertir des listes en tuples avec tuple().

Vous pouvez en savoir plus sur la conversion des types de données en lisant "Comment convertir des types de données en Python 3."

Conclusion

Le type de données tuple est un type de données séquencé qui ne peut pas être modifié, offrant une optimisation à vos programmes en étant un type légèrement plus rapide à traiter que les listes pour Python. Lorsque d'autres collaborent avec vous sur votre code, votre utilisation de tuples leur fera comprendre que vous n'avez pas l'intention que ces séquences de valeurs soient modifiées.

Ce tutoriel a couvert les fonctionnalités de base des tuples, y compris l'indexation, la découpe et la concaténation des tuples, ainsi que les fonctions intégrées disponibles.