Dans cet article, vous apprendrez tout sur les tuples Python. Plus précisément, que sont les tuples, comment les créer, quand les utiliser et diverses méthodes avec lesquelles vous devez être familier.
Vidéo: listes et tuples Python
Un tuple en Python est similaire à une liste. La différence entre les deux est que nous ne pouvons pas changer les éléments d'un tuple une fois qu'il est assigné alors que nous pouvons changer les éléments d'une liste.
Créer un tuple
Un tuple est créé en plaçant tous les éléments (éléments) entre parenthèses (), séparés par des virgules. Les parenthèses sont facultatives, cependant, il est recommandé de les utiliser.
Un tuple peut avoir n'importe quel nombre d'éléments et ils peuvent être de types différents (entier, flottant, liste, chaîne, etc.).
# Different types of tuples # Empty tuple my_tuple = () print(my_tuple) # Tuple having integers my_tuple = (1, 2, 3) print(my_tuple) # tuple with mixed datatypes my_tuple = (1, "Hello", 3.4) print(my_tuple) # nested tuple my_tuple = ("mouse", (8, 4, 6), (1, 2, 3)) print(my_tuple)
Production
() (1, 2, 3) (1, 'Bonjour', 3.4) ('souris', (8, 4, 6), (1, 2, 3))
Un tuple peut également être créé sans utiliser de parenthèses. Ceci est connu sous le nom d'emballage de tuple.
my_tuple = 3, 4.6, "dog" print(my_tuple) # tuple unpacking is also possible a, b, c = my_tuple print(a) # 3 print(b) # 4.6 print(c) # dog
Production
(3, 4,6, 'chien') 3 4,6 chien
Créer un tuple avec un élément est un peu délicat.
Avoir un élément entre parenthèses ne suffit pas. Nous aurons besoin d'une virgule de fin pour indiquer qu'il s'agit en fait d'un tuple.
my_tuple = ("hello") print(type(my_tuple)) # # Creating a tuple having one element my_tuple = ("hello",) print(type(my_tuple)) # # Parentheses is optional my_tuple = "hello", print(type(my_tuple)) #
Production
Accéder aux éléments de tuple
Il existe différentes manières d'accéder aux éléments d'un tuple.
1. Indexation
Nous pouvons utiliser l'opérateur d'index ()pour accéder à un élément dans un tuple, où l'index commence à 0.
Ainsi, un tuple ayant 6 éléments aura des indices de 0 à 5. Essayer d'accéder à un index en dehors de la plage d'index de tuple (6,7,… dans cet exemple) lèvera un IndexError.
L'index doit être un entier, nous ne pouvons donc pas utiliser float ou d'autres types. Cela entraînera TypeError.
De même, les tuples imbriqués sont accessibles à l'aide de l'indexation imbriquée, comme illustré dans l'exemple ci-dessous.
# Accessing tuple elements using indexing my_tuple = ('p','e','r','m','i','t') print(my_tuple(0)) # 'p' print(my_tuple(5)) # 't' # IndexError: list index out of range # print(my_tuple(6)) # Index must be an integer # TypeError: list indices must be integers, not float # my_tuple(2.0) # nested tuple n_tuple = ("mouse", (8, 4, 6), (1, 2, 3)) # nested index print(n_tuple(0)(3)) # 's' print(n_tuple(1)(1)) # 4
Production
points 4
2. Indexation négative
Python permet une indexation négative pour ses séquences.
L'index -1 fait référence au dernier élément, -2 à l'avant-dernier élément et ainsi de suite.
# Negative indexing for accessing tuple elements my_tuple = ('p', 'e', 'r', 'm', 'i', 't') # Output: 't' print(my_tuple(-1)) # Output: 'p' print(my_tuple(-6))
Production
tp
3. Tranchage
Nous pouvons accéder à une plage d'éléments dans un tuple en utilisant l'opérateur de découpage deux-points :.
# Accessing tuple elements using slicing my_tuple = ('p','r','o','g','r','a','m','i','z') # elements 2nd to 4th # Output: ('r', 'o', 'g') print(my_tuple(1:4)) # elements beginning to 2nd # Output: ('p', 'r') print(my_tuple(:-7)) # elements 8th to end # Output: ('i', 'z') print(my_tuple(7:)) # elements beginning to end # Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') print(my_tuple(:))
Production
('r', 'o', 'g') ('p', 'r') ('i', 'z') ('p', 'r', 'o', 'g', 'r ',' a ',' m ',' i ',' z ')
Le découpage peut être mieux visualisé en considérant que l'index se situe entre les éléments, comme indiqué ci-dessous. Donc, si nous voulons accéder à une plage, nous avons besoin de l'index qui découpera la partie du tuple.
Tranchage d'élément en Python
Changer un tuple
Contrairement aux listes, les tuples sont immuables.
Cela signifie que les éléments d'un tuple ne peuvent pas être modifiés une fois qu'ils ont été affectés. Mais, si l'élément est lui-même un type de données mutable comme list, ses éléments imbriqués peuvent être modifiés.
Nous pouvons également attribuer un tuple à différentes valeurs (réaffectation).
# Changing tuple values my_tuple = (4, 2, 3, (6, 5)) # TypeError: 'tuple' object does not support item assignment # my_tuple(1) = 9 # However, item of mutable element can be changed my_tuple(3)(0) = 9 # Output: (4, 2, 3, (9, 5)) print(my_tuple) # Tuples can be reassigned my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') # Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') print(my_tuple)
Production
(4, 2, 3, (9, 5)) ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
We can use + operator to combine two tuples. This is called concatenation.
We can also repeat the elements in a tuple for a given number of times using the * operator.
Both + and * operations result in a new tuple.
# Concatenation # Output: (1, 2, 3, 4, 5, 6) print((1, 2, 3) + (4, 5, 6)) # Repeat # Output: ('Repeat', 'Repeat', 'Repeat') print(("Repeat",) * 3)
Output
(1, 2, 3, 4, 5, 6) ('Repeat', 'Repeat', 'Repeat')
Deleting a Tuple
As discussed above, we cannot change the elements in a tuple. It means that we cannot delete or remove items from a tuple.
Deleting a tuple entirely, however, is possible using the keyword del.
# Deleting tuples my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') # can't delete items # TypeError: 'tuple' object doesn't support item deletion # del my_tuple(3) # Can delete an entire tuple del my_tuple # NameError: name 'my_tuple' is not defined print(my_tuple)
Output
Traceback (most recent call last): File "", line 12, in NameError: name 'my_tuple' is not defined
Tuple Methods
Methods that add items or remove items are not available with tuple. Only the following two methods are available.
Some examples of Python tuple methods:
my_tuple = ('a', 'p', 'p', 'l', 'e',) print(my_tuple.count('p')) # Output: 2 print(my_tuple.index('l')) # Output: 3
Output
2 3
Other Tuple Operations
1. Tuple Membership Test
We can test if an item exists in a tuple or not, using the keyword in.
# Membership test in tuple my_tuple = ('a', 'p', 'p', 'l', 'e',) # In operation print('a' in my_tuple) print('b' in my_tuple) # Not in operation print('g' not in my_tuple)
Output
True False True
2. Iterating Through a Tuple
We can use a for loop to iterate through each item in a tuple.
# Using a for loop to iterate through a tuple for name in ('John', 'Kate'): print("Hello", name)
Output
Hello John Hello Kate
Advantages of Tuple over List
Since tuples are quite similar to lists, both of them are used in similar situations. However, there are certain advantages of implementing a tuple over a list. Below listed are some of the main advantages:
- Nous utilisons généralement des tuples pour des types de données hétérogènes (différents) et des listes pour des types de données homogènes (similaires).
- Étant donné que les tuples sont immuables, l'itération dans un tuple est plus rapide qu'avec list. Il y a donc une légère amélioration des performances.
- Les tuples qui contiennent des éléments immuables peuvent être utilisés comme clé pour un dictionnaire. Avec les listes, ce n'est pas possible.
- Si vous avez des données qui ne changent pas, l'implémenter en tant que tuple garantira qu'il reste protégé en écriture.
