3 Structures

Python dispose de plusieurs structures différentes intégrées de base. Nous allons aborder dans cette partie quelques unes d’entre-elles : les listes, les N-uplet (ou tuples), les ensembles et les dictionnaires.

3.1 Listes

Une des structures les plus flexibles en Python est la liste. Il s’agit d’un regroupement de valeurs. La création d’une liste s’effectue en écrivant les valeurs en les séparant par une virgule et en entourant l’ensemble par des crochets ([ et ]).

x = ["Pascaline", "Gauthier", "Xuan", "Jimmy"]
print(x)
## ['Pascaline', 'Gauthier', 'Xuan', 'Jimmy']

Le contenu d’une liste n’est pas forcément du texte :

y = [1, 2, 3, 4, 5]
print(y)
## [1, 2, 3, 4, 5]

Il est même possible de faire figurer des éléments de type différent dans une liste :

z = ["Piketty", "Thomas", 1971]
print(z)
## ['Piketty', 'Thomas', 1971]

Une liste peut contenir une autre liste :

tweets = ["aaa", "bbb"]
followers = ["Anne", "Bob", "Irma", "John"]
compte = [tweets, followers]
print(compte)
## [['aaa', 'bbb'], ['Anne', 'Bob', 'Irma', 'John']]

3.1.1 Extraction des éléments

L’accès aux éléments se fait grace à son indexation (attention, l’indice du premier élément est 0) :

print(x[0]) # Le premier élément de x
## Pascaline
print(x[1]) # Le second élément de x
## Gauthier

L’accès à un élément peut aussi se faire en parant de la fin, en faisant figurer le signe moins (-) devant l’indice : L’accès aux éléments se fait grace à son indexation (attention, l’indice du premier élément est 0) :

print(x[-1]) # Le dernier élément de x
## Jimmy
print(x[-2]) # L'avant dernier élément de x
## Xuan

Le découpage d’une liste de manière à obtenir un sous-ensemble de la liste s’effectue avec les deux points (:) :

print(x[1:2]) # Les premiers et seconds éléments de x
## ['Gauthier']
print(x[2:]) # Du second (non inclus) à la fin de x
## ['Xuan', 'Jimmy']
print(x[:-2]) # Du premier à l'avant dernier (non inclus)
## ['Pascaline', 'Gauthier']
Le découpage retourne également une liste.

Lors de l’extraction des éléments de la liste à l’aide des crochets, il est possible de rajouter un troisième paramètre, le pas :

print(x[::2]) # Un élément sur deux
## ['Pascaline', 'Xuan']

L’accès à des listes imbriquées s’effectue en utilisant plusieurs fois les crochets :

tweets = ["aaa", "bbb"]
followers = ["Anne", "Bob", "Irma", "John"]
compte = [tweets, followers]
res = compte[1][3] # Le 4e élément du 2e élément de la liste compte

Le nombre d’éléments d’une liste s’obtient avec la fonction len() :

print(len(compte))
## 2
print(len(compte[1]))
## 4

3.1.2 Modification

Les listes sont mutables, c’est-à-dire que leur contenu peut être modifié une fois l’objet créé.

3.1.2.1 Remplacement

Pour modifier un élément dans une liste, on utilise l’indiçage :

x = [1, 3, 5, 6, 9]
x[3] = 7 # Remplacement du 4e élément
print(x)
## [1, 3, 5, 7, 9]

3.1.2.2 Ajout d’éléments

Pour ajouter des éléments à une liste, on utilise la méthode append() :

x.append(11) # Ajout de la valeur 11 en fin de liste
print(x)
## [1, 3, 5, 7, 9, 11]

Il est aussi possible d’utiliser la méthode extend(), pour concaténer des listes :

y = [13, 15]
x.extend(y)
print(x)
## [1, 3, 5, 7, 9, 11, 13, 15]

3.1.2.3 Suppression d’éléments

Pour retirer un élément d’une liste, on utilise la méthode remove() :

x.remove(3) # Retire le 4e élément
print(x)
## [1, 5, 7, 9, 11, 13, 15]

On peut aussi utiliser la commande del :

x = [1, 3, 5, 6, 9]
del x[3] # Retire le 4e élément
print(x)
## [1, 3, 5, 9]

3.1.2.4 Affectations multiples

On peut modifier plusieurs valeurs en même temps :

x = [1, 3, 5, 6, 10]
x[3:5] = [7, 9] # Remplace les 4e et 5e valeurs
print(x)
## [1, 3, 5, 7, 9]

La modification peut agrandir la taille de la liste :

x = [1, 2, 3, 4, 5]
x[2:3] = ['a', 'b', 'c', 'd'] # Remplace la 3e valeur
print(x)
## [1, 2, 'a', 'b', 'c', 'd', 4, 5]

On peut supprimer plusieurs valeurs en même temps :

x = [1, 2, 3, 4, 5]
x[3:5] = [] # Retire les 4e et 5e valeurs
print(x)
## [1, 2, 3]

3.1.3 Test d’appartenance

En utilisant l’opérateur in, on peut tester l’appartenance d’un objet à une liste :

x = [1, 2, 3, 4, 5]
print(1 in x)
## True

3.1.4 Copie de liste

Attention, la copie d’une liste n’est pas triviale en Python. Prenons un exemple.

x = [1, 2, 3]
y = x

Modifions le premier élément de y, et observons le contenu de y et de x :

y[0] = 0
print(y)
## [0, 2, 3]
print(x)
## [0, 2, 3]

Comme on peut le constater, le fait d’avoir utilisé le signe égal a simplement créé une référence et non pas une copie.

Pour effectuer une copie de liste, plusieurs façons existent. Parmi elles, l’utilisation de la fonction list() :

x = [1, 2, 3]
y = list(x)
y[0] = 0
print("x : ", x)
## x :  [1, 2, 3]
print("y : ", y)
## y :  [0, 2, 3]

On peut noter que lorsque l’on fait un découpement, un nouvel objet est créé, pas une référence :

x = [1, 2, 3, 4]
y = x[:2]
y[0] = 0
print("x : ", x)
## x :  [1, 2, 3, 4]
print("y : ", y)
## y :  [0, 2]

3.1.5 Tri

Pour trier les objets de la liste (sans en créer une nouvelle), Python propose la méthode sort() :

x = [2, 1, 4, 3]
x.sort()
print(x)
## [1, 2, 3, 4]

Cela fonctionne également avec des valeurs textuelles, en triant par ordre alphabétique :

x = ["c", "b", "a", "a"]
x.sort()
print(x)
## ['a', 'a', 'b', 'c']

Il est possible de fournir à la méthode sort() des paramètres. Parmi ces paramètres, il en est un, key, qui permet de fournir une fonction pour effectuer le tri. Cette fonction doit retourner une valeur pour chaque objet de la liste, sur laquelle le tri sera effectué. Par exemple, avec la fonction len(), qui, lorsqu’appliquée à du texte, retourne le nombre de caractères :

x = ["aa", "a", "aaaaa", "aa"]
x.sort(key=len)
print(x)
## ['a', 'aa', 'aa', 'aaaaa']

3.2 N-uplets (Tuples)

Les n-uplets, ou tuples sont des séquences d’objets Python.

Pour créer un n-uplet, on liste les valeurs, séparées par des virgules :

x = 1, 4, 9, 16, 25
print(x)
## (1, 4, 9, 16, 25)

On note que les n-uplets sont repérés par une suite de valeurs, entourées dans deux parenthèses.

3.2.1 Extraction des éléments

Les éléments d’un n-uplet s’extraient de la même manière que ceux des listes (c.f. Section 3.1.1).

print(x[0])
## 1

3.2.2 Modification

Contrairement aux listes, les n-uplets sont inaltérables (c’est-à-dire ne pouvant pas être modifés après avoir été créés) :

x[0] = 1
## TypeError: 'tuple' object does not support item assignment
## 
## Detailed traceback: 
##   File "<string>", line 1, in <module>

Il est possible d’imbriquer des n-uplets à l’intérieur d’un autre n-uplet. Pour ce faire, on a recours à l’utilisation de parenthèses :

x = ((1, 4, 9, 16), (1, 8, 26, 64))
print(x)
## ((1, 4, 9, 16), (1, 8, 26, 64))

3.3 Ensembles

Les ensembles (sets) sont des collections non ordonnée d’éléments uniques. Les ensembles sont inaltérables, et non indexés.

Pour créer un ensemble, Python fournit la fonction set(). On fournit un ou plusieurs éléments constituant l’ensemble, en les séparant par des virgules et en entourant l’ensemble d’accolades ({}) :

ensemble = set({"Marseille", "Aix-en-Provence", "Nice", "Rennes"})
print(ensemble)
## {'Nice', 'Aix-en-Provence', 'Marseille', 'Rennes'}

De manière équivalent, on peut ne pas utiliser la fonction set() et définir l’ensemble uniquement à l’aide des crochets :

ensemble = {"Marseille", "Aix-en-Provence", "Nice", "Rennes"}
print(ensemble)
## {'Nice', 'Aix-en-Provence', 'Marseille', 'Rennes'}

En revanche, si l’ensemble est vide, Python retourne un erreur si la fonction set() n’est pas utilisée : il est nécessaire d’utiliser la fonction set :

ensemble_vide = {}
type(ensemble_vide)

Le type de l’objet que l’on vient de créer n’est pas set mais dict (c.f. Section 3.4). Aussi, pour créer l’ensemble vide, on utilise set() :

ensemble_vide = set()
print(type(ensemble_vide))
## <class 'set'>

Lors de la création, s’il existe des doublons dans les valeurs fournies, ils seront supprimés pour ne garder qu’une seule valeur :

ensemble = set({"Marseille", "Aix-en-Provence", "Nice", "Marseille", "Rennes"})
print(ensemble)
## {'Nice', 'Aix-en-Provence', 'Marseille', 'Rennes'}

La longueur d’un ensemble s’obtient à l’aide de la fonction len() :

print(len(ensemble))
## 4

3.3.1 Modifications

3.3.1.1 Ajout

Pour ajouter un élément à un ensemble, Python offre la méthode add() :

ensemble.add("Toulon")
print(ensemble)
## {'Marseille', 'Rennes', 'Toulon', 'Nice', 'Aix-en-Provence'}

Si l’élément est déjà présent, il ne sera pas ajouté :

ensemble.add("Toulon")
print(ensemble)
## {'Marseille', 'Rennes', 'Toulon', 'Nice', 'Aix-en-Provence'}

3.3.1.2 Suppression

Pour supprimer une valeur d’un ensemble, Python propose la méthode remove() :

ensemble.remove("Toulon")
print(ensemble)
## {'Marseille', 'Rennes', 'Nice', 'Aix-en-Provence'}

Si la valeur n’est pas présente dans l’ensemble, Python retourne un message d’erreur :

ensemble.remove("Toulon")
## KeyError: 'Toulon'
## 
## Detailed traceback: 
##   File "<string>", line 1, in <module>
print(ensemble)
## {'Marseille', 'Rennes', 'Nice', 'Aix-en-Provence'}

3.3.2 Test d’appartenance

Un des intérêts des ensembles est la recherche rapide de présence ou absence de valeurs (plus rapide que dans une liste). Comme pour les listes, les tests d’appartenance s’effectuent à l’aide de l’opérateur in :

print("Marseille" in ensemble)
## True
print("Paris" in ensemble)
## False

3.3.3 Copie d’ensemble

Pour copier un ensemble, comme pour les listes (c.f. Section 3.1.4), il ne faut pas utiliser le signe d’égalité. La copie d’un ensemble se fait à l’aide de la méthode copy() :

ensemble = set({"Marseille", "Aix-en-Provence", "Nice"})
y = ensemble.copy()
y.add("Toulon")
print("y : ", y)
## y :  {'Nice', 'Aix-en-Provence', 'Toulon', 'Marseille'}
print("ensemble : ", ensemble)
## ensemble :  {'Nice', 'Aix-en-Provence', 'Marseille'}

3.3.4 Conversion en liste

Un des intérêts des ensembles est est qu’ils contiennent des éléments uniques. Aussi, lorsque l’on souhaite obtenir les éléments distincts d’une liste, il est possible de la convertir en ensemble (avec la fonction set()), puis de convertir l’ensemble en liste (avec la fonction list()) :

ma_liste = ["Marseille", "Aix-en-Provence", "Marseille", "Marseille"]
print(ma_liste)
## ['Marseille', 'Aix-en-Provence', 'Marseille', 'Marseille']
mon_ensemble = set(ma_liste)
print(mon_ensemble)
## {'Aix-en-Provence', 'Marseille'}
ma_nouvelle_liste = list(mon_ensemble)
print(ma_nouvelle_liste)
## ['Aix-en-Provence', 'Marseille']

3.4 Dictionnaires

Les dictionnaires en Python sont une implémentation d’objets clé-valeurs, les clés étant indexées.

Les clés sont souvent du texte, les valeurs peuvent être de différents types et différentes structures.

Pour créer un dictionnaire, on peut procéder en utilisant des accolades ({}). Comme rencontré dans la Section 3.3, si on évalue le code suivant, on obtient un dictionnaire :

dict_vide = {}
print(type(dict_vide))
## <class 'dict'>

Pour créer un dictionnaire avec des entrée, on peut utiliser les accolades, on sépare chaque entrée par des virgules, et on distingue la clé de la valeur associée par deux points (:) :

mon_dict = { "nom": "Kyrie",
  "prenom": "John",
  "naissance": 1992,
  "equipes": ["Cleveland", "Boston"]}
print(mon_dict)
## {'nom': 'Kyrie', 'prenom': 'John', 'naissance': 1992, 'equipes': ['Cleveland', 'Boston']}

Il est aussi possible de créer un dictionnaire à l’aide de la fonction dict(), en fournissant une séquence de clés-valeurs :

x = dict([("Julien-Yacine", "Data-scientist"),
  ("Sonia", "Directrice")])
print(x)
## {'Julien-Yacine': 'Data-scientist', 'Sonia': 'Directrice'}

3.4.1 Extraction des éléments

L’extraction dans les dictionnaires repose sur le même principe que pour les listes et les n-uplets (c.f. Section @ref(#structure-liste-extraction)). Toutefois, l’extraction d’un élément d’un dictionnaire ne se fait pas en fonction de sa position dans le dictionnaire, mais par sa clé :

print(mon_dict["prenom"])
## John
print(mon_dict["equipes"])
## ['Cleveland', 'Boston']

Si l’extraction s’effectue par une clé non présente dans le dictionnaire, une erreur sera retournée :

print(mon_dict["age"])
## KeyError: 'age'
## 
## Detailed traceback: 
##   File "<string>", line 1, in <module>

On peut tester la présence d’une clé avec l’opérateur in :

print("prenom" in mon_dict)
## True
print("age" in mon_dict)
## False

L’extraction de valeurs peut aussi se faire à l’aide de la méthode get(), qui retourne une valeur None si la clé n’est pas présente :

print(mon_dict.get("prenom"))
## John
print(mon_dict.get("age"))
## None

3.4.2 Clés et valeurs

À l’aide de la méthode key(), on peut accéder aux clés du dictionnaire :

les_cles = mon_dict.keys()
print(les_cles)
## dict_keys(['nom', 'prenom', 'naissance', 'equipes'])
print(type(les_cles))
## <class 'dict_keys'>

Il est possible par la suite de transformer cette énumération de clés en liste :

les_cles_liste = list(les_cles)
print(les_cles_liste)
## ['nom', 'prenom', 'naissance', 'equipes']

La méthode values() fournit quand à elle les valeurs du dictionnaire :

les_valeurs = mon_dict.values()
print(les_valeurs)
## dict_values(['Kyrie', 'John', 1992, ['Cleveland', 'Boston']])
print(type(les_valeurs))
## <class 'dict_values'>

La méthode items() fournit quand à elle les clés et valeurs sous forme de n-uplets :

les_items = mon_dict.items()
print(les_items)
## dict_items([('nom', 'Kyrie'), ('prenom', 'John'), ('naissance', 1992), ('equipes', ['Cleveland', 'Boston'])])
print(type(les_items))
## <class 'dict_items'>

3.4.3 Recherche d’appartenance

Grâce aux méthodes keys(), values() et items(), il est aisé de rechercher la présence d’objets dans un dictionnaire.

print("age" in les_cles)
## False
print("nom" in les_cles)
## True
print(['Cleveland', 'Boston'] in les_valeurs)
## True

3.4.4 Modification

3.4.4.1 Remplacement

Pour remplacer la valeur associée à une clé, on peut utiliser les crochets ([]) et le signe d’égalité (=).

Par exemple, pour remplacer les valeurs associées à la clé equipes :

mon_dict["equipes"] = ["Montclair Kimberley Academy",
  "Cleveland Cavaliers", "Boston Celtics"]
print(mon_dict)
## {'nom': 'Kyrie', 'prenom': 'John', 'naissance': 1992, 'equipes': ['Montclair Kimberley Academy', 'Cleveland Cavaliers', 'Boston Celtics']}

3.4.4.2 Ajout d’éléments

L’ajout d’un élément dans un dictionnaire peut s’effectuer avec les crochets ([]) et le signe d’égalité (=) :

mon_dict["taille_cm"] = 191
print(mon_dict)
## {'nom': 'Kyrie', 'prenom': 'John', 'naissance': 1992, 'equipes': ['Montclair Kimberley Academy', 'Cleveland Cavaliers', 'Boston Celtics'], 'taille_cm': 191}

Pour ajouter le contenu d’un autre dictionnaire à un dictionnaire, Python propose la méthode update().

Créons un second dictionnaire dans un premier temps :

second_dict = {"masse_kg" : 88, "debut_nba" : 2011}
print(second_dict)
## {'masse_kg': 88, 'debut_nba': 2011}

Ajoutons le contenu de ce second dictionnaire au premier :

mon_dict.update(second_dict)
print(mon_dict)
## {'nom': 'Kyrie', 'prenom': 'John', 'naissance': 1992, 'equipes': ['Montclair Kimberley Academy', 'Cleveland Cavaliers', 'Boston Celtics'], 'taille_cm': 191, 'masse_kg': 88, 'debut_nba': 2011}

Si on modifie par la suite le second dictionnaire, cela n’aura pas d’incidence sur le premier :

second_dict["poste"] = "PG"
print(second_dict)
## {'masse_kg': 88, 'debut_nba': 2011, 'poste': 'PG'}
print(mon_dict)
## {'nom': 'Kyrie', 'prenom': 'John', 'naissance': 1992, 'equipes': ['Montclair Kimberley Academy', 'Cleveland Cavaliers', 'Boston Celtics'], 'taille_cm': 191, 'masse_kg': 88, 'debut_nba': 2011}

3.4.4.3 Suppression d’éléments

La suppression d’un élément dans un dictionnaire peut s’effectuer de plusieurs manières. Par exemple, avec l’opérateur del :

del mon_dict["debut_nba"]
print(mon_dict)
## {'nom': 'Kyrie', 'prenom': 'John', 'naissance': 1992, 'equipes': ['Montclair Kimberley Academy', 'Cleveland Cavaliers', 'Boston Celtics'], 'taille_cm': 191, 'masse_kg': 88}

Il est également possible d’utiliser la méthode pop() :

res = mon_dict.pop("masse_kg")
print(mon_dict)
## {'nom': 'Kyrie', 'prenom': 'John', 'naissance': 1992, 'equipes': ['Montclair Kimberley Academy', 'Cleveland Cavaliers', 'Boston Celtics'], 'taille_cm': 191}

Dans l’instruction précédente, nous avons ajouté une assignation du résultat de l’appliation de la méthode pop() à une variable nommée res. Comme on peut le constater, la méthode pop(), en plus d’avoir supprimé la clé, a retourné la valeur associée :

print(res)
## 88

3.4.5 Copie de dictionnaire

Pour copier un dictionnaire, et non créer une référence (ce qui est le cas si on utilise le signe d’égalité), Python fournit comme pour les ensembles, une méthode copy() :

d = {"Marseille": 13, "Rennes" : 35}
d2 = d.copy()
d2["Paris"] = 75
print("d: ", d)
## d:  {'Marseille': 13, 'Rennes': 35}
print("d2: ", d2)
## d2:  {'Marseille': 13, 'Rennes': 35, 'Paris': 75}

3.4.6 Exercice

  1. Créer un dictionnaire nommé photo, comprenant les couples clés-valeurs suivants :

  2. clé : id, valeur : 1,
  3. clé : description, valeur : Une photo du Vieux-port de Marseille,
  4. clé : loc, valeur : une liste dans laquelle sont données les coordonnées suivantes 5.3772133, 43.302424. 2.Ajouter le couple de clé-valeur suivant au dictionnaire photo : clé : utilisateur, valeur : bob.
  5. Rechercher s’il existe une entrée dont la clé vaut description dans le dictionnaire photo. Si tel est le cas, afficher l’entrée correspondante (clé et valeur).
  6. Supprimer l’entrée dans photo dont la clé vaut utilisateur.
  7. Modifier la valeur de l’entrée loc dans le dictionnaire photo, pour proposer une nouvelle liste, dont les coordonnées sont les suivantes : 5.3692712 et 43.2949627.