Listes en Python: Création, Modification et Suppression

Listes en Python Création, Modification et Suppression
Listes en Python Création, Modification et Suppression

Une liste Python peut stocker un ensemble de données de toute taille et de tout type. Les programmes ont souvent besoin de stocker un grand nombre de valeurs.

Supposons, par exemple, que vous devez lire 100 numéros, calculer leur moyenne, puis savoir combien de numéros sont au-dessus de la moyenne.

Votre programme va lire les nombres et puis calculer leur moyenne, et enfin comparer chaque nombre à la moyenne pour déterminer s’il y est supérieur.

Afin d’accomplir cette tâche, tous les chiffres doivent être stockés dans des variables. C’est pourquoi, vous devez créer 100 variables et à plusieurs reprises écrire presque le même code 100 fois juste pour lire la valeur de ces 100 variables.

La rédaction d’un programme de cette façon est pénible et inutile. Alors, comment pouvez-vous résoudre ce problème?

Une approche efficace et organisée est nécessaire. Python fournit un type appelé « liste » qui stocke une collection séquentielle d’éléments.




Dans notre exemple, vous pouvez stocker tous les 100 numéros dans une liste et y accéder via une variable de type liste. La solution pourrait ressembler au code suivant.

NOMBRE_DES_ELEMENTS = 5 # Pour simplifier, utiliser 5 au lieu de 100
nombres = [] # Créer une liste vide
somme = 0

for i in range(NOMBRE_DES_ELEMENTS):
    valeur = eval(input("Entrez un nouveau numéro: "))
    nombres.append(valeur)
    somme += valeur

moyenne = somme / NOMBRE_DES_ELEMENTS

compteur = 0 # Le nombre d'éléments au-dessus de la moyenne
for i in range(NOMBRE_DES_ELEMENTS):
 	if nombres[i] > moyenne:
        compteur += 1

print("La moyenne est", moyenne)
print("Le nombre d'éléments au-dessus de la moyenne est", compteur)

Voici le résultat de l’exécution du programme ci-dessus:

Entrez un nouveau numéro: 3
Entrez un nouveau numéro: 5
Entrez un nouveau numéro: 1
Entrez un nouveau numéro: 2
Entrez un nouveau numéro: 6
La moyenne est 3.4
Le nombre d'éléments au-dessus de la moyenne est 2

Le programme crée une liste vide (ligne 2 : nombres = []). Il lit à plusieurs reprises le nombre saisi au clavier (ligne 5), l’ajoute à la liste (ligne 6), et l’ajoute à la variable « somme » (ligne 7).

Ensuite, Il calcule la moyenne dans la ligne 8 et il compare chaque valeur dans la liste avec la moyenne pour compter le nombre de valeurs supérieures à la moyenne (lignes 9-12).

Opérations de base sur les listes en Python

Une liste est une séquence définie par la classe « list ». Elle contient les méthodes de création, de manipulation et de traitement des listes. Les éléments d’une liste sont accessibles via un indice.

La classe « list » définit les listes. Pour créer une liste, vous pouvez utiliser le constructeur de classe « list », comme suit:

liste1 = list() # Créer une liste vide
liste2 = list([2, 3, 4]) # Créer une liste don't les éléments sont 2, 3 et 4
liste3 = list(["red", "green", "blue"]) # Créer une liste de chaînes de caractères
liste4 = list(range(3, 6)) # Créer une liste don't les éléments sont 3, 4 et 5
liste5 = list("abcd") # Créer une liste don't les éléments sont 'a', 'b', 'c' et 'd'

Vous pouvez également créer une liste en utilisant la syntaxe suivante, qui est un peu plus simple:

liste1 = [] # identique à list()
liste2 = [2, 3, 4] #  identique à list([2, 3, 4])
liste3 = ["red", "green"] #  identique à list(["red", "green"])

Les éléments d’une liste sont séparés par des virgules et sont entourés par une paire de crochets ([ ]).

Une liste peut contenir des éléments du même type ou de types mixtes. La liste suivante est un bon exemple:

liste4 = [2, "three", 4]

Le tableau ci-dessous résume les opérations appliquées sur les listes.

Opération Description
x in sVrai si l’élément x est dans la liste s.
x not in sVrai si l’élément x ne figure pas dans la liste s.
s1 + s2Concaténer deux listes s1 et s2.
s * n, n * sCrée une liste composée de n copies concaténées de s.
s[i]Elément d’indice i dans la liste s.
s[i : j]Tranche de la liste s dès l’indice i à l’indice j -1.
len(s)Le nombre d’éléments dans la liste s.
min(s)Le plus petit élément dans la liste s.
max(s)Le plus grand élément dans la liste s.
sum(s)Somme de tous les éléments de s.
Boucle forTraverse les éléments de la liste s de gauche à droite.
<, <=, >, >=, =, !=Compare deux listes

 

Fonctions utiles sur les listes Python: random et shuffle

Plusieurs fonctions intégrées dans Python peuvent être utilisés avec les listes.

Vous pouvez utiliser la fonction len() pour retourner le nombre d’éléments dans la liste, les fonctions max/min pour extraire les éléments avec la valeur la plus grande et la valeur la plus petite dans la liste, et la fonction sum() pour retourner la somme de tous les éléments dans la liste.

Vous pouvez également utiliser la fonction shuffle du module random pour modifier les indices des éléments de la liste aléatoirement. Voici quelques exemples:

>>> liste1 = [2, 3, 4, 1, 32]
>>> len(liste1)
5
>>> max(liste1)
32
>>> min(liste1)
1
>>> sum(liste1)
42
>>> import random
>>> random.shuffle(liste1) # modifier les indices des éléments de liste1 aléatoirement
>>> liste1
[4, 1, 2, 32, 3]
>>>

L’opérateur indice [ ]

Chaque élément dans une liste est accessible par l’opérateur indice [ ], en utilisant la syntaxe suivante:

maListe[indice]

les indices d’une liste (par exemple maListe) sont compris entre 0 et len (maListe) -1. Cela signifie que l’indice du premier élément est 0, ainsi que l’indice du dernier élément est len(maListe)-1.

L’expression maListe[indice] peut être utilisée comme une variable. elle est également connu comme une variable indexée.

Par exemple, le code suivant assigne les valeurs dans maListe[0] et maListe[1] à maListe[2].

maListe[2] = maListe[0] + maListe[1]

la boucle for suivante assigne 0 à maListe[0], 1 à maListe[1], …. et 9 à maListe[9]. La taille de maListe est 10.

for i in range(len(maListe)):
    maListe[i] = i

On peut réaliser la même chose avec la boucle suivante:

i = 0
while i < len(maListe):
   maListe[i] = i
   i += 1

L’accès à un indice hors la liste est une erreur de programmation commune qui se traduit par l’exception IndexError. Pour éviter cette erreur, assurez-vous que vous n’utilisez pas un indice au-delà de len (maList) – 1.

Python permet également l’utilisation de nombres négatifs comme indices pour faire référence aux positions des éléments par rapport à la fin de la liste. L’indice (positif) actuelle est obtenu en additionnant la longueur de la liste avec l’indice négatif. Par exemple:

>>> liste1 = [2, 3, 5, 2, 33, 21]
>>> liste1[-1]
21
>>> liste1[-3]
2
>>>

Dans la ligne 2, liste1 [-1] est identique à liste1[-1 + len (liste1)], ce qui représente le dernier élément de la liste. Dans la ligne 4, liste1[-3] est le même que liste1 [-3 + len (liste1)], ce qui représente le quatrième élément dans la liste.

Découpage en tranches (slicing) des listes Python

L’opérateur indice [ ] vous permet de sélectionner un élément don’t l’indice est spécifié entre crochets. L’opérateur de découpage en tranches retourne une tranche de la liste en utilisant la syntaxe maListe[début : fin]. La tranche est une sous-liste qui commence à l’indice début et se termine à l’indice fin – 1. Voici quelques exemples:

>>> liste1 = [2, 3, 5, 7, 9, 1]
>>> liste1[2 : 4]
[5, 7]
>>>

L’indice de début ou l’indice de fin dans une tranche peut parfois être omis. Danse ce cas, l’indice de début est 0 et l’indice de fin est len(maListe). Par exemple:

>>> liste1 = [2, 3, 5, 2, 33, 21]
>>> liste1[ : 2] # identique à liste1[0:2]
[2, 3]
>>> liste1[3 : ] # identique à liste1[3:6] (6 = len(liste1))
[2, 33, 21]
>>>

Notez que list1 [ :2] est la même que list1 [0: 2] (ligne 2), et que list1 [3:] est la même que list1 [3: len (list1)] (ligne 4).

Vous pouvez utiliser un indice négatif dans le tranchage. Par exemple:

>>> liste1 = [2, 3, 5, 2, 33, 21]
>>> liste1[1 : -3]
[3, 5]
>>> liste1[-4 : -2]
[3, 5]
>>>

Dans la ligne 2, liste1 [1: -3] est la même que liste1 [1: -3 + len (liste1)]. Dans la ligne 4, liste1 [-4: -2] est la même que liste1 [-4 + len (liste1): -2 + len (liste1)].

Si début >= fin, la sous-liste maListe[début: fin] retourne une liste vide.

Si fin > len(maListe), Python utilisera la longueur de maListe comme fin de la tranche.

Les opérateurs +, *  et in/not in

Vous pouvez utiliser l’opérateur de concaténation (+) pour joindre deux listes et l’opérateur de répétition (*) pour dupliquer une liste. Voici quelques exemples:

>>> liste1 = [2, 3]
>>> liste2 = [1, 9]
>>> liste3 = liste1 + liste2
>>> liste3
[2, 3, 1, 9]
>>>
>>> liste4 = 3 * liste1
>>> liste4
[2, 3, 2, 3, 2, 3]
>>>

Une nouvelle liste est obtenue par concaténation de liste1 avec liste2 (ligne 3). La ligne 7 duplique list1 trois fois pour créer une nouvelle liste liste4. Notez que l’expression 3 * list1 est la même que list1 * 3.

Vous pouvez déterminer si un élément est dans une liste ou pas en utilisant l’opérateur in/not in. Par exemple:

>>> liste1 = [2, 3, 5, 2, 33, 21]
>>> 2 in liste1
True
>>> 2 not in liste1
False
>>>

Parcourir les éléments d’une liste

Les éléments d’une liste en Python sont itérables. Python supporte l’utilisation de  la boucle for pour parcourir une liste sans utiliser une variable indice. Par exemple, le code suivant affiche tous les éléments dans la liste maListe:

for u in maListe:
   print(u)

Vous pouvez lire le code comme suit :

«Pour chaque élément u dans maListe, affichez-le.”

Vous devez toujours utiliser une variable indice si vous souhaitez parcourir la liste dans un ordre différent ou de modifier les éléments de la liste. Par exemple, le code suivant affiche les éléments de positions impaires.

for i in range(0, len(maListe), 2):
   print(maListe[i])

Comparer les listes en Python

Vous pouvez comparer les listes en utilisant les opérateurs de comparaison (>,> =, <, <=, == et! =). Pour que cela fonctionne, les deux listes doivent contenir le même type d’éléments.

La comparaison utilise l’ordre lexicographique: les deux premiers éléments sont comparés, et s’ils diffèrent cela détermine le résultat de la comparaison, sinon les deux éléments suivants sont comparés, et ainsi de suite, jusqu’à ce que l’une des deux listes soit épuisée. Voici quelques exemples:

>>> liste1 = ["green", "red", "blue"]
>>> liste2 = ["red", "blue", "green"]
>>> liste2 == liste1
False
>>> liste2 != liste1
True
>>> liste2 >= liste1
False
>>> liste2 > liste1
False
>>> liste2 < liste1
True
>>> liste2 <= liste1
True
>>>

Les compréhensions de listes Python

Les compréhensions de listes fournissent un moyen pour créer une liste séquentielle d’éléments. Une liste en compréhension se compose de supports contenant une expression suivie par une clause for. Voici quelques exemples:

>>> liste1 = [x for x in range(5)] # Retourne une liste de 0, 1, 2, 3, 4
>>> liste1
[0, 1, 2, 3, 4]
>>>
>>> liste2 = [0.5 * x for x in liste1]
>>> liste2
[0.0, 0.5, 1.0, 1.5, 2.0]
>>>
>>> liste3 = [x for x in liste2 if x < 1.5]
>>> liste3
[0.0, 0.5, 1.0]
>>>

Dans la ligne 1, liste1 est créée à partir d’une expression à l’aide d’une clause for. Les éléments de liste1 sont 0, 1, 2, 3 et 4. Chaque élément dans liste2 est la moitié de son élément correspondant dans list1 (ligne 5). Dans la ligne 9, liste3 comprend les nombres dont la valeur est inférieure à 1,5 de list2.

Méthodes de la classe « list »: append, count, extend, index, insert, pop, remove, reverse et sort

MéthodeDescription
append(x: objet): NoneAjoute un élément x à la fin de la liste.
count(x: objet): intRenvoie le nombre de fois l’élément x apparaît dans la liste.
extend(L: liste): NoneAjoute tous les éléments de L à la liste.
index(x: objet): intRenvoie l’indice de la première occurrence de l’élément x dans la liste.
insert(index: int, x: objet): NoneInsère un élément x à un indice donné. Notez que le premier élément de la liste a l’index 0.
pop(i): objetSupprime l’élément à un indice donné et le renvoie. Le paramètre i est facultatif. Si vous n’avez pas spécifié la valeur de i, list.pop () va supprimer et retourner le dernier élément de la liste.
remove(x: objet): NoneSupprime la première occurrence de l’élément x dans la liste.
reverse(): NoneInverse les éléments de la liste.
sort(): NoneTrie les éléments de la liste en ordre croissant.

 

Voici quelques exemples qui utilisent les méthodes append, count, extend, index et insert:

>>> liste1 = [2, 3, 4, 1, 32, 4]
>>> liste1.append(19)
>>> liste1
[2, 3, 4, 1, 32, 4, 19]
>>> liste1.count(4) # Retourne le nombre d'occurrences du chiffre 4
2
>>> liste2 = [99, 54]
>>> liste1.extend(liste2)
>>> liste1
[2, 3, 4, 1, 32, 4, 19, 99, 54]
>>> liste1.index(4) # Retourne l'indice du chiffre 4
2
>>> liste1.insert(1, 25) # Insère 25 à la position d'indice 1
>>> liste1
[2, 25, 3, 4, 1, 32, 4, 19, 99, 54]
>>>

La ligne 2 ajoute 19 à la liste, et la ligne 5 renvoie le nombre d’occurrences de l’élément 4 dans la liste. L’appel liste1.extend(liste2) (ligne 8) ajoute les éléments de la liste liste2 à la liste liste1.

La ligne 11 renvoie l’indice de l’élément 4 dans la liste, et la ligne 13 insère 25 dans la liste à la position d’indice 1.

Voici quelques exemples qui utilisent les méthodes insert, pop, remove, reverse et sort:

>>> liste1 = [2, 25, 3, 4, 1, 32, 4, 19, 99, 54]
>>> liste1.pop(2)
3
>>> liste1
[2, 25, 4, 1, 32, 4, 19, 99, 54]
>>> liste1.pop()
54
>>> liste1
[2, 25, 4, 1, 32, 4, 19, 99]
>>> liste1.remove(32) # Supprimer l'élément 32
>>> liste1
[2, 25, 4, 1, 4, 19, 99]
>>> liste1.reverse() # Inverser l'ordre des éléments dans la liste
>>> liste1
[99, 19, 4, 1, 4, 25, 2]
>>> liste1.sort() # Trier la liste
>>> liste1
[1, 2, 4, 4, 19, 25, 99]
>>>

La ligne 2 supprime l’élément d’indice 2 de la liste liste1. L’appel liste1.pop() (ligne 6) retourne et supprime le dernier élément de la liste liste1.

La ligne 10 supprime l’élément 32 de liste1, la ligne 13 inverse les éléments de la liste, et la ligne 15 trie les éléments de la liste en ordre croissant.

Fractionnement d’une chaîne de caractères en une liste

La classe str possède la méthode split() utile pour convertir une chaîne de caractères en une liste. Par défaut, la méthode split(separateur) retourne la liste de toutes les sous-chaînes de caractères séparées par la chaîne «separateur».

En cas vous n’avez pas spécifié de valeur pour le paramètre «separateur», Python utilisera comme séparateur le caractère « espace ».

Par exemple:

items = "Jane John Peter Susan".split()

fractionne la chaîne « Jane John Peter Susan » et donne comme résultat la liste [‘Jane’, ‘John’, ‘Peter’, ‘Susan’]. Dans ce cas, les éléments sont délimités par des espaces. Dans l’exemple suivant, les éléments de la date sont séparés par le caractère « ».

items = "09/20/2012".split("/")

La ligne ci-dessus fractionne la chaîne « 09/20/2012 » et donne comme résultat la liste [’09’, ’20’, ‘2012’].

Saisie d’une Liste

Vous pouvez souvent avoir besoin d’écrire du code qui lit les données saisies au clavier et les stocker dans une liste. En effet, vous pouvez demander à l’utilisateur de saisir chaque élément dans une ligne séparée et ensuite l’ajouter à une liste via une boucle for.

Par exemple, le code suivant lit dix numéros un par ligne et les insère dans une liste.

lst = [] # Créer une liste
print("Entrer 10 nombres: ")
   for i in range(10):
      lst.append(eval(input())

Parfois, il est plus commode de saisir les données sur une seule ligne séparées par des espaces. En effet, Vous pouvez utiliser la méthode split() de la classe str pour extraire les données saisies de cette façon. Par exemple, le code suivant lit dix nombres séparés espace et les stocke dans une liste.

# Lire les numéros comme une chaîne à partir de la console
s = input("Entrer 10 nombres séparés par espace: ")
items = s.split() # Extraire les éléments de la chaîne
lst = [eval(x) for x in items] # Convertir les éléments en nombres

l’appel input() lit une chaîne. L’utilisation de la fonction split() extrait les éléments délimités par des espaces de la chaîne s et stocke les éléments dans la liste items.

La dernière ligne crée une liste de numéros en convertissant les éléments de la liste items en nombres.

Simplifier le code en utilisant les listes Python

Les listes peuvent être utilisées pour simplifier considérablement l’écriture du code pour accomplir certaines tâches. Par exemple, supposons que vous souhaitez obtenir le nom anglais du mois correspondant au numéro du mois saisi au clavier.

Si les noms des mois sont stockés dans une liste, le nom du mois pour un mois donné peut être accessible simplement via son indice dans la liste. Le code suivant invite l’utilisateur à entrer un numéro de mois et ensuite affiche le nom du mois correspondant:

months = ["January", "February", "March", ..., "December"]
monthNumber = eval(input("Entrer un numéro de mois (1 to 12): "))
print("Le mois est ", months[monthNumber - 1])

En plus, on doit utiliser l’instruction if avec plusieurs clauses elif au cas où on a choisi de ne pas utiliser une liste pour stocker les noms des mois:

if monthNumber == 0:
   print("Le mois est January")
elif monthNumber == 1:
   print("Le mois est February")
...
else:
   print("Le mois est December")

Copie de listes Python

Pour copier les données d’ une liste à une autre liste, vous devez copier les éléments individuellement de la liste sources à la liste cible.

Parfois, vous avez souvent besoin de dupliquer une liste ou d’une partie d’une liste dans un programme. Dans ce cas, vous essayez d’utiliser l’instruction d’affectation (=), comme suit:

list2 = list1

mais, cette déclaration ne copie pas le contenu de la liste list1 à list2. En fait, elle copie la valeur de référence (« adresse mémoire ») de list1 dans list2. Par conséquent, list1 et list2 pointent sur la même liste et elles peuvent toutes les deux la manipuler.

Par exemple, si vous tenter d’ajouter l’élément 5 à la liste par le biais de list1 (list1.append(5)) et après vous avez tenté d’afficher le dernier élément de la même liste avec la variable list2 (print(list2[-1])), Python va afficher 5.

Ce comportement est due au fait que les variables dans Python stockent les références (« adresses mémoires ») des données et non pas les valeurs des données.

Avant l’affectation, list1 et list2 pointent sur les emplacements mémoire différent. Après l’affectation list2=list1, la valeur de référence de list1 est passé à list2.

Voici un exemple qui illustrer le concept:

>>> list1 = [1, 2]
>>> list2 = [3, 4, 5]
>>> id(list1)
36207312
>>> id(list2)
36249848
>>>
>>> list2 = list1
>>> id(list2)
36207312
>>>

Deux listes sont créées (lignes 1-2) et chacune est un objet indépendant avec un identifiant différent (lignes 4 et 6). Après avoir affecté list1 à list2, l’id de liste2 devient le même que celui de la liste list1 (la ligne 10).

list1 et list2 font référence maintenant au même objet. Pour copier des éléments de list1 dans list2, vous pouvez utiliser le code suivant:

list2 = [x for x in list1]

ou tout simplement:

list2 = [] + list1

Passer une liste Python en paramètre à une fonction

Lors du passage d’une liste en paramètre à une fonction, le contenu de la liste peut être modifié par le code de la fonction car une liste est un objet mutable.

Par exemple, la fonction suivante affiche les éléments d’une liste:

def printList(lst):
   for element in lst:
      print(element)

Vous pouvez appeler la fonction en y passant une liste en paramètre. Par exemple, l’instruction suivante appelle la fonction PrintList pour afficher 3, 1, 2, 6, 4 et 2.

printList([3, 1, 2, 6, 4, 2])

Puisqu’une liste est un objet mutable, le contenu d’une liste peut être modifié par le code de la fonction. L’exemple suivant illustre ce concept:

def main():
   x = 1 # x est une variable de type entier
   y = [1, 2, 3] # y est une liste

   m(x, y) # Appeler la fonction m avec les arguments x and y

   print("x est ", x)
   print("y[0] est ", y[0])

def m(number, numbers):
   number = 1001 # Assigner une nouvelle valeur à la variable number
   numbers[0] = 5555 # Assigner une nouvelle valeur à la variable numbers[0]

main() # Appeler la fonction main()

Voici le résultat du code ci-dessus.

x est 1
y[0] est 5555

Dans cet exemple d’exécution, vous voyez qu’après l’appel de la fonction m (ligne 5)  x a gardé sa valeur 1, mais y [0] a changé de 1 à 5555.

Puisque y contient la valeur de référence à la liste [1, 2, 3], la variable numbers contient maintenant la même valeur de référence que la variable y. Ainsi, on peut changer le contenu de la liste [1,2,3] à l’intérieur de la fonction m().

Par contre, x est un objet immuable et donc la fonction m() n’a pas pu changer sa valeur.

Une liste Python comme valeur de retour d’une fonction

Lorsqu’une fonction retourne une liste, la valeur de référence de la liste est renvoyée et non pas son contenu. Par exemple, la fonction suivante renvoie une liste qui est l’inversion d’une autre liste.

def reverse(lst):
   result = []

   for element in lst:
      result.insert(0, element)

   return result

Rechercher dans une liste Python

Si une liste est triée, une recherche dichotomique est plus efficace qu’une recherche linéaire pour trouver un élément dans la liste.

La recherche est une tâche commune dans la programmation informatique. De nombreux algorithmes sont consacrés à la recherche. Cette section traite des deux approches couramment utilisées: la recherche séquentielle et la recherche dichotomique.

Voici les codes des deux types de recherches:

def Recherche_Seq(T,x):
n=len(T)
   for i in range(n):
      if T[i]= =x :
         return True
   return False

 

def RechercheDichotomique(T,x):
   a,b = 0,len(T)-1
   while a <= b:
      m =(a+b)//2
      if T[m]==x:
         return True
      if T[m]<x:
         a=m+1
      else:
         b=m-1
   return False

 

1 COMMENTAIRE

LAISSER UN COMMENTAIRE

Please enter your comment!
Please enter your name here