Création d'un tuple

Un tuple est créé en plaçant tous les éléments (éléments) entre parenthèses () , séparé 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 différents types (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)

Sortie

()
(1, 2, 3)
(1, 'Hello', 3.4)
('mouse', [8, 4, 6], (1, 2, 3))

Un tuple peut également être créé sans utiliser de parenthèses. C'est ce qu'on appelle l'emballage de tuples.

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

Sortie

(3, 4.6, 'dog')
3
4.6
dog

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 finale pour indiquer qu'il s'agit en fait d'un tuple.

my_tuple = ("hello")
print(type(my_tuple))  # <class 'str'>

# Creating a tuple having one element
my_tuple = ("hello",)
print(type(my_tuple))  # <class 'tuple'>

# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple))  # <class 'tuple'>

Sortie

<class 'str'>
<class 'tuple'>
<class 'tuple'>

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 de flotteur ou d'autres types. Cela se traduira par 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

Sortie

p
t
s
4

2. Indexation négative

Python autorise l'indexation négative pour ses séquences.

L'index de -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])

Sortie

t
p

3. Découpage

Nous pouvons accéder à une gamme 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[:])

Sortie

('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.

Modifier 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é assignés. Mais, si l'élément est lui-même un type de données mutable comme une liste, ses éléments imbriqués peuvent être modifiés.

Nous pouvons également affecter 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)

Sortie

(4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

Nous pouvons utiliser + Opérateur pour combiner deux tuples. C'est ce qu'on appelle la concaténation .

Nous pouvons également répéter les éléments d'un tuple un certain nombre de fois en utilisant le * opérateur.

Les deux + et * les opérations aboutissent à un nouveau tuple.

# Concatenation
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))

# Repeat
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3)

Sortie

(1, 2, 3, 4, 5, 6)
('Repeat', 'Repeat', 'Repeat')

Supprimer un Tuple

Comme indiqué ci-dessus, nous ne pouvons pas modifier les éléments d'un tuple. Cela signifie que nous ne pouvons pas supprimer ou supprimer des éléments d'un tuple.

Cependant, il est possible de supprimer entièrement un tuple en utilisant le mot-clé 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)

Sortie

Traceback (most recent call last):
  File "<string>", line 12, in <module>
NameError: name 'my_tuple' is not defined

Méthodes tuple

Les méthodes qui ajoutent ou suppriment des éléments ne sont pas disponibles avec tuple. Seules les deux méthodes suivantes sont disponibles.

Quelques exemples de méthodes de tuple Python :

my_tuple = ('a', 'p', 'p', 'l', 'e',)

print(my_tuple.count('p'))  # Output: 2
print(my_tuple.index('l'))  # Output: 3

Sortie

2
3

Autres opérations sur les tuples

1. Test d'adhésion à Tuple

Nous pouvons tester si un élément existe dans un tuple ou non, en utilisant le mot-clé 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)

Sortie

True
False
True

2. Itérer dans un tuple

Nous pouvons utiliser un for boucle pour parcourir chaque élément d'un tuple.

# Using a for loop to iterate through a tuple
for name in ('John', 'Kate'):
    print("Hello", name)

Sortie

Hello John
Hello Kate

Avantages de Tuple par rapport à List

Étant donné que les tuples sont assez similaires aux listes, les deux sont utilisés dans des situations similaires. Cependant, il y a certains avantages à implémenter un tuple plutôt qu'une liste. Voici quelques-uns des principaux avantages :

• Nous utilisons généralement des tuples pour les types de données hétérogènes (différents) et des listes pour les types de données homogènes (similaires).
• Puisque les tuples sont immuables, l'itération à travers un tuple est plus rapide qu'avec la liste. 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, les implémenter en tant que tuple garantira qu'elles restent protégées en écriture.

Liste Python Chaînes Python