Un tuple, intégré à Python, est une structure de données conçue pour regrouper des éléments. Semblable à une liste, il se distingue par sa rapidité accrue.
Cependant, certaines limitations font que les listes sont parfois préférables. Cet article explore les aspects essentiels pour maîtriser l’utilisation des tuples.
Qu’est-ce qu’un Tuple?
Comme mentionné précédemment, un tuple est un type de donnée fondamental en Python servant à organiser des ensembles de données. Son fonctionnement est analogue à celui d’une liste, car il ordonne les informations de manière itérable, à la façon d’un tableau. La particularité du tuple réside dans son immuabilité : une fois créé, son contenu est figé, impossible à modifier.
Il est impossible d’ajouter ou de supprimer des éléments. Ainsi, le tuple est idéal pour stocker des données stables. Il peut même accueillir des données de types variés. La section suivante détaille les différentes approches pour créer des tuples en Python.
Comment Créer un Tuple en Python?
Il existe diverses façons de générer des tuples en Python. Cette partie explore trois des méthodes les plus courantes, celles que vous rencontrerez souvent en lisant le code d’autres développeurs.
Pour expérimenter les exemples de code, Python doit être installé sur votre système. Si ce n’est pas le cas, un guide d’installation est disponible. Vous pouvez également exécuter votre code via un environnement en ligne tel que Google Colab.
#1. Utilisation de la syntaxe littérale (parenthèses)
La méthode la plus courante pour définir un tuple en Python est d’encadrer un ensemble de valeurs entre parenthèses, chacune étant séparée par une virgule. L’exemple suivant illustre cette approche :
# Création d'un tuple en encadrant les valeurs par des parenthèses valeurs = (1, 2, 3) # Affichage du tuple print(valeurs) # Affichage du type de la variable "valeurs" print(type(valeurs))
L’exécution de ce code affichera le résultat suivant :
Comme le montre le résultat, le tuple contient les valeurs spécifiées lors de son initialisation et est de type
En Python, les parenthèses sont facultatives lors de la création d’un tuple. Ainsi, la déclaration valeurs = 1, 2, 3 est aussi valide que valeurs = (1, 2, 3). Néanmoins, il est recommandé d’employer les parenthèses pour une meilleure lisibilité du code.
La création d’un tuple avec un seul élément nécessite une attention particulière. Il ne suffit pas de placer cet élément entre parenthèses ; il faut également ajouter une virgule à la fin. Voici un exemple :
# Sans virgule finale, il ne s'agit pas d'un tuple pas_un_tuple = (1) # Avec virgule finale, il s'agit bien d'un tuple un_tuple = (1,) # Affichage de "pas_un_tuple" print(pas_un_tuple) # Affichage du type de donnée de "pas_un_tuple" print(type(pas_un_tuple)) # Affichage de "un_tuple" print(un_tuple) # Affichage du type de donnée de "un_tuple" print(type(un_tuple))
L’exécution du code révèle que `pas_un_tuple` est interprété comme un entier de valeur 1. Il est essentiel de retenir cette particularité lors de la création de tuples.
#2. Utilisation de la fonction constructeur
Une autre manière de créer des tuples en Python est d’employer la fonction constructeur `tuple()`. Cette méthode consiste à appeler la fonction en lui passant un objet itérable comme argument, tel qu’une liste. Ce dernier sera alors transformé en tuple. Voici un exemple :
# Création d'un tuple à partir d'une liste valeurs = tuple([1, 2, 3]) # Affichage des valeurs print(valeurs) # Affichage du type de donnée de la variable "valeurs" print(type(valeurs))
Comme vous pouvez le constater, l’emploi de la fonction aboutit au même résultat que l’utilisation de la syntaxe littérale. Toutefois, la fonction permet de générer un tuple basé sur une valeur dynamique, telle qu’une liste dont les valeurs sont déterminées à l’exécution. Avec la première méthode, il est nécessaire de connaître les valeurs ou les identifiants constituant le tuple lors de l’écriture du code.
#3. Création d’un tuple vide
Lors de la manipulation de tuples, il est parfois nécessaire de créer des tuples vides. Ceux-ci peuvent être créés de deux manières : avec le constructeur ou avec la syntaxe littérale. L’exemple suivant montre les deux approches :
# Utilisation de la syntaxe littérale tuple_vide_1 = () # Utilisation du constructeur tuple_vide_2 = tuple()
Les tuples vides servent notamment à représenter un ensemble de résultats inexistant. Prenez l’exemple de cette fonction :
def creer_intervalle(debut, fin):
return tuple(range(debut, fin))
Cette fonction génère un tuple contenant les valeurs allant du début à la fin spécifiée. Pour parcourir les résultats de la fonction, on utilise généralement une boucle :
mes_valeurs = creer_intervalle(0, 5)
for valeur in mes_valeurs:
pass
Si vous passez 5 et 5 en argument à `creer_intervalle`, la fonction retournera un tuple vide. La boucle `for` ne produira alors aucune itération, et le code se déroulera sans incident.
En l’absence de tuples vides et si `creer_intervalle` retournait par exemple la valeur `None`, une tentative d’itération générerait une erreur. Pour éviter un plantage, il faudrait alors ajouter un test pour gérer le cas limite où la fonction retourne `None` ou toute autre valeur indiquant un tuple vide.
Cela compliquerait inutilement le code. Il est préférable d’éviter les cas spéciaux et de s’assurer que toutes les fonctions retournent des valeurs d’une interface uniforme. Dans ce contexte, cela signifie que la fonction doit toujours retourner un tuple, même s’il est parfois vide.
Comment Accéder aux Éléments
Il y a deux manières d’accéder aux éléments d’un tuple en Python : via leur index ou en les déstructurant. Nous allons commencer par explorer l’accès par index.
Accéder aux Éléments par Index
L’accès aux éléments via leur index est similaire à l’accès aux éléments d’une liste. On utilise pour cela la notation entre crochets. Les tuples sont indexés à partir de zéro, ce qui signifie que le premier élément a l’index 0, le suivant l’index 1 et ainsi de suite jusqu’au dernier élément.
L’exemple ci-dessous illustre l’accès aux éléments par leur index :
# Création d'un tuple valeurs = (1, 2, 3, 4) # Accès au premier élément premier_element = valeurs[0] # Accès au quatrième élément (index 3) quatrieme_element = valeurs[3]
L’indexation négative est également possible. L’élément d’index -1 est le dernier élément, celui d’index -2 est l’avant-dernier et ainsi de suite.
# Création du tuple valeurs = (1, 2, 3, 4) # Accès au dernier élément dernier_element = valeurs[-1] # Accès à l'avant-dernier élément avant_dernier_element = valeurs[-2]
De plus, on peut accéder à des sous-ensembles d’éléments en utilisant le découpage (slicing). Cette méthode est similaire à celle utilisée pour les listes. La notation est : `[
# Création du tuple valeurs = (1, 2, 3, 4, 5, 6, 7) # Récupération des trois premiers éléments valeurs[1:3] # Récupération d'un élément sur deux valeurs[::2]
Itérer sur des Éléments
Un tuple est un objet itérable en Python. On peut donc parcourir ses éléments à l’aide d’une boucle `for`, comme le montre cet exemple :
valeurs = (1, 2, 3, 4)
for valeur in valeurs:
print(valeur)
Cette approche d’accès aux éléments est idéale lorsque l’on souhaite traiter tous les éléments du tuple.
Accéder aux Éléments par Déstructuration
Pour comprendre la déstructuration, prenons l’exemple suivant, où l’on essaie de récupérer les différents éléments d’un tuple.
# Création d'un tuple contenant les informations d'un utilisateur enregistrement_personne = (1, 'John Doe', '[email protected]') # Accès aux différents éléments du tuple pour les utiliser dans le code identifiant = enregistrement_personne[1] nom = enregistrement_personne[2] email = enregistrement_personne[3]
Python permet une méthode d’accès plus élégante :
# Création du tuple contenant les informations d'un utilisateur enregistrement_personne = (1, 'John Doe', '[email protected]') identifiant, nom, email = enregistrement_personne
C’est ce qu’on appelle la déstructuration. La première variable, `identifiant`, se voit attribuer la première valeur du tuple, la deuxième variable, `nom`, reçoit le deuxième élément et ainsi de suite. L’exemple ci-dessus équivaut à :
identifiant, nom, email = (1, 'John Doe', '[email protected]')
Ici, au lieu de stocker le tuple dans une variable, on le décompose immédiatement. En sachant qu’il est possible d’omettre les parenthèses lors de la création de tuples, on peut écrire le code de la manière suivante :
identifiant, nom, email = 1, 'John Doe', '[email protected]'
Après cette opération, les variables `identifiant`, `nom` et `email` contiendront les valeurs 1, ‘John Doe’ et ‘[email protected]‘. Il s’agit d’une méthode pratique et concise pour créer des variables en Python, que l’on rencontre souvent dans du code de production. Il est donc important de comprendre que, derrière cette élégante syntaxe, se cache le concept des tuples.
Différences entre Tuple et Liste
Bien qu’ils soient similaires, certaines différences fondamentales font que chacun est mieux adapté à un usage spécifique. Comprendre ces différences vous aidera à sélectionner le bon type de données et à écrire un code plus efficace.
| Aspect | Tuple | Liste |
| Stockage en mémoire | Stocké dans une zone mémoire contiguë | Stocké dans différentes parties de la mémoire |
| Modifiabilité | Immuable (ne peut être modifié) | Mutable (peut être modifié) |
| Vitesse | Accès plus rapide | Accès plus lent |
| Type de données | Stocke généralement des données de types variés | Stocke généralement des données du même type |
| Cas d’utilisation | Habituellement utilisé pour stocker une collection de valeurs similaires, telles que des marques. | Habituellement utilisé pour stocker une collection de valeurs similaires telles que des marques. |
Avantages d’un Tuple
#1. Plus rapide
Grâce à la façon dont les valeurs d’un tuple sont stockées en mémoire de manière contiguë, l’accès aux valeurs est plus rapide qu’avec une liste. Cependant, du fait de leur immuabilité, les tuples ne sont pas toujours la meilleure structure de données pour stocker des collections de valeurs.
Leur utilisation idéale consiste à stocker en mémoire un grand volume de données qui ne seront pas modifiées, mais qui seront consultées à plusieurs reprises durant l’exécution du programme. Dans ce cas, votre programme bénéficiera grandement des performances accrues des tuples.
#2. Retourner Plusieurs Valeurs
Vous pouvez utiliser des tuples pour retourner plusieurs valeurs à partir d’une fonction et déstructurer le résultat. Par exemple :
from random import randint
def creer_deux_nombres():
premier_nombre = randint(0, 9)
second_nombre = randint(0, 9)
return premier_nombre, second_nombre
premier_nombre, second_nombre = creer_deux_nombres()
Dans cet exemple, une fonction génère deux nombres aléatoires et les retourne tous les deux dans un tuple. L’instruction `return premier_nombre, second_nombre` équivaut à écrire `return (premier_nombre, second_nombre)`. En effet, les parenthèses sont facultatives lors de la création de tuples. Pour accéder au résultat, on utilise la déstructuration.
#3. Protection en Écriture des Valeurs
Les tuples étant immuables une fois créés, ils sont idéaux pour stocker des données en mémoire qui ne changeront pas pendant l’exécution du programme. Ils garantissent que vous ne modifierez pas accidentellement les données ailleurs dans votre code.
#4. Stocker Plusieurs Types de Données
Les tuples permettent de stocker des valeurs de différents types. Cela vous permet de créer des enregistrements de données, comme le stockage des informations d’un utilisateur dans un tuple. Vous pouvez aussi y inclure des éléments plus complexes tels que des fonctions, des dictionnaires, d’autres tuples et même des listes.
Méthodes de Tuple Courantes
#1. count()
L’objet tuple possède la méthode `count()`, qui calcule le nombre d’occurrences d’un élément donné. Voici un exemple :
# Création d'un tuple contenant plusieurs nombres valeurs = (1, 2, 3, 4, 5, 4, 4, 6) # Comptage du nombre de 4 nombre_de_4 = valeurs.count(4) # Affichage du nombre de 4 print(nombre_de_4)
Dans cet exemple, nous constatons que le nombre 4 apparaît exactement trois fois dans le tuple.
#2. index()
La méthode `index()` permet de trouver l’index de la première occurrence d’une valeur dans un tuple. Si la valeur n’existe pas, une exception `ValueError` est levée. Le code suivant illustre le fonctionnement de cette méthode :
# Création d'un tuple contenant plusieurs nombres
valeurs = (1, 2, 3, 4, 5, 4, 4, 6)
# Recherche de l'index du 4
index_du_4 = valeurs.index(4)
print("Index du 4:", index_du_4)
# Recherche de l'index du 9
index_du_9 = valeurs.index(9)
print("Index du 9:", index_du_9)
L’exécution de ce code produit le résultat suivant :
Dans ce cas, l’index de 4 est bien 3 et le code s’exécute sans problème. Toutefois, la recherche de l’index de 9 a provoqué une exception. Il est donc important de gérer ces exceptions lors de l’écriture de programmes Python qui utilisent la méthode `index()`.
#3. len()
Comme tous les objets itérables en Python, les tuples ont une propriété « longueur » que l’on peut obtenir en passant le tuple comme argument à la fonction `len()`.
# Création d'un tuple valeurs = (1, 2, 3, 4) # Obtention de la longueur longueur = len(valeurs) # Affichage du résultat print(longueur)
Ceci est le résultat de l’exécution du code ci-dessus.
#4. min() et max()
Les fonctions `min()` et `max()` parcourent chaque élément d’un itérable et les comparent afin de déterminer le plus petit et le plus grand élément. `max()` retourne le plus grand élément, tandis que `min()` retourne le plus petit.
Dans le cas de nombres, la comparaison est évidente. Avec des chaînes de caractères, Python utilise l’ordre alphabétique. Le plus petit mot, retourné par `min()`, est le premier mot si les chaînes ont été classées par ordre alphabétique. Le plus grand mot est alors le dernier. Si l’itérable contient un mélange de types de données différents, les opérations échoueront car Python ne sait pas comment comparer différents types de données.
Voici un exemple de code :
# Création d'un tuple avec des valeurs valeurs = (1, 2, 3, 4, 5) # Obtention de la plus grande valeur plus_grand = max(valeurs) # Obtention de la plus petite valeur plus_petit = min(valeurs) # Affichage des résultats print(plus_grand) print(plus_petit)
#5. sorted()
La fonction `sorted()` en Python prend un objet itérable et retourne une liste contenant les éléments triés. Vous pouvez appeler la fonction `sorted()`, en passant un tuple comme argument, et obtenir les éléments du tuple triés dans une liste. Pour reconvertir la liste triée en tuple, utilisez la fonction constructeur `tuple()`. Voici un exemple :
# Création d'un tuple avec des valeurs dans un ordre aléatoire valeurs = (1, 5, 3, 3, 2, 4) # Utilisation de sorted() pour trier les valeurs dans une liste liste_triee = sorted(valeurs) # Conversion de la liste en tuple tuple_trie = tuple(liste_triee) # Affichage du résultat print(tuple_trie)
#6. Additionner et Multiplier des Tuples
L’opération d’addition sur deux tuples a pour effet de les concaténer. La multiplication répète les éléments d’un tuple autant de fois que la valeur du multiplicateur. L’exemple suivant illustre ces deux opérations.
# Création d'un tuple avec des valeurs
valeurs = (1, 2, 3, 4, 5)
# Création d'un nouveau tuple par addition
ajoute = valeurs + valeurs
# Création d'un nouveau tuple par multiplication
multiplie = valeurs * 2
print("valeurs + valeurs =", ajoute)
print("valeurs * 2 =", multiplie)
Derniers Mots
Dans cet article, vous avez appris que :
- Les tuples sont des objets de type liste utilisés pour stocker des collections de valeurs.
- Contrairement aux listes, ils sont immuables.
- Ils sont plus rapides et plus efficaces que les listes.
- Ils peuvent être créés en utilisant des parenthèses et en séparant les valeurs par des virgules.
- Ils peuvent aussi être créés avec la fonction constructeur `tuple()`.
- Vous pouvez accéder aux valeurs individuelles via un système d’index basé sur zéro.
- Vous pouvez également déstructurer les valeurs du tuple.
- Vous pouvez parcourir les valeurs en utilisant une boucle `for`.
- Différentes méthodes sont disponibles pour manipuler les tuples.
Pour approfondir vos connaissances, vous pouvez explorer d’autres sujets tels que les méthodes de liste et les méthodes de dictionnaire en Python.