Listes et Dictionnaires
Listes
Initialiser et afficher des listes
Les listes sont l'équivalent des tableaux que nous avons vu en cours. La seule différence, c'est que les listes sont forcément dynamiques, et elles peuvent stocker n'importe quel type de données.
A ce titre elles sont considérées comme des containers car elles peuvent stocker des objets quelconques ou bien des références d'objets (par exemple des fonctions).
#Une liste 1D vide
listX = []
# 1 dimension
listA = [ 1,2,3,4 ]
print (len(listA)) # 4 elements
# 2 dimension matrice
listB = [ [1,2],[2,3],[4,5]]
print( listB)
# 2 dimension non symmétrique
listC = [[1,2,3], [2,1], [4]]
print( listC)
Initialiser une liste avec d'autres listes :
Construire une liste avec la fonction append() :
Voir l'execution détaillé en ligne
Pour afficher un élément dans une liste
# 1 dimension
listA = [1,2,3,4]
print( listA[0])
# 2 dimension matrice
listB = [[1,2],[2,3],[4,5]]
print( listB[1][0])
# 2 dimension non symmétrique
listC = [[1,2,3], [2,1], [4]]
print( listC[0][2])
print( listC[2][0])
Pour connaitre la taille d'une liste, on utilise la méthode len() fournie par le langage.
# 1 dimension
listA = [1,2,3,4]
print( len(listA))
# 2 dimension matrice
listB = [[1,2],[2,3],[4,5]]
print( len(listB) , "/" , len(listB[0]), "/", len(listB[1]), "/", len(listB[2]))
# 2 dimension non symmétrique
listC = [[1,2,3], [2,1], [4]]
print( len(listC))
print( len(listC[0]))
print( len(listC[1]))
print( len(listC[2]))
Opérations sur les listes
Les listes, comme beaucoup d'autres choses en python, sont des objets qui possèdent des méthodes, et des attributs.
C'est l'opérateur . qui permet d'accéder et d'appliquer des méthodes sur les objets.
Autrement dit, voici comment se présente un attribut et une méthode/fonction s'appliquant sur un objet :
- objet.attribut
- objet.methode()
Si l'objet est la liste, alors nous allons voir toutes les méthodes qui s'appliquent sur celle-ci.
Warning
La plupart de ces méthodes/fonctions ne retournent rien, et modifient la liste en place.
Modifier une liste
Par ajout à la fin ou au début
listA = [1,5,3]
listA.append(4)
print( listA)
listB = ["oeuf","jambon"]
listB.append("Frites")
print( listB)
listC = ["gerard", "paul", "albert"]
listC.append(["Eleonore",5])
print( listC)
listD = []
listD.append(1)
listD.append([2,3])
listD.append("test")
print( listD)
Par remplacement direct
Pour modifier directement un élément dans une liste :
listA = [1,5,3]
listB = ["gerard", "paul", "albert"]
listA[0] = 2
listB[1] = "Edouard"
print( listA)
print( listB)
Par remplacement via l'index
listA = [1,5,3]
# Insérer un 8 à la position 2 se fait avec la commande suivante :
listA.insert(2,8)
print( listA)
Suppression via l'index
Pour supprimer des éléments en utilisant l'indice et la fonction pop()
listA = [1,5,3]
# pop renvoie la valeur supprimé
print( "element supprimé = " , listA.pop(1))
print( "liste après suppression", listA)
listB = [[2,3],[1,4]]
print( "element supprimé = " , listB[0].pop(1))
print( "liste après suppression", listB)
Suppression via la valeur
Pour supprimer des occurence de valeurs directement avec remove()
listA = [1,5,3]
listB = [2,4,3,4]
#Enleve le chiffre 5 de la liste A
listA.remove(5)
print( listA)
# Enleve la première occurence 4 de la liste B
listB.remove(4)
print( listB)
Concatener des listes
listA = [1,5,3]
listB = [2,[4,3]]
listC = ["gerard", "paul", "albert"]
print( listA + listB)
print( listA + listC + listB)
Multiplier des listes
Trier des listes
Pour trier des listes ou des sous listes :
listA = [1,5,3]
listB = [2,4,3,4]
listC = [[3,2],[4,1]]
# Modifie la liste en place
listA.sort()
listB.sort()
listC[0].sort()
listC[1].sort()
print( listA)
print( listB)
print( listC)
Gérer la mutabilité des listes
Warning
Les listes sont dites mutables en comparaison des autres types qui sont pour la plupart du temps immutables Par mutable, il faut comprendre qu'elles sont donc modifiables en l'état, sans qu'une copie ait besoin d'être faite :
Pour modifier une liste, attention avec les variables alias en Python :
Jusqu'à présent, rien de particulier, le comportement est le même qu'avec des objets immutables.
Pour une re-assignation normale :
Dans ce cas-là, là encore le mécanisme marche, Python détecte le changement et il crée un nouvel objet de valeur 24, qu'il rattache à la variable L1
Voir l'execution détaillé en ligne
Dans ce cas là, tout est différent car nous accédons à l'intérieur de l'objet L1 sans qu'il y ait ré-affectation, il n'y a donc pas de modification de la référence comme précédemment.
L1 et L2 désigne donc toujours le même objet, donc la modification est valable pour les deux !!
Pour une modification d'un élément de l'objet liste mutable
Voyons un cas encore plus vicieux, lorsque notre liste comporte une référence vers un autre objet.
Voir l'execution détaillé en ligne
Que se passe-t-il si je modifie les éléments appartenant à L1 dans L2 ?
L2[1].append(5)
print( L1)
print( L2)
# marche aussi en modifiant L1
L1.append(8)
print( L1)
print( L2)
Voir l'execution détaillé en ligne
Surprise !* Les éléments de L1 ont été modifiés ! Donc Python accède bien à L1 dans L2 via une référence vers L1 et non pas une copie des éléments du tableau !
Si on veut éviter ce comportement, par peur de faire des erreurs, ou parce que c'est inutile, on peut indiquer à Python que l'on veut faire une copie, avec l'opérateur [:] :
Dictionnaires
Les dictionnaires sont un autre type de structures de données permettant de stocker de l'information.
A la différence des listes qui ne peuvent être accédé que par leurs indices, les dictionnaires permettent d'accéder aux données en suivant un schéma dit clef-valeur
Initialiser un dictionnaire
# Initialisation d'un dictionnaire vide
monDictionnaire1 = {}
print( monDictionnaire1)
# Initialisation d'un dictionnaire déjà rempli
monDictionnaire2 = {"pomme":2, "orange":3}
print( monDictionnaire2)
# Avec une clef numérique
monDictionnaire3 = {1:"Gauche", 2:"Droite"}
print( monDictionnaire3)
Accéder à un dictionnaire
Les dictionnaires ne sont pas des séquences comme les listes, et la clef qui détermine l'entrée dans le dictionnaire peut être numérique, caractère ou composite.
Pour lister des éléments :
monDictionnaire4 = {"pomme":2, "orange":3, "patate":2}
print( monDictionnaire4["patate"])
monDictionnaire5 = {1:"Gauche", 2:"Droite"}
print( monDictionnaire5[1])
Pour ajouter un ou des éléments dans un dictionnaire :
# Initialisation d'un dictionnaire vide
monDictionnaire6 = {}
# et remplissage
monDictionnaire6["patate"] = 3
monDictionnaire6["orange"] = 8
monDictionnaire6["citron"] = 5
print( monDictionnaire6)
# Ajout dans un dictionnaire existant
# L'ordre n'a aucune d'importance dans un dictionnaire
monDictionnaire7 = {1:"Gauche", 3:"Droite"}
monDictionnaire7[2] = "Milieu"
print( monDictionnaire7)
Pour supprimer des éléments dans un dictionnaire :
monDictionnaire8 = {"pomme":2, "orange":3, "patate":2}
del monDictionnaire8["pomme"]
print( monDictionnaire8)
Méthodes spécifiques aux dictionnaires
Pour lister toutes les clefs dans le dictionnaire
Pour lister les valeurs dans le dictionnaire
Pour tester l'existence d'une valeur dans le dictionnaire
monDictionnaire11 = {"pomme":2, "orange":3, "patate":2}
print( "Pomme" in monDictionnaire11 )
print( "pomme" in monDictionnaire11)
print( "citron" in monDictionnaire11)
et gérer les cas ou la clef n'existe pas, avec la même syntaxe in :
monDictionnaire12= {"pomme":2, "orange":3, "patate":2}
if "citrouille" not in monDictionnaire12:
print("Pas de citrouille par ici !")
Parcourir les dictionnaires
Pour parcourir seulement les clefs :
Pour parcourir seuelment les valeurs :
monDictionnaire13 = {"pomme":2, "orange":3, "patate":2}
for clef in monDictionnaire13:
print( monDictionnaire13[clef])
Pour parcourir les clefs et les valeurs en même temps :