devstory

Le Tutoriel de Python Lists

  1. Python List
  2. Accéder aux éléments de la liste
  3. Mettre à jour la Liste
  4. Supprimer des éléments dans la liste
  5. Les opérateurs à la base dans la liste
  6. Les fonctions de la Liste (List)
  7. Les méthodes de la Liste (list)

1. Python List

En Python, List est le type de données le plus flexible. C'est une séquence (sequence) d'éléments (element), qui vous permet de supprimer ou d'ajouter les éléments à la liste et vous permet de découper (Slice) les éléments.
Pour écrire une liste, vous devez placer les éléments dans une paire de crochets [] et les séparer par la virgule. Les éléments de la liste sont indexés (index) de gauche à droite et démarrés à partir de l'index 0.
listExample.py
fruitList = ["apple", "apricot", "banana","coconut", "lemen"]

otherList = [100, "one", "two", 3]


print ("Fruit List:")

print (fruitList)

print (" --------------------------- ")


print ("Other List:")
 

print (otherList)
Output:
Fruit List:
['apple', 'apricot', 'banana', 'coconut', 'lemen']
 ---------------------------
Other List:
[100, 'one', 'two', 3]

2. Accéder aux éléments de la liste

Accéder aux éléments
Utilisez la boucle for pour accéder aux éléments de la liste :
accessElementExample.py
fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"]

for fruit in fruitList :
    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 la liste via l'index. Les éléments de la liste sont indexés de gauche à droite et démarrés par 0.
indexAccessExample.py
fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"] 
print ( fruitList )

# Nombre des éléments.
print ("Element count: ", len(fruitList) ) 

for i in range (0, len(fruitList) ) : 
    print ("Element at ", i, "= ", fruitList[i] )
    
# Une sous - liste des éléments avec l'index de 1 à 4 (1, 2, 3)
subList = fruitList[1: 4]    

# ['apricot', 'banana', 'coconut']
print ("Sub List [1:4] ", subList )
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 List [1:4]  ['apricot', 'banana', 'coconut']
Vous pouvez également accéder aux éléments de la liste par index négatif (Negative index), les éléments sont indexés de droite à gauche avec la valeur -1, -2, ...
indexAccessExample2.py
fruitList = ["apple", "apricot", "banana", "coconut", "lemen", "plum", "pear"]

print ( fruitList )
print ("Element count: ", len(fruitList) ) 
print ("fruitList[-1]: ", fruitList[-1])
print ("fruitList[-2]: ", fruitList[-2])  
subList1 = fruitList[-4: ]
print ("\n")
print ("Sub List fruitList[-4: ] ")
print (subList1) 
subList2  = fruitList[-4:-2]
print ("\n")
print ("Sub List fruitList[-4:-2] ")
print (subList2)
Output:
['apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear']
Element count: 7
fruitList[-1]:  pear
fruitList[-2]:  plum  

Sub List fruitList[-4: ]  
['coconut', 'lemen', 'plum', 'pear']

Sub List fruitList[-4:-2]  
['coconut', 'lemen']

3. Mettre à jour la Liste

L'exemple ci - dessus est une manière de mise à jour la Liste via l'index (index):
updateListExample.py
years = [1991,1995, 1992] 
print ("Years: ", years) 
print ("Set years[1] = 2000")

years[1] = 2000

print ("Years: ", years) 
print ( years ) 

print ("Append element 2015, 2016 to list") 
# Adjoignez (append) un élément à la fin de la liste.
years.append( 2015  )
years.append( 2016  )  
print ("Years: ", years)
Output:
Years: [1991, 1995, 1992]
Set years[1] = 2000
Years: [1991, 2000, 1992]
[1991, 2000, 1992]
Append element 2015, 2016 to list
Years: [1991, 2000, 1992, 2015, 2016]
Vous pouvez également mettre à jour la valeur d'une tranche (Slide) d'éléments. C'est un moyen de vous aider à mettre à jour les multiples éléments à la fois.
Une tranche (Slice) est plusieurs éléments consécutifs dans une liste.
sliceUpdateExample.py
years =  [ 1990 ,  1991 ,  1992 ,  1993 ,  1994 ,  1995 ,  1996 ]
print ("Years: ", years)
print ("Update Slice: years[1:5] = [2000, 2001]")

years[1:5] = [ 2000 ,  2001 ]
print ("Years: ", years)
Output:
Years: [1990, 1991, 1992, 1993, 1994, 1995, 1996]
Update Slice: years[1:5] = [2000, 2001]
Years: [1990, 2000, 2001, 1995, 1996]

4. Supprimer des éléments dans la liste

Pour supprimer un ou plusieurs éléments d'une liste (list), vous pouvez utiliser l'instruction del (del statement) ou utiliser la méthode remove(). L'exemple ci-dessous utilise l'instruction del pour supprimer un ou plusieurs éléments par index.
deleteElementExample.py
years =  [ 1990 ,  1991 ,  1992 ,  1993 ,  1994 ,  1995 ,  1996 ] 
print ("Years: ", years)  
print ("\n del years[6]") 
# Supprimez l'élément à la position où l'index = 6.
del years[6] 
print ("Years: ", years)  
print ("\n del years[1:4]")

# Supprimez l'élément à la position où l'index = 1,2,3
del years[1:4]  
print ("Years: ", years)
Output:
Years: [1990, 1991, 1992, 1993, 1994, 1995, 1996]

 del years[6]
Years: [1990, 1991, 1992, 1993, 1994, 1995]

 del years[1:4]
Years: [1990, 1994, 1995]
La méthode remove(value) supprime le premier élément de la liste qui a la même valeur que la valeur du paramètre. La méthode peut lancer une exception (throw exception) si aucun élément n'est trouvé à supprimer.
removeElementExample.py
years =  [ 1990 ,  1991 ,  1992 ,  1993 ,  1994 ,  1993 ,  1993 ]
print ("Years: ", years) 
print ("\n years.remove(1993)")

# Supprimez le premier élément dont la valeur est 1993 dans la liste.
years.remove(1993)
print ("Years: ", years)
Output:
Years: [1990, 1991, 1992, 1993, 1994, 1993, 1993]

 years.remove(1993)
Years: [1990, 1991, 1992, 1994, 1993, 1993]

5. Les opérateurs à la base dans la liste

Comme la chaîne (String), List a trois opérateurs, y compris +, * , in.
Opérateur
Description
Ví dụ
+
L'opérateur sert à enchaîner (concatenate) 2 List afin de créer une nouvelle liste (List).
[1, 2, 3[ + ["One","Two"]
--> [1, 2, 3, "One", "Two"]
*
L'opérateur sert à enchaîner (concatenate) multitudes copies de la même liste et à créer une nouvelle liste
[1, 2] * 3
--> [1, 2, 1, 2, 1, 2]
in
Vérifiez si un élément est dans une liste (List), ce qui renvoie True ou False.
"Abc" in ["One", "Abc"]
--> True
listOperatorsExample.py
list1 = [1, 2, 3] 
list2 = ["One", "Two"]

print ("list1: ", list1)
print ("list2: ", list2)
print ("\n")

list12 = list1 + list2
print ("list1 + list2: ", list12)

list2x3 = list2 * 3
print ("list2 * 3: ", list2x3)

hasThree = "Three" in list2
print ("'Three' in list2? ", hasThree)
Output:
list1: [1, 2, 3]
list2: ['One', 'Two']

list1 + list2: [1, 2, 3, 'One', 'Two']
list2 * 3: ['One', 'Two', 'One', 'Two', 'One', 'Two']
'Three' in list2? False

6. Les fonctions de la Liste (List)

Fonction
Description
cmp(list1, list2)
Compare les éléments des deux listes. 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 liste avec la valeur maximale.
min(list)
Renvoie des éléments dans la liste avec la valeur minimale.
list(seq)
Convertit une tuple en liste.
listsFunctionExample.py
list1 = [1991, 1994, 1992] 
list2 = [1991, 1994, 2000, 1992]

print ("list1: ", list1)
print ("list2: ", list2)

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

# Valeur maximale dans la liste(list).
maxValue = max(list1) 
print ("Max value of list1: ", maxValue) 

# Valeur minimale dans la liste (list)
minValue = min(list1) 
print ("Min value of list1: ", minValue)

# Tuple
tuple3 = (2001, 2005, 2012) 
print ("tuple3: ", tuple3)

# Convertit un tuple en liste
list3 = list (tuple3) 
print ("list3: ", list3)
Output:
list1: [1991, 1994, 1992]
list2: [1991, 1994, 2000, 1992]
len(list1): 3
len(list2): 4
Max value of list1: 1994
Min value of list1: 1991
tuple3: (2001, 2005, 2012)
list3: [2001, 2005, 2012]
Si les éléments dans la liste (list) est du type numérique, la recherche de la valeur minimale et maximale dans la liste est compréhensible. Mais si la liste comprend des éléments du type object, nous feront des comparaisons sur la principe par défaut en Python, ou vous pouvez également une règle particulière.
Voir plus :
  • Comparing and Sorting in Python

7. Les méthodes de la Liste (list)

Méthode
Description
list.append(obj)
Adjoint (append) un objet à la liste.
list.count(obj)
Renvoie le nombre que 'obj' apparait dans la liste
ist.extend(seq)
Adjoint le contenu d'une séquence (sequence) à la liste
list.index(obj)
Renvoie l'index le plus bas dans la liste où obj apparaît.
list.insert(index, obj)
Insère l'objet dans la liste de décalage index.
list.pop([index])
Si a un paramètre d'index, supprimez et renvoyez l'élément à la position d'index. Sinon, supprimez et renvoyez le dernier élément de la liste.
Supprime l'élément dont la valeur est obj dans la liste.
list.reverse()
Renverse les objets dans la liste
list.sort(key=None, reverse=False)
Trie les éléments dans la liste par la clé (key) fournie dans des paramètres.
Exemple :
listMethodsExample.py
years =  [ 1990 ,  1991 ,  1992 ,  1993 ,  1993 ,  1993 ,  1994 ]
print ("Years: ", years)
print ("\n - Reverse the list")

# Renversez la liste.
years.reverse()
print ("Years (After reverse): ", years)

aTuple = (2001, 2002, 2003)

print ("\n - Extend: ", aTuple)
years.extend(aTuple)
print ("Years (After extends): ", years)
print ("\n - Append 3000")
years.append(3000)

print ("Years (After appends): ", years)

print ("\n - Remove 1993")
years.remove(1993)
print ("Years (After remove): ", years) 
 
print ("\n - years.pop()")

# Supprimez le dernier élément de la liste.
lastElement = years.pop()

print ("last element: ", lastElement) 
print ("\n") 
# Count 
print ("years.count(1993): ",years.count(1993) )
Output:
Years: [1990, 1991, 1992, 1993, 1993, 1993,1994]

 - Reverse the list
Years (After reverse): [1994, 1993, 1993, 1993, 1992, 1991, 1990]

 - Extend: (2001, 2002, 2003)
Years (After extends):  [1994, 1993, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003]

 - Append 3000
Years (After appends):  [1994, 1993, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003, 3000]

 - Remove 1993
Years (After remove):  [1994, 1993, 1993, 1992, 1991, 1990, 2001, 2002, 2003, 3000]

 - years.pop(2001)
last element:  3000

years.count(1993): 2
Voir plus :
  • Comparing and Sorting in Python

Articles les plus récents

Show More