Tuplet
Un tuple est une liste immuable. Un tuple ne peut en aucun cas être modifié une fois qu'il a été créé.
Pourquoi les tuples sont-ils nécessaires ?
- En cas de protection des données contre les modifications (intentionnelles ou accidentelles).
- Les tuples occupent moins d'espace mémoire et sont plus rapides que les listes.
- Pour renvoyer plusieurs valeurs d'une fonction.
- Les tuples peuvent être utilisés comme clés de dictionnaire (nous en reparlerons plus tard).
Créer des tuples
1 manière : comme une liste, mais avec des parenthèses
1
2
3
|
un = (1,2,3,4,5)
imprimer(type(a)) # classe 'tuple'
impression(a) # (1, 2, 3, 4, 5)
|
2 voies : en utilisant la fonction
tuple()
1
2
3
|
b = tuple((1,2,3,4,5))
impression(type(b)) # <classe 'tuple'>
impression(b) # (1, 2, 3, 4, 5)
Tu dois t'en souvenir !
- Les tuples sont une liste immuable.
- Les éléments d'un tuple peuvent être de différents types.
- Vous pouvez créer un tuple en utilisant la fonction
tuple() ou en listant les éléments entre parenthèses.
Fonctionnalités tuple
1) Vous pouvez attribuer des valeurs à un tuple sans utiliser de parenthèses/
Par exemple, vous pouvez créer un tuple comme celui-ci :
1
2
3
|
a = 1,2,3,4,5
print(a[3]) # 4 Un élément d'un tuple est accessible de la même manière qu'un élément d'une liste,
# en spécifiant l'index de l'élément entre crochets.
2) Pour déclarer un tuple qui comprend un seul élément, vous devez utiliser une virgule de fin :
1
2
3
4
|
a = 'a'
b = 'b',
print(type(b)) # <classe 'tuple>
print(type(a)) # <classe 'str'>
3) Vous pouvez affecter les valeurs des éléments du tuple à des variables individuelles :
1
2
3
|
mon_tuple = (1, 2, 3, 4, 5)
a, b, c, d, e = mon_tuple
impression(c) #3
Les traits de soulignement _ peuvent être utilisés comme variables inutiles
1
2
3
|
mon_tuple = (1, 2, 3)
a, _, _ = mon_tuple
impression(a) #1
Le nombre de variables doit correspondre au nombre des éléments du tuple !
4) Un tuple peut contenir divers éléments imbriqués. Dans ce cas, lorsque vous faites référence à des éléments imbriqués, vous devez utiliser des crochets supplémentaires
1
2
|
my_tuple = (('a', 'b', 'c'), [1, 2], ((1, 'a' ), ('b', 'c')))
print(my_tuple[2][1]) # ('b', 'c')
|
Se référant aux éléments. Tuples imbriqués
Les tuples peuvent contenir d'autres tuples en tant qu'éléments. En outre, des listes, des chaînes, etc. peuvent être utilisées comme éléments d'un tuple.
L'accès aux éléments est similaire à l'accès aux éléments d'une liste, en spécifiant l'index de l'élément entre crochets. L'indexation commence à zéro.
Lorsque vous faites référence à des éléments imbriqués, des crochets supplémentaires doivent être utilisés.
my_tuple = (('a', 'b', 'c'), [1, 2], ((1, 'a' ), ('b', 'c')))
print(my_tuple[2][1]) # ('b', 'c')
|
Comparer des tuples
Lors de la comparaison de tuples :
- les nombres sont comparés par valeur ;
- chaînes dans l'ordre lexicographique ;
- en cas d'égalité d'éléments dans les mêmes positions, les éléments suivants sont comparés ;
- la comparaison des éléments se fera jusqu'à la première inégalité ;
- lors de la comparaison, les éléments doivent être convertis dans le même type (vous ne pouvez pas comparer un nombre et une chaîne).
Exemple
1
2
3
4
5
6
7
8
9
dix
onze
12
|
A=4
B=8
C = 'a',
D = 'z',
E = (14, "maximum", "minimal")
F = (14, "maximum", "min")
K=999
impression(A < B) # Vrai
print(C < D) # Vrai
print(E > F) # Vrai
print(K < F) # Faux
print(C < K) # Erreur de type : '<' non supporté
# entre les instances de 'str' et 'int'
|
Tranches
Le découpage peut être effectué de la même manière que les listes.
Il faut se rappeler qu'en prenant un élément par index ou tranche ( slice), on ne change en rien le tuple, on en copie simplement une partie pour une utilisation ultérieure (par exemple, pour l'impression, quelques calculs, etc. .p.).
Syntaxe des tranches
my_tuple[start:stop:step] # start, stop and step
|
Concaténation de tuples
Il est possible de concaténer des tuples pour créer un nouvel objet (concaténation, similaire aux chaînes).
1
2
3
4
|
x = (1,2,3,4)
y = (5,6,7,8)
z = x + y
print(z) # (1, 2, 3, 4, 5, 6, 7, 8)
Pendant l'opération de multiplication, le tuple est répété plusieurs fois (similaire à la multiplication de chaînes).
1
2
3
|
x = (1,2,3,4)
z = x*2
print(z) # (1, 2, 3, 4, 1, 2, 3, 4)
Supprimer un tuple
Les opérations et méthodes de tuple sont similaires aux opérations et méthodes de liste. Sauf pour ceux qui changent les éléments d'un tuple.
Un élément contenu dans un tuple ne peut pas être ajouté ou supprimé en raison de son immuabilité. Cependant, le tuple lui-même peut être supprimé à l'aide de l'opérateur del.
1
2
|
étudiant = (2007, "Ivan", "Ivanov", "9-A", Faux)
de l'étudiant
|
Méthodes pour travailler avec des tuples
Les méthodes de travail avec les tuples sont similaires aux méthodes de travail avec les listes, à l'exception des méthodes qui modifient le tuple. De telles méthodes ne sont pas disponibles en raison de l'immuabilité du tuple. Ils peuvent être appliqués en créant un nouveau tuple.
Exemple de tri de tuples
Vous pouvez facilement trier un tuple en utilisant la fonction sorted().
1
2
3
4
|
un = (5, 3, 2, 1, 4)
print(trié(a)) # [1, 2, 3, 4, 5]
a = tuple(trié(a))
impression(a) # (1, 2, 3, 4, 5)
Notez que les méthodes telles que append(), extend(), remove() ne fonctionnent PAS avec les tuples et pop().
|