Tuple est un type de données intégré à Python qui est utilisé pour stocker une collection de données. Il est similaire à une liste mais est légèrement plus rapide.
Cependant, ses limites rendent les listes plus souhaitables dans certaines situations. Dans cet article, je vais vous expliquer tout ce que vous devez savoir pour commencer à utiliser les tuples.
Table des matières
Qu’est-ce qu’un Tuple ?
Comme mentionné précédemment, un tuple est l’un des types de données intégrés à Python utilisé pour stocker des collections de données. Elle est similaire à une liste Python en ce sens qu’elle stocke les données dans un format itérable, semblable à un tableau. Contrairement à une liste, cependant, un tuple est immuable. Autrement dit, une fois créées, ses valeurs ne peuvent pas être modifiées.
Des éléments supplémentaires ne peuvent pas être ajoutés et des éléments existants ne peuvent pas être supprimés. Un tuple est donc idéal pour stocker des données qui ne changent pas. Il peut même s’agir d’une collection de données de différents types. Dans la section suivante, nous discuterons des différentes manières de créer des tuples en Python.
Comment créer un Tuple en Python ?
Il existe au moins trois façons de créer des tuples en Python. Dans cette section, nous couvrirons trois des méthodes les plus courantes que vous utiliserez et verrez probablement lors de la lecture de code provenant d’autres personnes.
Pour exécuter les exemples de code suivants, vous devez avoir installé Python. Si Python n’est pas déjà installé, voici un guide utile pour installer Python. Vous pouvez également exécuter votre code dans un environnement d’exécution Python en ligne tel que Google Colab.
#1. Utilisation du littéral tuple (parenthèses)
La façon la plus courante de voir les tuples définis en Python consiste à placer une collection de valeurs entre parenthèses. Ces valeurs sont séparées par des virgules. L’exemple suivant illustre cette méthode :
# Creates a tuple by placing values between parentheses values = (1, 2, 3) # Printing out the tuple to the screen print(values) # Printing out the type of values variable print(type(values))
L’exécution de ce code produira ce qui suit :
Comme vous pouvez le voir sur la sortie, le tuple contient les valeurs avec lesquelles nous l’avons initialisé. Il est également de type
Lorsque vous créez des tuples en Python, les parenthèses ne sont pas nécessaires. Par conséquent, cette valeur = 1, 2, 3 est tout aussi valable que cette valeur = (1, 2, 3). Il est cependant recommandé d’utiliser des parenthèses pour rendre votre code plus compréhensible.
Créer des tuples avec un élément en Python est un peu délicat. Au lieu de simplement placer un élément entre parenthèses, vous devez également ajouter une virgule de fin. Voici un exemple pour illustrer :
# Without trailing comma, this won't create a tuple not_a_tuple = (1) # With trailing comma, this will create a tuple a_tuple = (1,) # Printing not_a_tuple print(not_a_tuple) # Printing not_a_tuple's data type print(type(not_a_tuple)) # Printing a_tuple print(a_tuple) # Printing a_tuple's data type print(type(a_tuple))
En exécutant le code ci-dessus, vous verrez que not_a_tuple devient un entier de valeur 1. Il est important de garder cela à l’esprit lors de la création de tuples.
#2. Utilisation de la fonction constructeur
La deuxième méthode de création de tuples en Python utilise la fonction constructeur de tuples. Dans cette méthode, vous appelez la fonction, en passant un objet itérable comme une liste comme argument. Celui-ci sera converti en un tuple. Voici un exemple:
# Creating tuple from a list of values values = tuple([1, 2, 3]) # Printing out the values print(values) # Printing out the data type of the values identifier print(type(values))
Comme vous pouvez le voir, l’utilisation de la fonction donne le même résultat que l’utilisation du littéral. Cependant, la fonction vous permet de créer un tuple basé sur une valeur dynamique, telle qu’une liste dont les valeurs ne sont connues qu’au moment de l’exécution. Avec la première méthode, vous devriez connaître les valeurs ou les identifiants qui composent votre tuple lors de l’écriture du code.
#3. Création d’un tuple vide
Lorsque vous travaillez avec des tuples dans votre code, vous devrez peut-être créer des tuples vides. Les tuples vides sont créés comme prévu. Vous pouvez utiliser le constructeur de tuple ou le littéral to lors de leur création. Voici un exemple montrant comment utiliser l’une ou l’autre méthode :
# Using the tuple literal empty_tuple_1 = () # Using the constructor empty_tuple_2 = tuple()
Les tuples vides sont utiles pour représenter un ensemble vide de résultats. Considérez la fonction suivante :
def create_range(start, end):
return tuple(range(start, end))Cette fonction crée un tuple avec des valeurs depuis le début jusqu’à la valeur de fin que vous transmettez. Si vous vouliez parcourir les résultats de la fonction, vous utiliseriez quelque chose comme ceci :
my_values = create_range(0, 5)
for value in my_values:
passSi vous fournissez 5 et 5 à la fonction create_range, le résultat serait un tuple vide. Et si vous essayiez de l’itérer, vous n’auriez aucune itération et votre code se déroulerait normalement.
D’un autre côté, s’il n’y avait pas de tuples vides et que vous obteniez à la place la valeur None, alors essayer de l’itérer générerait une erreur. Pour éviter de planter le programme, vous devez implémenter un test pour le cas limite où la fonction create_range renvoie None ou toute autre valeur représentant un tuple vide.
Cela conduirait à un code désordonné. Idéalement, vous voudriez éviter autant que possible les cas particuliers. Cela signifie que la valeur de retour de toutes les fonctions doit avoir une interface identique afin que votre code fonctionne autant que possible dans le cas général. Dans ce cas, cela signifie renvoyer un tuple tout le temps, bien que, parfois, il soit vide.
Comment accéder aux éléments
Il existe deux façons d’accéder aux éléments d’un tuple en Python. La première méthode est par index, et la seconde par déstructuration des éléments. Dans un premier temps, nous verrons comment accéder aux éléments par index.
Accéder aux éléments par index
L’accès aux éléments par l’index est similaire à la façon dont vous accéderiez aux éléments de la liste par l’index. Ceci est fait en utilisant la notation entre crochets. Les tuples utilisent un système d’indexation à base zéro, ce qui signifie que le premier élément est l’index 0 et celui qui suit est l’index 1 jusqu’au dernier élément.
L’exemple ci-dessous montre comment accéder aux éléments par index :
# Creating a tuple values = (1, 2, 3, 4) # Accessing the first element first_element = values[0] # Accessing the fourth element(index 3) fourth_element = values[3]
Vous pouvez également utiliser l’indexation négative. L’élément avec l’indice -1 est le dernier élément, et l’élément avec l’indice -2 est le deuxième à partir du dernier élément.
# Creating the tuple values = (1, 2, 3, 4) # Accessing the last element last_element = values[-1] # Accessing the second from last element second_from_last_element = values[-2]
De plus, vous pouvez également accéder à des sous-collections d’éléments d’un tuple en le découpant. Ceci est similaire à la façon dont vous découperiez une liste. La notation est la suivante
# Creating the tuple values = (1, 2, 3, 4, 5, 6, 7) # Getting the first three elements values[1: 3] # Getting every other element values[::2]
Itérer sur des éléments
Un tuple est un objet itérable en Python. Par conséquent, vous pouvez itérer sur ses éléments à l’aide d’une boucle for, comme illustré dans l’exemple suivant :
values = (1, 2, 3, 4)
for value in values:
print(value)Cette méthode d’accès aux éléments est idéale lorsque vous souhaitez accéder à tous les éléments du tuple.
Accéder aux éléments par déstructuration
Pour expliquer la déstructuration, considérons le scénario suivant où nous essayons d’obtenir les différents éléments d’un tuple.
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') # Accessing the different elements in the tuple to use in our code id = person_record[1] name = person_record[2] email = person_record[3]
Python nous permet d’utiliser une méthode plus pratique pour accéder aux valeurs, comme illustré ci-dessous :
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') id, name, email = person_record
C’est ce qu’on appelle la déstructuration. C’est-à-dire que la première variable, id dans ce cas, se verra attribuer la première valeur dans le tuple et la deuxième variable au deuxième élément. Cela continue jusqu’à la fin du tuple. L’exemple ci-dessus est équivalent à ceci :
id, name, email = (1, 'John Doe', '[email protected]')
Dans ce cas, au lieu de stocker le tuple dans une variable, nous le détruisons immédiatement. Lorsque vous combinez cela avec la connaissance que vous n’avez pas besoin d’utiliser des parenthèses lors de la création de tuples, vous pouvez alors écrire le code comme ceci.
id, name, email = 1, 'John Doe', '[email protected]'
A la fin de tout cela, vous aurez des variables id, name et email avec les valeurs 1, ‘John Doe’ et ‘[email protected]‘. C’est un moyen pratique et succinct de créer des variables en Python que vous verrez dans le code de production. Il est utile de savoir qu’au cœur de cette syntaxe élégante se trouve le concept de tuples.
Différences entre tuple et liste
Bien que les deux soient similaires, certaines différences clés rendent chacun plus adapté à un cas d’utilisation particulier. Comprendre ces différences vous aidera à choisir le meilleur type de données à utiliser et à écrire un code meilleur et plus efficace.
AspectTupleListMemory StorageStocké dans une mémoire contiguëStocké dans différentes parties de la mémoireMutabilitéImmuable (ne peut pas être modifié)Mutable (peut être modifié)VitesseL’accès est plus rapideL’accès est plus lentType de donnéesStocke généralement des données de différents typesStocke généralement des données du même typeCas d’utilisationHabituellement utilisé pour stocker une collection de valeurs similaires, telles que marques. Habituellement utilisé pour stocker une collection de valeurs similaires telles que des marques.
Avantages d’un Tuple
#1. C’est plus rapide
En raison de la façon dont les valeurs d’un tuple sont stockées dans une mémoire contiguë, l’accès aux valeurs est plus rapide par rapport à une liste. Cependant, comme une fois créés, ils ne peuvent pas être modifiés, les tuples ne sont pas toujours la meilleure structure de données à utiliser pour stocker des collections de valeurs.
Leur cas d’utilisation idéal consiste à stocker de nombreuses données en mémoire qui ne changent pas mais qui seront consultées plusieurs fois pendant l’exécution du programme. Dans ce cas, votre programme bénéficiera énormément de l’amélioration des performances des tuples.
#2. Renvoyer plusieurs valeurs
Vous pouvez utiliser des tuples pour renvoyer plusieurs valeurs à partir d’une fonction et déstructurer le résultat. Par exemple:
from random import randint
def create_two_numbers():
first_num = randint(0, 9)
second_num = randint(0, 9)
return first_num, second_num
first_num, second_num = create_two_numbers()Dans cet exemple, nous avons une fonction qui crée deux nombres aléatoires et les renvoie tous les deux dans un tuple. L’instruction return first_num, second_num équivaut à écrire return (first_num, second_num). En effet, les parenthèses sont facultatives lors de la création de tuples. Pour accéder au résultat, nous le détruisons.
#3. Les valeurs sont protégées en écriture
Les tuples sont immuables une fois créés. Ils sont donc idéaux pour stocker des données en mémoire qui ne changent pas pendant l’exécution du programme. Ils garantissent que vous n’écrasez pas accidentellement les données ailleurs dans votre code.
#4. Stocker plusieurs types de données
Les tuples vous permettent de stocker des valeurs de plusieurs types de données. Cela vous permet de créer des enregistrements de données, tels que le stockage des détails d’un utilisateur dans un tuple. Vous pouvez également stocker 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. compter()
L’objet tuple contient la méthode count, qui compte le nombre de fois qu’un élément apparaît. Par exemple:
# Creating a tuple with several numbers values = (1, 2, 3, 4, 5, 4, 4, 6) # Counting the number of fours n_fours = values.count(4) # Prining out the number of fours print(n_fours)
À partir de cet exemple, nous pouvons voir que le nombre 4 apparaît exactement trois fois dans notre tuple.
#2. indice()
La méthode index peut être utilisée pour trouver l’index de la première occurrence d’une valeur dans un tuple. Si la valeur n’existe pas, une exception ValueError sera levée. Voici du code pour illustrer le fonctionnement de la méthode index :
# Creating a tuple with several numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Search for index of 4
index_of_four = values.index(4)
print("Index of four:", index_of_four)
# Search for index of 9
index_of_nine = values.index(9)
print("Index of nine:", index_of_nine)Et lorsque nous exécutons le code ci-dessus, voici le résultat :
Dans ce cas, l’index de 4 est 3 et le code s’est exécuté sans problème. Mais lorsqu’il s’agissait de trouver l’indice de 9, le programme a soulevé une exception. Il est important de gérer ces exceptions lorsque vous écrivez des programmes Python qui utilisent la méthode index.
#3. len()
Comme tous les objets itérables en Python, les tuples ont une propriété length à laquelle vous pouvez accéder lorsque vous transmettez le tuple comme argument à la fonction len().
# Creating a tuple values = (1, 2, 3, 4) # Getting the length length = len(values) # Print the output print(length)
C’est le résultat de l’exécution du code ci-dessus.
#4. min() et max()
Les méthodes min et max fonctionnent en parcourant chaque élément d’un itérable et en comparant s’il est supérieur ou inférieur à celui qui le précède. En fin de compte, max renverra le plus grand élément de l’itérable tandis que min renverra le plus petit.
Avec les chiffres, l’opération est évidente. Avec les chaînes, Python utilisera l’ordre alphabétique. Le plus petit mot, renvoyé par min, est le premier mot si les chaînes ont été écrites dans l’ordre alphabétique. Alors que le plus grand mot est le dernier mot. Si l’itérable contient un mélange de différents types de données, les opérations échoueront toutes les deux car Python ne sait pas comment comparer différents types de données.
Voici un exemple de code :
# Creating tuple with values values = (1, 2, 3, 4, 5) # Getting the largest value largest = max(values) # Getting the smallest value smallest = min(values) # Output the results print(largest) print(smallest)
#5. trié()
La fonction triée en Python prend un objet itérable et renvoie une liste des éléments triés. Vous pouvez appeler la fonction triée, passer un tuple comme argument et obtenir les éléments du tuple triés dans une liste. Pour convertir la liste triée en tuple, vous pouvez utiliser la fonction constructeur. Voici un exemple :
# Creating a tuple with values in random order values = (1, 5, 3, 3, 2, 4) # Using sorted to sort the values into a list sorted_list = sorted(values) # Converting the list into a tuple sorted_tuple = tuple(sorted_list) # Printing the output print(sorted_tuple)
#6. Ajouter et multiplier des tuples
L’opération d’addition sur deux tuples les concatène simplement. L’opération de multiplication répète les éléments d’un tuple autant de fois que la valeur avec laquelle vous avez multiplié. Voici un exemple pour illustrer les deux exemples.
# Create a tuple with some values
values = (1, 2, 3, 4, 5)
# Create a new tuple using addition
added = values + values
# Create a new tuple using multiplication
multiplied = values * 2
print("values + values =", added)
print("values * 2 =", multiplied)
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, elles sont immuables.
- Ils sont plus rapides et plus efficaces que les listes.
- Ils peuvent être construits en utilisant des parenthèses et en séparant les valeurs par des virgules.
- Ils peuvent également être construits à l’aide de la fonction constructeur de tuple.
- Vous pouvez accéder aux valeurs individuelles à l’aide d’un système d’index de base zéro.
- Vous pouvez également déstructurer les valeurs du tuple.
- Vous pouvez également parcourir les valeurs à l’aide d’une boucle for.
- Les différentes méthodes que vous pouvez utiliser avec un tuple.
Ensuite, vous voudrez peut-être consulter plus de contenu Python, comme les méthodes de liste Python et les méthodes de dictionnaire Python.