Voici un aperçu des listes, tuples,
dictionnaires et ensembles en Python :
1. Listes (Lists)
Définition
Une liste en Python est une séquence ordonnée, modifiable et indexée d’éléments. Elle est
définie par des crochets `[]`.
Types de données supportés :
Une liste peut contenir tout type de données : entiers, flottants, chaînes de caractères, listes
imbriquées, objets, etc.
Spécificités :
- Mutabilité : Les listes sont modifiables ; on peut ajouter, supprimer ou modifier des
éléments après leur création.
- Indexation : Elles conservent l’ordre d’ajout des éléments et sont indexées, ce qui permet
d’accéder aux éléments par leur position.
Méthodes courantes
1. `append(x)` : Ajoute l’élément `x` à la fin de la liste.
```python
liste = [1, 2, 3]
liste.append(4) # liste devient [1, 2, 3, 4]
```
2. `remove(x)` : Supprime la première occurrence de `x` dans la liste.
```python
liste = [1, 2, 3, 2]
liste.remove(2) # liste devient [1, 3, 2]
```
3. `pop(i)` : Supprime et retourne l’élément à l’index `i`. Si aucun index n’est spécifié, il retire
le dernier élément.
```python
liste = [1, 2, 3]
liste.pop() # retourne 3, liste devient [1, 2]
```
4. `sort()` : Trie la liste dans l’ordre croissant.
```python
liste = [3, 1, 2]
liste.sort() # liste devient [1, 2, 3]
```
5. `index(x)` : Retourne l’index de la première occurrence de `x`.
```python
liste = [1, 2, 3]
index = liste.index(2) # retourne 1
```
---
2. Tuples
Définition :
Un tuple est une séquence ordonnée et immuable d’éléments, définie par des parenthèses
`()`.
Types de données supportés :
Comme les listes, les tuples peuvent contenir tout type de données.
Spécificités :
- Immutabilité : Les tuples ne peuvent pas être modifiés une fois créés, ce qui les rend plus
rapides et sécurisés pour stocker des données constantes.
- Indexation : Comme les listes, les tuples sont indexés et conservent l’ordre d’ajout.
Méthodes courantes :
1. `count(x)` : Retourne le nombre d’occurrences de `x` dans le tuple.
```python
tuple_ex = (1, 2, 2, 3)
tuple_ex.count(2) # retourne 2
```
2. `index(x)` : Retourne l’index de la première occurrence de `x`.
```python
tuple_ex = (1, 2, 3)
tuple_ex.index(3) # retourne 2
```
3. `len()` : Retourne la longueur du tuple.
```python
len((1, 2, 3)) # retourne 3
```
4. `min()` : Retourne le plus petit élément.
```python
min((3, 1, 2)) # retourne 1
```
5. `max()` : Retourne le plus grand élément.
```python
max((3, 1, 2)) # retourne 3
```
---
3. Dictionnaires (Dictionaries)
Définition :
Un dictionnaire est une collection non ordonnée de paires clé-valeur, définie par des
accolades `{}`.
Types de données supportés :
Les clés doivent être de types immuables (chaînes, entiers, tuples), tandis que les valeurs
peuvent être de tout type.
Spécificités :
- Non ordonné : L’ordre d’ajout des paires n’est pas conservé.
- Accès par clé : On accède aux valeurs via leurs clés uniques, et non par index.
Méthodes courantes :
1. `get(key, default)` : Retourne la valeur associée à `key`, ou `default` si la clé est absente.
```python
dic = {'a': 1, 'b': 2}
dic.get('a') # retourne 1
```
2. `keys()` : Retourne une vue contenant les clés du dictionnaire.
```python
dic = {'a': 1, 'b': 2}
dic.keys() # retourne dict_keys(['a', 'b'])
```
3. `values()` : Retourne une vue contenant les valeurs du dictionnaire.
```python
dic.values() # retourne dict_values([1, 2])
```
4. `items()` : Retourne une vue contenant les paires clé-valeur du dictionnaire.
```python
dic.items() # retourne dict_items([('a', 1), ('b', 2)])
```
5. `update(new_dict)` : Met à jour le dictionnaire avec les paires clé-valeur de `new_dict`.
```python
dic.update({'c': 3}) # dic devient {'a': 1, 'b': 2, 'c': 3}
```
4. Ensembles (Sets)
Définition :
Un ensemble est une collection non ordonnée d’éléments uniques, définie par des accolades `{}`.
Types de données supportés :
Les éléments doivent être immuables (entiers, flottants, chaînes, tuples).
Spécificités :
- Uniqueness : Les éléments d’un ensemble sont uniques ; les doublons sont automatiquement
supprimés.
- Non ordonné : Les ensembles ne sont pas indexés et n’ont pas d’ordre spécifique.
Méthodes courantes:
1. `add(x)` : Ajoute l’élément `x` à l’ensemble.
```python
ensemble = {1, 2}
ensemble.add(3) # ensemble devient {1, 2, 3}
```
2. `remove(x)` : Supprime `x` de l’ensemble. Provoque une erreur si `x` n'existe pas.
```python
ensemble.remove(1) # ensemble devient {2, 3}
```
3. `discard(x)` : Supprime `x` de l’ensemble sans erreur si `x` n'existe pas.
```python
ensemble.discard(4) # ensemble reste {2, 3}
```
4. `union(autre_set)` : Retourne un nouvel ensemble avec les éléments de l’ensemble actuel et de
`autre_set`.
```python
ensemble.union({4, 5}) # retourne {2, 3, 4, 5}
```
5. `intersection(autre_set)` : Retourne un nouvel ensemble avec les éléments communs aux deux
ensembles.
```python
ensemble.intersection({2, 4}) # retourne {2}
```
Conclusion
Ces structures de données sont des piliers en Python, chacune avec des caractéristiques adaptées à
des besoins spécifiques : Listes pour la flexibilité, Tuples pour les données constantes, Dictionnaires
pour des paires clé-valeur et Ensembles pour les collections d’éléments uniques.
