madamasterclass.com
Connaître la notion de Liste en Python
Une liste en Python est une structure de données fondamentale qui permet de stocker une collection ordonnée et modifiable d'éléments. Contrairement aux tableaux de certains langages, les listes Python peuvent contenir des éléments de types différents au sein de la même structure.
Les listes Python possèdent plusieurs propriétés fondamentales qui les distinguent des autres structures de données :
La compréhension de la complexité est cruciale pour optimiser les performances :
Les opérations d'ajout permettent d'étendre dynamiquement la liste. Chaque méthode a ses spécificités :
La suppression d'éléments peut affecter les indices des éléments suivants. Il est important de comprendre les différences :
Python offre des opérateurs intuitifs pour combiner et manipuler les listes de manière élégante :
nombres = [5, 2, 8] # Initialisation - O(1) nombres.append(1) # [5, 2, 8, 1] - O(1) amortisé nombres.insert(1, 4) # [5, 4, 2, 8, 1] - O(n) dernier = nombres.pop() # [5, 4, 2, 8], dernier = 1 - O(1) doubles = nombres + nombres # [5, 4, 2, 8, 5, 4, 2, 8] - O(n) triples = nombres * 3 # Répétition 3 fois - O(n) contient_4 = 4 in nombres # True - O(n)
Python propose des méthodes sophistiquées pour manipuler les listes efficacement :
Éducation
sort(key=None, reverse=False)
Tri sur place avec critère personnalisé
reverse()
Inversion de l'ordre des éléments
count(x)
Nombre d'occurrences de x
index(x, start, end)
Index de la première occurrence de x
copy()
Copie superficielle de la liste
clear()
Supprime tous les éléments
Comprendre visuellement le comportement des algorithmes de tri et de recherche :
Python utilise l'algorithme Timsort, un algorithme hybride dérivé de merge sort et insertion sort. Sa complexité temporelle est :
Le slicing permet d'extraire des sous-séquences de manière efficace. La syntaxe générale est :
Où :
Les listes imbriquées permettent de créer des structures de données multidimensionnelles. Elles sont particulièrement utiles pour représenter des matrices, des tableaux ou des structures hiérarchiques.
Les compréhensions de listes (list comprehensions) offrent une syntaxe concise et pythonique pour créer des listes. Elles sont généralement plus rapides que les boucles équivalentes.
Les compréhensions de listes sont généralement plus rapides que les boucles traditionnelles car elles sont optimisées au niveau du bytecode Python.
Python gère automatiquement la mémoire pour les listes, mais il est important de comprendre les implications des différentes opérations :
Adopter de bonnes pratiques permet d'écrire du code plus lisible, maintenable et performant :
copy() aux slices vides [:]enumerate() pour les indiceszip() pour itérer sur plusieurs listesÉtant donné la liste suivante : nombres = [10, 20, 30, 40, 50]
1. Ajoutez l'élément 60 à la fin de la liste
2. Modifiez le deuxième élément pour qu'il devienne 25
3. Affichez le dernier élément de la liste
# Solution :
nombres = [10, 20, 30, 40, 50]
# 1. Ajout en fin de liste
nombres.append(60)
# 2. Modification du 2ème élément (indice 1)
nombres[1] = 25
# 3. Affichage du dernier élément
print(nombres[-1]) # Affiche 60
# Liste finale : [10, 25, 30, 40, 50, 60]
Étant donné deux listes : liste1 = [1, 2, 3] et liste2 = ['a', 'b', 'c']
1. Concaténez-les pour obtenir [1, 2, 3, 'a', 'b', 'c']
2. Créez une liste imbriquée [[1, 'a'], [2, 'b'], [3, 'c']]
3. Extrayez 'b' de la liste résultante de la question 2
# Solution :
liste1 = [1, 2, 3]
liste2 = ['a', 'b', 'c']
# 1. Concaténation
liste_concat = liste1 + liste2 # [1, 2, 3, 'a', 'b', 'c']
# 2. Liste imbriquée
liste_imbriquee = [[liste1[i], liste2[i]] for i in range(len(liste1))]
# 3. Extraction de 'b'
element_b = liste_imbriquee[1][1] # Récupère 'b'
# Variante pour la question 2 :
# liste_imbriquee = list(zip(liste1, liste2))
Étant donné la liste : data = [12, 5, 8, 19, 3, 7]
1. Triez la liste par ordre croissant
2. Calculez la somme des éléments
3. Créez une nouvelle liste avec les carrés des éléments impairs
4. Trouvez l'indice de la valeur maximale
# Solution :
data = [12, 5, 8, 19, 3, 7]
# 1. Tri croissant
data.sort() # [3, 5, 7, 8, 12, 19]
# 2. Somme des éléments
somme = sum(data) # 54
# 3. Carrés des éléments impairs
carres_impairs = [x**2 for x in data if x % 2 != 0] # [25, 49, 9]
# 4. Indice de la valeur maximale
indice_max = data.index(max(data)) # 5 (car trié, dernier élément)
# Variante non triée :
# indice_max = data.index(max(data))
Étant donné la liste : mix = [4, 'a', 7, 'b', 'c', 9, 2]
1. Séparez les nombres et les chaînes dans deux listes distinctes
2. Inversez l'ordre des éléments de la liste originale
3. Supprimez tous les éléments non numériques de la liste originale
4. Créez une liste des multiples de 3 à partir des nombres
# Solution :
mix = [4, 'a', 7, 'b', 'c', 9, 2]
# 1. Séparation
nombres = [x for x in mix if isinstance(x, int)]
chaines = [x for x in mix if isinstance(x, str)]
# 2. Inversion de l'ordre
mix.reverse() # [2, 9, 'c', 'b', 7, 'a', 4]
# 3. Suppression des non-numériques
mix = [x for x in mix if isinstance(x, int)] # [2, 9, 7, 4]
# 4. Multiples de 3
multiples_3 = [x for x in nombres if x % 3 == 0] # [9]
Étant donné la matrice : matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
1. Affichez l'élément central (5)
2. Calculez la somme de chaque ligne
3. Transposez la matrice (échanger lignes et colonnes)
4. Créez une liste avec les éléments de la diagonale principale
# Solution :
matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 1. Élément central
centre = matrice[1][1] # 5
# 2. Somme de chaque ligne
sommes_lignes = [sum(ligne) for ligne in matrice] # [6, 15, 24]
# 3. Transposition
matrice_transposee = [[ligne[i] for ligne in matrice] for i in range(3)]
# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
# 4. Diagonale principale
diagonale = [matrice[i][i] for i in range(3)] # [1, 5, 9]
# Variante avec numpy pour la transposition :
# import numpy as np; np.array(matrice).T.tolist()
Créez une fonction somme_liste qui :
1. Prend une liste de nombres en paramètre
2. Retourne la somme de ses éléments
3. Testez-la avec [1, 2, 3, 4, 5] (doit retourner 15)
def somme_liste(nombres):
return sum(nombres)
# Test
print(somme_liste([1, 2, 3, 4, 5])) # 15
# Version alternative sans sum():
def somme_liste_alt(nombres):
total = 0
for num in nombres:
total += num
return total
Créez une fonction filtrer_pairs qui :
1. Prend une liste de nombres en paramètre
2. Retourne une nouvelle liste contenant seulement les nombres pairs
3. Testez-la avec [1, 2, 3, 4, 5, 6, 7, 8] (doit retourner [2, 4, 6, 8])
def filtrer_pairs(nombres):
return [x for x in nombres if x % 2 == 0]
# Test
print(filtrer_pairs([1, 2, 3, 4, 5, 6, 7, 8])) # [2, 4, 6, 8]
# Version alternative avec boucle for:
def filtrer_pairs_alt(nombres):
pairs = []
for num in nombres:
if num % 2 == 0:
pairs.append(num)
return pairs
Créez une fonction moyenne_ponderee qui :
1. Prend deux listes (valeurs et poids) de même longueur
2. Retourne la moyenne pondérée des valeurs
3. Testez-la avec valeurs = [10, 20, 30] et poids = [1, 2, 3] (doit retourner 23.33)
def moyenne_ponderee(valeurs, poids):
somme_produits = sum(v * p for v, p in zip(valeurs, poids))
somme_poids = sum(poids)
return round(somme_produits / somme_poids, 2)
# Test
print(moyenne_ponderee([10, 20, 30], [1, 2, 3])) # 23.33
# Gestion d'erreur possible :
if len(valeurs) != len(poids):
raise ValueError("Les listes doivent avoir la même longueur")
Créez une fonction matrice_carre qui :
1. Prend une liste de listes (matrice carrée)
2. Retourne True si c'est une matrice carrée (même nombre de lignes et colonnes), False sinon
3. Testez-la avec [[1, 2], [3, 4]] (True) et [[1, 2, 3], [4, 5]] (False)
def matrice_carre(matrice):
n = len(matrice)
return all(len(ligne) == n for ligne in matrice)
# Tests
print(matrice_carre([[1, 2], [3, 4]])) # True
print(matrice_carre([[1, 2, 3], [4, 5]])) # False
# Version alternative :
def matrice_carre_alt(matrice):
taille = len(matrice)
for ligne in matrice:
if len(ligne) != taille:
return False
return True
Créez une fonction fusion_triee qui :
1. Prend deux listes triées en entrée
2. Retourne une nouvelle liste triée contenant les éléments des deux listes
3. Testez-la avec [1, 3, 5] et [2, 4, 6] (doit retourner [1, 2, 3, 4, 5, 6])
4. Bonus: Faites-le sans utiliser sort()
# Version simple avec sort()
def fusion_triee(liste1, liste2):
fusion = liste1 + liste2
fusion.sort()
return fusion
# Version algorithmique (sans sort())
def fusion_triee_opti(liste1, liste2):
resultat = []
i = j = 0
while i < len(liste1) and j < len(liste2):
if liste1[i] < liste2[j]:
resultat.append(liste1[i])
i += 1
else:
resultat.append(liste2[j])
j += 1
# Ajouter les éléments restants
resultat.extend(liste1[i:])
resultat.extend(liste2[j:])
return resultat
# Tests
print(fusion_triee([1, 3, 5], [2, 4, 6])) # [1, 2, 3, 4, 5, 6]
print(fusion_triee_opti([1, 3, 5], [2, 4, 6])) # [1, 2, 3, 4, 5, 6]
Abonnez-vous maintenant et recevez notre newsletter hebdomadaire avec des matériaux éducatifs, de nouveaux cours, des articles intéressants, des livres populaires et bien plus encore !
