Manipulation et méthodes courantes de chaque structure

Listes : flexibilité et dynamisme

Les listes sont des séquences ordonnées et modifiables. Elles sont très polyvalentes et largement utilisées en Python.

• Accès : `liste[index]` (indexation), `liste[debut:fin:pas]` (slicing)
• Modification : `liste[index] = nouvelle_valeur`
• Ajout : `append(element)`, `insert(index, element)`, `extend(iterable)`
• Suppression : `remove(element)`, `pop(index)`, `del liste[index]`, `clear()`
• Autres : `reverse()`, `sort()`, `copy()`

ma_liste = [1, 2, 3, 2]

ma_liste.append(4)        # Ajoute 4 à la fin : [1, 2, 3, 2, 4]
ma_liste.insert(1, 5)    # Insère 5 à l'index 1 : [1, 5, 2, 3, 2, 4]
ma_liste.extend([6, 7])  # Ajoute 6 et 7 à la fin : [1, 5, 2, 3, 2, 4, 6, 7]
ma_liste.remove(2)      # Supprime la première occurrence de 2 : [1, 5, 3, 2, 4, 6, 7]
element = ma_liste.pop(1) # Supprime et retourne l'élément à l'index 1 (ici, 5) : [1, 3, 2, 4, 6, 7], element = 5
ma_liste.sort()         # Trie la liste en place : [1, 2, 3, 4, 6, 7]
ma_liste.reverse()      # Inverse la liste en place : [7, 6, 4, 3, 2, 1]
compte = ma_liste.count(2) # Compte le nombre d'occurrences de 2 (ici, 1)
index = ma_liste.index(4)  # Retourne l'index de la première occurrence de 4 (ici, 2)

# Copie de liste
autre_liste = ma_liste.copy() # Crée une copie superficielle
import copy
liste_complexe = [1, [2, 3]]
copie_profonde = copy.deepcopy(liste_complexe) # Crée une copie profonde

Tuples : immuabilité et performance

Les tuples sont des séquences ordonnées et immuables. Ils sont souvent utilisés pour représenter des données qui ne doivent pas être modifiées, ou comme clés de dictionnaires.

• Accès : `tuple[index]` (indexation), `tuple[debut:fin:pas]` (slicing)

mon_tuple = (1, 2, 3, 2)

compte = mon_tuple.count(2)  # Compte le nombre d'occurrences de 2 (ici, 2)
index = mon_tuple.index(3)   # Retourne l'index de la première occurrence de 3 (ici, 2)

# Concaténation (crée un nouveau tuple)
tuple1 = (1, 2)
tuple2 = (3, 4)
tuple3 = tuple1 + tuple2  # (1, 2, 3, 4)

# Répétition (crée un nouveau tuple)
tuple4 = tuple1 * 3  # (1, 2, 1, 2, 1, 2)

Dictionnaires : association clé-valeur et recherche rapide

Les dictionnaires permettent de stocker des paires clé-valeur, offrant une recherche rapide par clé. Depuis Python 3.7, ils conservent l'ordre d'insertion.

• Accès : `dictionnaire[cle]`, `dictionnaire.get(cle, valeur_par_defaut)`
• Modification/Ajout : `dictionnaire[cle] = valeur`
• Suppression : `del dictionnaire[cle]`, `dictionnaire.pop(cle, valeur_par_defaut)`, `clear()`

mon_dictionnaire = {"a": 1, "b": 2, "c": 3}

# Accès
valeur = mon_dictionnaire["b"]       # 2
valeur = mon_dictionnaire.get("d", 0)  # 0 (valeur par défaut si la clé est absente)

# Ajout/Modification
mon_dictionnaire["d"] = 4  # Ajoute la paire "d": 4
mon_dictionnaire["a"] = 5  # Modifie la valeur associée à la clé "a"

# Suppression
del mon_dictionnaire["c"]  # Supprime la paire "c": 3
valeur = mon_dictionnaire.pop("b") # Supprime la paire et retourne la valeur associée a la clé (ici 2)., valeur = 2

# Itération
cles = mon_dictionnaire.keys()    # Vue sur les clés (dict_keys(['a', 'd']))
valeurs = mon_dictionnaire.values() # Vue sur les valeurs (dict_values([5, 4]))
paires = mon_dictionnaire.items()   # Vue sur les paires clé-valeur (dict_items([('a', 5), ('d', 4)]))

# Fusion
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
dict1.update(dict2)          # {"a": 1, "b": 3, "c": 4}

Ensembles : unicité et opérations ensemblistes

Les ensembles sont des collections non ordonnées d'éléments uniques. Ils sont optimisés pour les tests d'appartenance et les opérations ensemblistes.

• Ajout : `add(element)`, `update(iterable)`
• Suppression : `remove(element)`, `discard(element)`, `pop()`, `clear()`

ensemble1 = {1, 2, 3}
ensemble2 = {3, 4, 5}

# Ajout
ensemble1.add(4)          # {1, 2, 3, 4}
ensemble1.update([4, 5, 6]) # {1, 2, 3, 4, 5, 6} 

# Suppression
ensemble1.remove(1)       # {2, 3, 4, 5, 6}  (lève une KeyError si l'élément n'est pas présent)
ensemble1.discard(7)      # {2, 3, 4, 5, 6} (ne fait rien si l'élément n'est pas présent)
element = ensemble1.pop()   # Supprime et retourne un élément arbitraire

# Opérations ensemblistes
union = ensemble1 | ensemble2        # {2, 3, 4, 5} | {3, 4, 5} = {2, 3, 4, 5}
intersection = ensemble1 & ensemble2 # {2, 3, 4, 5} & {3, 4, 5} = {3, 4, 5}
difference = ensemble1 - ensemble2   # {2, 3, 4, 5} - {3, 4, 5} = {2}
diff_sym = ensemble1 ^ ensemble2     # {2, 3, 4, 5} ^ {3, 4, 5} = {2}

# Tests
print(2 in ensemble1)           # True
print(ensemble2.issubset(ensemble1))  # False
print(ensemble1.issuperset(ensemble2)) # False
print(ensemble1.isdisjoint(ensemble2))# False

Comparaison des structures de données : choisir la bonne structure

Chaque structure de données a ses forces et ses faiblesses. Voici un tableau comparatif pour vous aider à choisir :

Le choix de la structure de données dépend du contexte et des opérations que vous devez effectuer. Il est important de bien comprendre les caractéristiques de chaque structure pour faire le meilleur choix.