Tupple (Tuple) en Python

Python中的元组类似于Les tuples en Python sont similaires àliste

. La différence entre eux est que, une fois un tuple assigné, ses éléments ne peuvent pas être modifiés, tandis que dans une liste, les éléments peuvent être modifiés.

Créer un tuple

parmi lesquels tous les éléments (éléments) sont placés entre des parenthèses () (séparés par des virgules). Les parenthèses sont optionnelles, mais, l'utilisation de parenthèses est une bonne habitude.Les tuples peuvent avoir un nombre arbitraire d'éléments et peuvent contenir différents types (entiers, nombres à virgule flottante, listes,chaîne

等).

Il est également possible de créer un tuple sans utiliser de parenthèses. Cela s'appelle l'emballage de tuple.

C'est un peu spécial de créer un tuple avec un seul élément.

Un tuple avec un seul élément, il n'est pas suffisant de l'encadrer dans des parenthèses. Nous avons besoin d'une virgule pour indiquer qu'il s'agit en réalité d'un tuple.
my_tuple = ("hello")
print(type(my_tuple))  # <class 'str'>
# Création d'un tuple avec un seul élément　　
my_tuple = "hello",　
my_tuple = ("hello",)
# Les parenthèses sont optionnelles
my_tuple = "hello",

print(type(my_tuple)) # <class 'tuple'>

Accéder aux éléments d'un tuple

1Nous pouvons accéder aux éléments d'un tuple de plusieurs manières.

.index

nous pouvons utiliser l'opérateur d'index [] pour accéder aux éléments d'un tuple dont l'index commence à 0.6un tuple avec5un tuple d'un élément aura des indices allant de 0 à6de l'index. Essayez d'accéder à un élément en dehors du tuple (par exemple7 ,

... ) déclenchera un IndexError.

L'index doit être un entier ; par conséquent, nous ne pouvons pas utiliser de float ou d'autres types. Sinon, cela provoquera un TypeError.

my_tuple = ('p','e','r','m','i','t')
De même, pour accéder aux éléments d'un tuple imbriqué en utilisant une indexation imbriquée, comme dans l'exemple suivant.　
# Sortie : (i, z)5print(my_tuple[0])  # 'p'
])  # 't'
# IndexError: L'index est en dehors de la plage de la liste6, [
# print(my_tuple[
# L'index doit être un entier
# Erreur de type : l'objet 'tuple' ne prend pas en charge l'affectation d'éléments2# TypeError: L'index d'une liste doit être un entier, pas un nombre à virgule flottante
# Tuple imbriquée
n_tuple = ("mouse", [8,　4,　6], (1,　2,　3))
# Indexation imbriquée
print(n_tuple[0][3])  # 's'
print(n_tuple[1][1])  #　4

2.index négative

Python permet une indexation négative sur ses séquences.

index-1représente l'élément dernier,-2représente l'élément avant-dernier, et ainsi de suite.

my_tuple = ('p','e','r','m','i','t')
# Sortie: 't'
# Sortie : (i, z)-1, [
# Sortie: 'p'
# Sortie : (i, z)-6, [

3.slicing

.slicing-Nous pouvons utiliser l'opérateur

my_tuple = ('p','r','o','g','r','a','m','i','z')
print(my_tuple[:2Un point d'interrogation “:” permet d'accéder à une série de projets dans un tuple.-4éléments
# Un élément
# Sortie : (i, z)1# Sortie : (r, o, g)4, [
:
# De début à l'élément deux
# Sortie : (p, r)-7, [
print(my_tuple[:8# Le
# Un élément à la fin
# Sortie : (i, z)7print(my_tuple[
:])
# Un tuple peut être réaffecté
# Éléments de début à la fin

print(my_tuple[:])

En considérant l'index entre les éléments, il est possible de visualiser au mieux les tranches, comme indiqué ci-dessous. Par conséquent, pour accéder à une plage, il faut utiliser les indices des tranches partielles du tuple.

Changement de 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 affectés. Cependant, si les éléments eux-mêmes sont de types de données variables (comme des listes), leurs éléments imbriqués peuvent être modifiés.

Nous pouvons également affecter un tuple à différentes valeurs (réaffectation).4,　2,　3# Sortie : (6,　5, [
my_tuple = (
# Erreur de type : l'objet 'tuple' ne prend pas en charge l'affectation d'éléments1# my_tuple[　9
] =
# Cependant, les éléments variables peuvent être modifiés3my_tuple[　9　　　　][0] =4,　2,　3# Sortie : (9,　5, [
print(my_tuple)
])
my_tuple = ('p','r','o','g','r','a','m','i','z')
# Un tuple peut être réaffecté
print(my_tuple)

# Sortie : (p, r, o, g, r, a, m, i, z)+Nous pouvons utiliserl'opérateur pour fusionner deux tuples. Cela s'appelle égalementConcaténation

.*Nous pouvons également utiliser l'opérateur，répéter les éléments du tupleRépéter

à une fréquence donnée.+et*Cette opération entraîne un nouveau enregistrement.

# Concaténation
# Sortie : (1,　2,　3,　4,　5,　6)
print(((1,　2,　3)　+　(4,　5,　6))
# Répétition
# Sortie : (Repeat, Repeat, Repeat)
print(("Repeat",)　*　3)

Suppression du tuple

Comme mentionné précédemment, nous ne pouvons pas modifier les éléments d'un tuple. Cela signifie également que nous ne pouvons pas supprimer ou supprimer des éléments du tuple.

Cependant, vous pouvez utiliser le mot-clédelSupprimer complètement un tuple.

my_tuple = ('p','r','o','g','r','a','m','i','z')
# Il n'est pas possible de supprimer des éléments
# Erreur de type : l'objet 'tuple' ne prend pas en charge la suppression d'éléments
# del my_tuple[3]
# Il est possible de supprimer tout le tuple
del my_tuple
# Erreur de nom : nom non défini “my_tuple”
print(my_tuple)

Tuple methods

Tuples do not provide methods to add or delete items. 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

Other tuple operations

1.Membership testing of tuple members

We can use the keyword 'in' to test if an item exists in the tuple.

my_tuple = ('a', 'p', 'p', 'l', 'e',)
# In operation
# Output: True
print('a' in my_tuple)
# Output: False
print('b' in my_tuple)
# Not in operation
# Output: True
print('g' not in my_tuple)

2.Traversal of tuples

Using a for loop, we can iterate over each item in a tuple.

# Output:　
# Hello John
# Hello Kate
for name in ('John', 'Kate'):
　　　　　print("Hello", name)

Advantages of tuples over lists

Since tuples are very similar to lists, they are also used in similar situations.

However, implementing tuples on lists has certain advantages. The following lists some of the main advantages:

• We usually use tuples for heterogeneous (different) data types and lists for homogeneous (similar) data types.

• Since tuples are immutable, iterating over a tuple is faster than using a list. Therefore, there is a slight performance improvement.

• Tuples containing immutable elements can be used as dictionary keys. This is not possible for lists.

• If you have immutable data, implementing it as a tuple will ensure it remains write-protected.