---
title: Découvrir le langage - collections
author: Steve Kossouho
---

# Collections de données

Ce chapitre va présenter 4 types de données de base, qui permettent de manipuler plusieurs informations avec une seule
variable :

- Listes
- Tuples
- Ensembles
- Dictionnaires

----

## Listes

Type de collection de données le plus utile : `list`{.python}. Un objet de type liste peut contenir une **séquence** d'éléments
de n'importe quel type en Python, y compris d'autres listes. Le contenu d'une liste est modifiable (ajouter, retirer des éléments…)

```python {.numberLines}
liste1 = [1, 2, 3, 4, 5, 6]  # éléments de types cohérents
liste2 = [1, 2, 3, "a", "b", "c"]  # pas de restriction sur les types
liste3 = [None, None, True, False]  # None n'est pas une valeur spéciale
liste4 = [[1, 2, 3], [4, 5, 6]]
liste5 = []  # liste vide. Équivalent à list()
liste6 = [liste1]  # Liste contenant 1 élément, qui est lui-même une liste
```

----

Il est possible d'exploiter une liste facilement; on peut ajouter de nouveaux éléments à la fin, les insérer à une
position précise, retirer un élément ou encore récupérer un élément seul. Notez que les positions ([index]{.naming})
des éléments démarrent à zéro (`0`) et qu'une liste n'a jamais d'emplacement vide.

```python {.numberLines}
liste1 = [1, 2, 3, 4, 5, 6]
liste2 = list()  # Créer une nouvelle liste vide

# Infos sur la liste
length = len(liste1)  # Récupérer le nombre d'éléments
position = liste1.index(3)  # Renvoie l'index de la valeur 3, ou erreur si introuvable
nine_trouvable = 9 in liste1  # Renvoie si l'élément 9 existe dans la liste

# Récupérer des éléments
print(liste1[0])  # Affiche le premier élément si la liste est non vide

# Manipuler le contenu
liste1.append(7)  # Ajoute 7 comme nouvel élément à la fin
liste1.insert(0, 99)  # Insère 99 comme nouvel élément au tout début
liste1[0] = 98  # Remplace la valeur à l'index 0
liste1.remove(4)  # Enlève la première occurrence du nombre 4, ou erreur si introuvable
del liste1[3]  # Retire l'élément à l'index 3
```

[Méthodes accessibles sur les listes](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)

----

### Erreurs d'accès

Accéder à un élément de liste n'existant pas génère une erreur (`IndexError`{.python}) et interrompt
votre programme; il peut être utile d'utiliser la fonction `len()`{.python} pour tester que vous
accédez à un indice valide.

```python {.numberLines}
liste1 = [1, 2, 3]
if len(liste1) >= 4:
    print(liste1[3])
```

----

### Erreurs de méthodes

Les méthodes `list.remove()`{.python} et `list.index()`{.python} provoquent également une erreur (`ValueError`{.python}) si
l'élément en argument est introuvable dans la liste. De la même façon, il peut être utile de tester
qu'un élément est présent dans la liste avant d'essayer de l'en supprimer :

```python {.numberLines}
liste1 = ["fred", "denis", 14, 23, 32]
if 8 in liste1:  # Tester que 8 a été trouvé dans la liste
    liste1.remove(8)
```

**Question** : Qu'écririez-vous pour supprimer toutes les occurrences d'une valeur en utilisant `list.remove()`{.python} ?

----

### Indices de liste négatifs

Il est également possible d'accéder à des éléments de liste **non vide** en utilisant des indices négatifs.

Dans ce cas, l'élément à l'index `-1` d'une liste `l` est celui à l'index `len(l) - 1`{.python}, à savoir
le dernier élément. L'élément à l'index `-len(l)`{.python} sera celui à l'index `0`, à savoir le premier
élément. Tout index hors de la plage disponible provoquera une erreur de type `IndexError`{.python}.

```python {.numberLines}
animals = ["dog", "cat", "rabbit", "hamster", "parrot"]
print(animals[-1])  # affiche "parrot"
print(animals[-2])  # affiche "hamster"
print(animals[-5])  # affiche "dog"
```

----

## Parcourir une liste

Comme on l'a vu avec la boucle `for`{.python}, utilisée avec `range()`{.python}, on peut utiliser la
boucle `for`{.python} sur une liste :

```python {.numberLines}
prime_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
for number in prime_numbers:
    print(number)
```

La variable `number`{.python} déclarée pour la boucle contiendra tour à tour 
les valeurs `2`{.python}, puis `3`{.python}, puis `5`{.python}, etc.


----

### Opérations sur listes

Récupérer des portions ou partitions de listes est possible en Python avec la syntaxe suivante (slicing).
Le comportement de cette syntaxe est basé sur le fonctionnement de la fonction `range`{.python}.

```python {.numberLines}
a = [10, 15, 20, 25, 30, 35, 40, 45, 50, 55]  # liste de base
b = a[0:5]  # copier dans une nouvelle liste les éléments aux index 0 à 4.
c = a[5:0]  # créer une nouvelle liste, mais ne rien y copier
d = a[:]  # copier de l'extrêmité gauche à droite incluses
e = a[::-1]  # copier tous les éléments à l'envers
f = a[::2]  # Tout parcourir 2 par 2
g = a[5:2:-1]  # L'indice de début est supérieur à l'indice de fin
h = a[2:5:-1]  # Le pas est négatif, start < end, renvoie une liste vide
```

Pourquoi créer des portions de listes ? Cela peut-être utile, par exemple, si
vous souhaitez appliquer un calcul sur une petite partition d'un jeu de données.

----

## Tuples

**Tuple** : Un `tuple`{.python} fonctionne quasiment trait pour trait comme une liste, à la différence qu'une 
fois que vous avez défini ses éléments, vous ne pouvez plus en changer. On parle de « collection immuable ».

```python {.numberLines}
a = (1, 2, 3)
b = ()  # ou tuple()
c = (1,)  # il vous faut au minimum une virgule
d = (None, "Salut", 15, 2.718)
```

Les méthodes de modification de contenu, telles que `append`{.python} etc. ne sont logiquement pas disponibles avec
ce type : [opérations des tuples](https://docs.python.org/3/library/stdtypes.html#common-sequence-operations)

----

## Ensembles (données uniques)

**Set** (ensemble) : Un `set`{.python} peut contenir plusieurs éléments et est modifiable au même titre
qu'une liste, mais n'est pas une séquence; aucune notion d'ordre ou d'index.
La collection garantit l'unicité des éléments, un élément ne pouvant apparaître qu'une fois au maximum
dans votre objet.

```python {.numberLines}
a = {1, 1, 2, 3, 3, 3}  # équivaut à {1, 2, 3}, les valeurs étant uniques à la fin
b = {2, 4, 5, "hello", (1, 2, 3)}
c = set()  # obligatoire pour déclarer un set vide, sinon considéré dict

print(len(b))

a.add(9.5)  # ajoute la valeur 9.5 (float) au set
a.discard(9.5)  # retire la valeur 9.5, ou ne fait rien

d = a.intersection(b)  # récupérer un ensemble avec les éléments communs à a et b
e = a.union(b)  # récupérer un ensemble avec les éléments présents dans a ou b
...
```

[Méthodes disponibles sur les ensembles](https://docs.python.org/fr/3/library/stdtypes.html#set)

----

![Opérations sur les ensembles](assets/images/basics-sets-operations.jpg)

----

### Bonus : Particularités des ensembles

Les ensembles sont des structures de données très efficaces. Techniquement, vous pouvez attendre une
complexité en `O(1)` pour que Python sache si un élément est déjà présent ou pas; cela signifie qu'il
faut plus ou moins le même nombre d'opérations pour trouver un élément, que votre `set`{.python} en contienne un
seul ou un milliard.

L'algorithme et la structure de données interne à Python derrière cette efficacité se nomme [Table de hachage]{.naming}.

----

#### Tables de hachage

Une table de hachage fonctionne en trois temps :

- On réserve des zones de mémoire d'avance (**buckets**), au départ vides;
- lorsque l'on souhaite vérifier si un élément y est présent, on lui calcule une signature (`hash()`{.python});
- la signature de l'objet permet de savoir quelle zone de mémoire consulter pour le trouver.
- si la zone de mémoire est vide, c'est que l'objet n'était pas présent.

----

#### Exemple de hachage

![Table de hachage](assets/images/basics-sets-hash-table.png)

----

#### Hachage

La signature est un nombre calculé qui est sensé dépendre du contenu d'un objet. Python propose une fonction
à cet effet, `hash()`{.python}, pour laquelle chaque classe propose sa propre implémentation.
L'objectif d'un hash est simple; deux objets différents doivent avoir un hash différent. 
Dans Python ce dernier est un nombre entier sur 64 bits. Si deux objets a et b ont le même hash, ils seront généralement 
considérés comme équivalents et donc en **collision** (dans ce cas, `a == b`{.python}). S'ils ne sont pas considérés équivalents,
il n'y a pas de collision.

----

#### Hachage en général dans Python

Entre deux lancements d'un interpréteur Python, le hash de la majorité des objets est différent;
l'algorithme utilise une valeur aléatoire pour générer les hashs, de façon qu'il soit impossible de créer un 
dictionnaire de signatures dédié à créer des collisions.

Le hachage est en général imprévisible pour les valeurs suivantes :

- `str`{.python} non vides
- `float`{.python} non équivalents à un `int`{.python}
- `None`{.python}
- `tuple`{.python}

----

#### Hashes prévisibles

Le hash est par contre prévisible pour les valeurs suivantes :

- `0`{.python}, `0.0`{.python}, `False`{.python} et `""`{.python} ont un hash de `0`{.python} mais `""`{.python} n'est pas équivalent;
- `1`{.python}, `1.0`{.python} et `True`{.python} ont un hash de `1`{.python} et sont tous en collision.
- `int`{.python}, où le hash est identique au nombre...

Les objets `int`{.python} ont généralement un `hash()`{.python} identique, sauf cas suivants :

- `-1`{.python} a un hash de `-2`{.python} car la valeur `-1`{.python} est un code d'erreur;
- `2 ** 61 - 2`{.python} est le dernier nombre positif avec un hash identique;
- à partir de `2 ** 61 - 1`{.python}, le hash revient à 0 etc.
- le même algorithme fonction sur les entiers négatifs, mais avec des hashes négatifs.

----

#### Hashes impossibles

L'algorithme de la table de hachage nécessite qu'un objet stocké dans un bucket possède en
permanence un `hash` correspondant à son bucket. Cela pose un problème avec les objets modifiables
à tout moment, tels que les `list`{.python}, `set`{.python} ou encore les `dict`{.python}.

La solution adoptée par Python consiste à interdire le calcul de signature desdits objets.
Les `tuple`{.python} demeurent des données valides, puisque nous avons la garantie de ne jamais pouvoir
changer leur contenu, et par là-même leur signature.

```python {.numberLines}
# La fonction hash est disponible par défaut en Python
print(hash([1, 2, 3]))  # Provoque une exception
print(hash({1, 2, 3}))  # Même problème
```

----

## Dictionnaires : associations entre clés et valeurs

**Dictionnaires** : (`dict`{.python}) C'est un **ensemble** d'associations où l'on définit [clés]{.naming} et [valeurs]{.naming}. 
C'est le même fonctionnement qu'un dictionnaire lexicographique, où, lorsque vous avez le
mot (la clé), vous retrouvez la définition s'il y en a une (la valeur). 
D'autres langages ont des structures similaires et appellent ça des `HashMap`{.java} ou des `object`{.javascript}.

```python {.numberLines}
a = {"server1": "192.168.1.2", "server2": "192.168.1.3", "server3": "192.168.1.5"}  # serveurs et adresses IP
b = {8: "Mme Garnier", 10: "M. Dubois", 11: "Mlle Yousfi", 12: "Mme Préjean"}  # rendez-vous horaires
d = {1.2: "flottant", True: "booléen", None: "rien", (1, 2, 3): "tuple"}  # clés de plusieurs types
c = {}  # ou dict(), ceci est un dictionnaire vide

print(a["server1"])  # affiche "192.168.1.2"
print(b[10])  # affiche "M. Dubois"
print(b[9])  # provoque une erreur
print(9 in b)  # Vérifier que 9 fait partie des clés de b
print(9 in b.values())  # Vérifier que 9 fait partie des valeurs de b
```

Les dictionnaires ont les mêmes contraintes que les ensembles uniquement au niveau de leurs clés; vous
pouvez uniquement utiliser des valeurs de types immuables, tels que `int`{.python}, `float`{.python}, `tuple`{.python}...

----

#### Parcourir un dictionnaire

Il est possible de parcourir un dictionnaire avec une boucle `for`{.python}. Dans ce cas, ce sont 
uniquement les clés du dictionnaire qui sont parcourues. Mais il existe des variantes assez pratiques pour
parcourir un dictionnaire :

```python {.numberLines}
profils = {
    "Jérémy": (25, "M", "Lille"),
    "Hélène": (30, "F", "Ambérieu-en-Bugey"),
    "Gwladys": (35, "F", "Nyons"),
    "Thierry": (40, "M", "Montceau-les-Mines"),
    "Carole": (45, "F", "Saint-Rémy-lès-Chevreuse"),
}

for prenom in profils:
    print(prenom)  # affiche uniquement une clé
    print(profils[prenom])  # retrouve la valeur associée à la clé
```

----

Si vous parcourez une collection dont tous les éléments sont eux-mêmes des séquences
de `n` éléments, vous pouvez les dépaqueter (**unpacking**) :

```python {.numberLines}
# Avancé, unpacking via la méthode `items`
profils = {...}

for item in profils.items():  # a.items() renvoie ((clé1, valeur1), (clé2, valeur2), …)
    print(item)  # est un tuple

for key, value in profils.items():
    # on peut utiliser 2 variables de boucle si chaque élément parcouru est 
    # une séquence de taille 2. Merci l'unpacking !
    print(key, value)  
```

----

#### Manipuler un dictionnaire

Pour changer la valeur associée à une clé existante, ou par la même occasion, associer une valeur à
une nouvelle clé, il suffit d'écrire :

```python {.numberLines}
populations = {"Bordeaux": 250000, "Cherbourg": 80000}
print(populations)

# Modifier le contenu
populations["Marseille"] = 800000
populations["Bordeaux"] = 90
print(populations["Bordeaux"])  # Affiche 90

# On peut supprimer du dictionnaire une association en écrivant
del populations["Marseille"]  # plus de clé pour Marseille !
print("Marseille" in populations)  # renvoie si la clé "Marseille" existe
```

----

### Extra : méthodes de dictionnaires

La méthode `get(key, default)`{.python} des dictionnaires renvoie la valeur associée à une clé. Si
l'on ne passe pas de valeur pour l'argument `default`{.python}, pour une clé introuvable, la méthode
renvoie `None`{.python} (au lieu de planter comme lorsqu'on écrit `dict[key]`{.python}).

```python {.numberLines}
populations = {"Paris": 2.6e6, "Marseille": 8e5, "Lyon": 5e5, "Bordeaux": 2.5e5}
print(populations.get("Tarbes"))  # renvoie None
print(populations.get("Mulhouse", -1))  # renvoie -1
print(populations.get("Marseille", -1))  # renvoie 800 000.0
```

Si l'on passe une valeur pour l'argument `default`{.python}, alors, si la clé n'a pas été trouvée,
la méthode renvoie la valeur de repli que vous avez définie.

----

## Compréhensions de listes, tuples etc.

Déclarer des listes, tuples, sets et dictionnaires avec la syntaxe de compréhension :

```python {.numberLines}
a = [x * 2 for x in range(100)]  # tous les nombres pairs de 0 à 198
b = [x * 2 for x in range(100) if x != 10]  # nombres pairs de 0 à 198 sauf 20
c = (x for x in range(100))  # pas un tuple mais un générateur, nombres de 0 à 99
d = {x / 2 for x in range(100)}  # on peut faire pareil avec les sets
pre = {"Jon": None, "Pam": None, "Mel": None, "Kim": None}
e = {k: pre[k] for k in pre}  # on copie pre
```

----

## Récapitulatif des collections

| Type          | Propriétés                                                                                                               |
|---------------|--------------------------------------------------------------------------------------------------------------------------|
| `list`        | `[...,]`{.python}. Séquence dont le contenu est modifiable (ajout, suppression).                                         |
| `tuple`       | `(...,)`{.python}. Séquence dont le contenu est gelé après déclaration. Utilisable comme élément d'un `set`.             |
| `set`         | `{...,}`{.python}. Déduplique les éléments et permet des opérations entre ensembles <br/>(union, intersection etc.)      |
| `dict`        | `{..:..,}`{.python}. Structure de **recherche** rapide où l'on peut associer des valeurs quelconques à des identifiants. |

----

### Usages d'exemple

Le `tuple`{.python} n'est jamais très important, et il sera souvent plus pratique de travailler sur des listes. Les seuls
cas de figure qui obligent à utiliser des `tuple`{.python} sont les cas où vous voulez ajouter une séquence comme élément d'un `set`
ou comme clé d'un `dict`{.python}.

- `list`{.python} : si vous avez des données séquentielles à stocker, par exemple lues depuis un fichier.
- `set`{.python} : si vous souhaitez enlever des doublons, connaître le nombre d'éléments uniques.
- `dict`{.python} : si vous avez besoin d'une "table de référence" pour stocker des données que vous allez rechercher fréquemment.

----

# Chaînes de caractères

----

## Opérations sur les chaînes de caractères

Nous n'avons pas vu grand chose sur les chaînes de caractères, mais certaines informations peuvent
être fréquemment utiles aux développeurs :

- [Méthodes sur les objets de type `str`{.python}](https://docs.python.org/3/library/stdtypes.html#string-methods)
- [Formatage de chaînes via les f-strings](https://zetcode.com/python/fstring/)
- [Documentation officielle sur le format des interpolations](https://docs.python.org/3/library/string.html#format-string-syntax)

```python {.numberLines}
number = 2_643
print(f"Le serveur qui doit être vérifié aujourd'hui est le numéro {number}")
print(f"Formatage de la variable : {number:f}")  # affiché comme flottant (6 chiffres après la virgule)
```

----

## Les chaînes de caractères et leurs méthodes

```python {.numberLines}
chaine = "Bonjour"
print(chaine.upper(), chaine.lower())
print(chaine.center(50, " "))  # Centre la chaîne originale sur 50 caractères
```

Méthodes qui renvoient une **copie** modifiée d'une chaîne

----

## Méthodes fréquemment utiles sur les chaînes de caractères

- `upper()`{.python} : renvoie une copie en majuscules
- `lower()`{.python} : renvoie une copie en minuscules
- `strip()`{.python} : retire les espaces aux extrêmités
- `replace(old, new, count=None)`{.python} : remplace `old` par `new`
- `index(sub, start=None)`{.python} : renvoie la position de `sub`
- `sub in text`{.python} : renvoie si `sub` est inclus dans `text`
- `split(sep=None)`{.python} : découpe en liste autour du séparateur, par défaut autour des espaces
- `str.join(iterable)`{.python} : sert de séparateur et joint une liste de chaînes

----

```python {.numberLines}
chaine = "Bonjour, nous sommes le 17 juillet 2063."
words = chaine.split()  # renvoie une liste de chaînes autour des espaces
rejoin = " ".join(words) # renvoie une chaîne en insérant l'espace comme séparateur
print(chaine.upper(), chaine.lower(), rejoin)
print("17 juillet" in chaine)
```

Exemple de `str.split()`{.python} et `str.join()`{.python}


