Le Tutoriel de Python Tuples

Python Tuples
Comparaison entre List et Tuple
Accéder aux éléments de Tuples
Mettre à jour Tuples
Des opérateurs de Tuples
Des fonctions de Tuples
Des méthodes

1. Python Tuples

En Python, Tuples est une séquence (sequence) de valeurs contenant de nombreux éléments (element), similaire à List (la liste). Contrairement à la liste, Tuples est un type de données immuables (immutable), toutes les mises à jour sur le Tuple créent une nouvelle entité dans la mémoire (memory).

Pour écrire un Tuple, vous devez mettre les éléments entre parenthèses () et les séparer par une virgule. Ces éléments de la liste sont indexés avec l'index (index) de 0.

tupleExample.py

fruitTuple = ("apple", "apricot", "banana","coconut", "lemen")
otherTuple = (100, "one", "two", 3)
print ("Fruit Tuple:")
print (fruitTuple)
print (" --------------------------- ")
print ("Other Tuple:")
print (otherTuple)

Output:

Fruit Tuple:
('apple', 'apricot', 'banana', 'coconut', 'lemen')
 ---------------------------
Other List:
(100, 'one', 'two', 3)

2. Comparaison entre List et Tuple

Voir plus :
Le Tutoriel de Python Lists

List et Tuple sont une séquence (sequence) des éléments. Elles sont des différences comme suivantes :

Lorsque vous écrivez une List, vous utilisez utiliser des crochets [], mais vous utilisez des parenthèses () en écrivant une Tuple.

# Voici est une Tuple.
aTuple = ("apple", "apricot", "banana")

# Voici est une List (une liste).
aList =  ["apple", "apricot", "banana"]

La liste est un type de données modifiable (mutable), vous pouvez utiliser la méthode append() pour ajouter l'élément à List ou utiliser la méthode remove() pour supprimer des éléments de List sans créer d'autre entité 'List' sur la mémoire.

listMemoryTest.py

list1 =  [1990, 1991, 1992] 
print ("list1: ", list1)

# L'addresse de la list1 sur la mémoire.
list1Address = hex ( id(list1) ) 
print ("Address of list1: ", list1Address ) 
print ("\n")
print ("Append element 2001 to list1")

# Adjoignez (append) un élément à la list1.
list1.append(2001) 
print ("list1 (After append): ", list1)

# L'addresse de la list1 sur la mémoire.
list1Address = hex ( id(list1) ) 
print ("Address of list1 (After append): ", list1Address )

Tuple est un objet immuable (immutable), elle n'a pas les méthodes append(), remove(), ... comme list. Vous pouvez penser que certaines méthodes, ou opérateurs sont utilisés pour mettre à jour Tuple mais le fait qu'elle est basée sur la Tuple originale pour créer une nouvelle Tuple.

tupleMemoryTest.py

tuple1 =  (1990, 1991, 1992)

# L'adresse de tuple1 sur la mémoire.
tuple1Address = hex ( id(tuple1) ) 
print ("Address of tuple1: ", tuple1Address )

# Adjoignez une tuple à la tuple1.
tuple1 = tuple1 + (2001, 2002)

# L'adresse de tuple1 sur la mémoire.
tuple1Address = hex ( id(tuple1) )  
print ("Address of tuple1 (After concat): ", tuple1Address )

Output:

Address of tuple1: 0x9096751d80
Address of tuple1 (After concat): 0x9096778f10

3. Accéder aux éléments de Tuples

Accéder aux éléments

Utilisez la boucle for pour accéder aux éléments de Tuple:

elementAccessExample.py

fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear")

for fruit in fruits :
    print ("Fruit: ", fruit)

Output:

Fruit: apple
Fruit: apricot
Fruit: banana
Fruit: coconut
Fruit: lemen
Fruit: plum
Fruit: pear

Accéder via l'index (index):

Vous pouvez également accéder aux éléments de Tuple via l'index. Les éléments de Tuple sont indexés de gauche à droit, à partir de 0.

indexAccessExample.py

fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear") 
print ( fruits )

# Le nombre des éléments.
print ("Element count: ", len(fruits) ) 

for i in range (0, len(fruits) ) : 
    print ("Element at ", i, "= ", fruits[i] )
    
# Une sous Tuple comprend des éléments indexés de 1 à 4 (1, 2, 3)
subTuple = fruits[1: 4]    
# ('apricot', 'banana', 'coconut')
print ("Sub Tuple [1:4] ", subTuple )

Output:

('apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear')
Element count: 7
Element at 0 = apple
Element at 1 = apricot
Element at 2 = banana
Element at 3 = coconut
Element at 4 = lemen
Element at 5 = plum
Element at 6 = pear
Sub Tuple [1:4]  ('apricot', 'banana', 'coconut')

Vous pouvez également accéder aux éléments de Tuple via l'index négatif (Negative index), les éléments sont indexés de droite à gauche avec les valeurs -1, -2, ...

indexAccessExample2.py

fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear")
print ( fruits )
print ("Element count: ", len(fruits) )

print ("fruits[-1]: ", fruits[-1])
print ("fruits[-2]: ", fruits[-2]) 
subTuple1 = fruits[-4: ]

print ("\n")
print ("Sub Tuple fruits[-4: ] ")
print (subTuple1) 
subTuple2  = fruits[-4:-2]
print ("\n")
print ("Sub Tuple fruits[-4:-2] ")
print (subTuple2)

Output:

('apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear')
Element count: 7
fruitList[-1]:  pear
fruitList[-2]:  plum  
 
Sub Tuple fruits[-4: ]  
('coconut', 'lemen', 'plum', 'pear')

Sub Tuple fruits[-4:-2]  
('coconut', 'lemen')

4. Mettre à jour Tuples

Notez que Tuple est immutable (immutable), donc elle a uniquement des méthodes ou des opérateurs à accéder ou à créer une nouvelle Tuple à partir l'originale Tuple.

updateTupleExample.py

tuple1 = (1990, 1991, 1992) 
print ("tuple1: ", tuple1)  
print ("Concat (2001, 2002) to tuple1") 
 
tuple2 = tuple1 + (2001, 2002)  
print ("tuple2: ", tuple2)

# Une sous Tuple contient des éléments indexés de 1 à 4 (1,2,3)
tuple3 = tuple2[1:4] 
print ("tuple2[1:4]: ", tuple3)

# Une sous Tuple contient des éléments de l'index 1 à la fin.
tuple4 = tuple2[1: ] 
print ("tuple2[1: ]: ", tuple4)

Output:

tuple1: (1990, 1991, 1992)
Concat (2001, 2002) to tuple1
tuple2: (1990, 1991, 1992, 2001, 2002)
tuple2[1:4]: (1991, 1992, 2001)
tuple2[1: ]: (1991, 1992, 2001, 2002)

5. Des opérateurs de Tuples

Comme la chaine (String), Tuple a 3 éléments +, * , in.

Toán tử	Mô tả	Ví dụ
+	L'opérateur sert à enchaîner (concatenate) 2 Tuple afin de créer une nouvelle Tuple	(1, 2, 3) + ("One","Two") --> (1, 2, 3, "One", "Two")
*	L'opérateur sert à enchaîner (concatenate) multitudes Tuple de la même liste et à créer une nouvelle Tuple	(1, 2) * 3 --> (1, 2, 1, 2, 1, 2)
in	Vérifiez si un élément est dans une Tuple, ce qui renvoie True ou False.	"Abc" in ("One", "Abc") --> True

tupleOperatorsExample.py

tuple1 = (1, 2, 3)
tuple2 = ("One", "Two")
print ("tuple1: ", tuple1)
print ("tuple2: ", tuple2)
print ("\n")

tuple12 = tuple1 + tuple2
print ("tuple1 + tuple2: ", tuple12)
tuple2x3 = tuple2 * 3
print ("tuple2 * 3: ", tuple2x3)
hasThree = "Three" in tuple2
print ("'Three' in tuple2? ", hasThree)

Output:

tuple1: (1, 2, 3)
tuple2: ('One', 'Two')

tuple1 + tuple2: (1, 2, 3, 'One', 'Two')
list2 * 3: ('One', 'Two', 'One', 'Two', 'One', 'Two')
'Three' in tuple2? False

6. Des fonctions de Tuples

Fonction	Description
cmp(list1, list2)	Compare les éléments des deux Tuples. Cette fonction a été supprimée de Python3.
len(list)	Renvoie le nombre des éléments de la liste
max(list)	Renvoie des éléments dans la Tuple avec la valeur maximale.
min(list)	Renvoie des éléments dans la Tuple avec la valeur minimale
tuple(seq)	Convertit une liste en Tuple.

tupleFunctionsExample.py

tuple1 = (1991, 1994, 1992)
tuple2 = (1991, 1994, 2000, 1992)
print ("tuple1: ", tuple1)
print ("tuple2: ", tuple2)

# Renvoie le nombre d'éléments.
print ("len(tuple1): ", len(tuple1) )
print ("len(tuple2): ", len(tuple2) )

# Valeur maximale dans la Tuple.
maxValue = max(tuple1)
print ("Max value of tuple1: ", maxValue)

# Valeur minimale dans la Tuple
minValue = min(tuple1)
print ("Min value of tuple1: ", minValue)

# (all)
# List
list3 = [2001, 2005, 2012]
print ("list3: ", list3)

# Convertit une liste en tuple
tuple3 = tuple (list3)
print ("tuple3: ", tuple3)

Output:

tuple1: (1991, 1994, 1992)
tuple2: (1991, 1994, 2000, 1992)
len(tuple1): 3
len(tuple2): 4
Max value of tuple1: 1994
Min value of tuple1: 1991
list3: [2001, 2005, 2012]
tuple3: (2001, 2005, 2012)

Voir plus :
Comparing and Sorting in Python

7. Des méthodes

Phương thức	Mô tả
tuple.count(obj)	Renvoie le nombre que 'obj' apparait dans Tuple
tuple.index(obj, [start, [stop]])	Renvoie l'index le plus petit dans Tuple que obj affiche. Lance ValueError si la valeur n'est pas trouvée. S'il y a des paramètres de start, stop, il suffit de chercher du start à la stop de l'index (Et pas de stop inclus).

Exemple :

tupleMethodsExample.py

years =  ( 1990 ,  1991 ,  1993 ,  1991 ,  1993 ,  1993 ,  1993 )
print ("Years: ", years)
print ("\n") 

# Renvoyez le nombre d'occurrences de 1993
print ("years.count(1993): ",years.count(1993) ) 

# Trouvez l'index qui apparaît 1993
print ("years.index(1993): ", years.index(1993) )

# Trouvez l'index qui apparaît 1993, à partir de l'index 3
print ("years.index(1993, 3): ", years.index(1993, 3) )

# Trouvez l'index qui apparaît 1993, de l'index 4 à 5 (Non inclus 6)
print ("years.index(1993, 4, 6): ", years.index(1993, 4, 6) )

Output:

Years: (1990, 1991, 1993, 1991, 1993, 1993, 1993)

years.count(1993): 4
years.index(1993): 2
years.index(1993, 3): 4
years.index(1993, 4, 6): 4

Voir plus:
Comparing and Sorting in Python

Le Tutoriel de Python Tuples

1. Python Tuples

2. Comparaison entre List et Tuple

3. Accéder aux éléments de Tuples

Accéder via l'index (index):

4. Mettre à jour Tuples

5. Des opérateurs de Tuples

6. Des fonctions de Tuples

7. Des méthodes

Tutoriels de programmation Python

Tutoriels de programmation Python

Articles les plus récents