img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Maîtrisez les listes Python comme un Pro

Fournir une formation complète sur les listes Python, de la création basique aux techniques avancées.
Permettre aux développeurs débutants et intermédiaires de maîtriser tous les aspects des listes.
Offrir des exemples pratiques et des bonnes pratiques pour une utilisation optimale en programmation.

Introduction aux listes Python

Les listes sont l'une des structures de données les plus polyvalentes et couramment utilisées en Python. Elles permettent de stocker des collections ordonnées et modifiables d'éléments de différents types.

Qu'est-ce qu'une liste ?

Une liste en Python est une collection ordonnée et mutable d'éléments qui peuvent être de types différents. Contrairement aux tableaux dans d'autres langages, les listes Python peuvent contenir des éléments hétérogènes.

exemple_liste.py
# Exemples de listes avec des noms marocains
prenoms_marocains = ["Fatima", "Mehdi", "Youssef", "Amina"]
villes_maroc = ["Casablanca", "Marrakech", "Fès", "Tanger"]

# Liste avec différents types de données
element_marocain = ["Maroc", 71000000, 446550, True]  # pays, population, superficie, indépendant

print("Prénoms marocains:", prenoms_marocains)
print("Villes du Maroc:", villes_maroc)
print("Élément marocain:", element_marocain)

Pourquoi utiliser les listes ?

Les listes sont essentielles en Python pour plusieurs raisons :

  • Elles permettent de regrouper des données connexes
  • Elles sont modifiables (on peut ajouter, supprimer ou modifier des éléments)
  • Elles préservent l'ordre des éléments
  • Elles permettent de stocker des données hétérogènes
  • Elles offrent de nombreuses méthodes intégrées pour la manipulation des données
utilisations_listes.py
# Exemple: Gestion d'une liste de plats marocains
plats_marocains = ["Tajine", "Couscous", "Pastilla", "Harira"]

# Ajouter un nouveau plat
plats_marocains.append("Méchoui")

# Modifier un élément
plats_marocains[0] = "Tajine de poulet"

# Trier la liste
plats_marocains.sort()

print("Plats marocains:", plats_marocains)
print("Nombre de plats:", len(plats_marocains))

Syntaxe de base et première liste

La création d'une liste en Python est simple. On utilise des crochets [] pour délimiter la liste, et les éléments sont séparés par des virgules.

syntaxe_liste.py
# Syntaxe de base pour créer une liste
ma_liste = [élément1, élément2, élément3, ...]

# Exemples avec des éléments marocains
regions_maroc = ["Casablanca-Settat", "Rabat-Salé-Kénitra", "Fès-Meknès"]
sites_touristiques = ["Jamaâ El Fna", "Hassan II", "Volubilis"]
codes_region = [6, 4, 3]

# Liste vide
liste_vide = []

# Liste avec différents types
maroc_info = ["Maroc", 1956, 446550, True]  # nom, année indépendance, superficie, monarchie

print("Régions:", regions_maroc)
print("Sites touristiques:", sites_touristiques)
print("Infos Maroc:", maroc_info)

Créer et initialiser des listes

En Python, il existe plusieurs méthodes pour créer et initialiser des listes, que ce soit des listes vides, pré-remplies ou générées dynamiquement.

Création de listes vides et pré-remplies

Les listes peuvent être créées vides pour être remplies ultérieurement, ou pré-remplies avec des valeurs initiales.

listes_vides_remplies.py
# Création de listes vides
villes_maroc_vides = []
regions_maroc_vides = list()

# Création de listes pré-remplies avec des villes marocaines
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]
plats_marocains = ["Tajine", "Couscous", "Pastilla", "Harira"]

# Ajout d'éléments aux listes vides
villes_maroc_vides.append("Agadir")
villes_maroc_vides.append("Meknès")
villes_maroc_vides.append("Oujda")

print("Villes du Maroc:", villes_maroc)
print("Plats marocains:", plats_marocains)
print("Villes ajoutées:", villes_maroc_vides)

Listes avec différents types de données

Contrairement à de nombreux autres langages, les listes Python peuvent contenir des éléments de types différents.

listes_types_differents.py
# Liste contenant différents types de données
informations_maroc = [
    "Maroc",           # Chaîne de caractères
    71000000,          # Entier (population)
    446550,            # Entier (superficie en km²)
    True,              # Booléen (indépendant)
    ["Arabes", "Berbères", "autres"],  # Liste
    {"capitale": "Rabat", "langue": "Arabe"}  # Dictionnaire
]

# Liste mixte avec informations sur des villes marocaines
ville_casablanca = [
    "Casablanca",      # Nom de la ville
    3.4e6,             # Population (3.4 millions)
    324,               # Superficie en km²
    True,              # Ville côtière
    ["Hassan II", "Mohammed V"]  # Monuments
]

# Accès aux éléments de types différents
nom_pays = informations_maroc[0]
population = informations_maroc[1]
groupes_ethniques = informations_maroc[4]

print("Nom du pays:", nom_pays)
print("Population:", population)
print("Groupes ethniques:", groupes_ethniques)
print("Type de groupes_ethniques:", type(groupes_ethniques))

Génération de listes avec range() et list()

La fonction range() combinée avec le constructeur list() permet de générer facilement des séquences de nombres.

generation_range.py
# Génération de listes avec range()
nombres_1_a_10 = list(range(1, 11))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
nombres_pairs = list(range(0, 21, 2))  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
annees_2000 = list(range(2000, 2024))  # Années de 2000 à 2023

# Simulation de données pour les régions marocaines
codes_regions = list(range(1, 13))  # Codes de 1 à 12 pour les 12 régions du Maroc
populations = list(range(500000, 7000000, 500000))  # Populations simulées

# Conversion d'une chaîne en liste de caractères
nom_maroc = list("Maroc")  # ['M', 'a', 'r', 'o', 'c']
ville_rabat = list("Rabat")  # ['R', 'a', 'b', 'a', 't']

# Affichage des résultats
print("Nombres de 1 à 10:", nombres_1_a_10)
print("Nombres pairs jusqu'à 20:", nombres_pairs)
print("Codes des régions marocaines:", codes_regions)
print("Nom Maroc en liste:", nom_maroc)
print("Ville Rabat en liste:", ville_rabat)

# Utilisation avec des compréhensions de liste pour plus de complexité
superficies_regions = [superficie * 1000 for superficie in range(10, 130, 10)]
print("Superficies des régions (km²):", superficies_regions)

Accéder aux éléments des listes

Python offre plusieurs méthodes pour accéder aux éléments d'une liste, que ce soit par index, par tranches (slicing) ou en vérifiant l'existence d'un élément.

Indexation positive et négative

Les éléments d'une liste sont accessibles par leur index. Python supporte l'indexation positive (à partir de 0) et négative (à partir de -1 pour le dernier élément).

indexation_listes.py
# Liste des villes marocaines
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir"]

# Indexation positive (commence à 0)
premiere_ville = villes_maroc[0]  # "Casablanca"
deuxieme_ville = villes_maroc[1]  # "Rabat"
troisieme_ville = villes_maroc[2]  # "Marrakech"

# Indexation négative (commence à -1 pour le dernier élément)
derniere_ville = villes_maroc[-1]  # "Agadir"
avant_derniere_ville = villes_maroc[-2]  # "Tanger"
premiere_ville_neg = villes_maroc[-6]  # "Casablanca"

# Liste des plats marocains
plats_marocains = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui"]

# Accès avec indexation positive et négative
plat_principal = plats_marocains[0]  # "Tajine"
soupe_traditionnelle = plats_marocains[-2]  # "Harira"
plat_festif = plats_marocains[-1]  # "Méchoui"

print("Villes du Maroc:", villes_maroc)
print("Première ville:", premiere_ville)
print("Dernière ville:", derniere_ville)
print("Plat principal:", plat_principal)
print("Soupe traditionnelle:", soupe_traditionnelle)

Slicing (découpage de listes)

Le slicing permet d'extraire une partie d'une liste en spécifiant un début, une fin et un pas. La syntaxe est liste[début:fin:pas].

slicing_listes.py
# Liste des régions marocaines
regions_maroc = [
    "Tanger-Tétouan-Al Hoceïma",
    "L'Oriental",
    "Fès-Meknès",
    "Rabat-Salé-Kénitra",
    "Béni Mellal-Khénifra",
    "Casablanca-Settat",
    "Marrakech-Safi",
    "Drâa-Tafilalet",
    "Souss-Massa",
    "Guelmim-Oued Noun",
    "Laâyoune-Sakia El Hamra",
    "Dakhla-Oued Ed-Dahab"
]

# Slicing de base
premieres_regions = regions_maroc[0:3]  # 3 premières régions
regions_centrales = regions_maroc[3:7]  # régions 4 à 7
dernieres_regions = regions_maroc[9:]   # à partir de la 10ème région

# Slicing avec indices négatifs
trois_dernieres = regions_maroc[-3:]  # 3 dernières régions
sans_les_deux_premieres = regions_maroc[2:]  # sans les 2 premières
sans_les_deux_dernieres = regions_maroc[:-2]  # sans les 2 dernières

# Slicing avec pas
une_sur_deux = regions_maroc[::2]  # une région sur deux
inverse = regions_maroc[::-1]  # liste inversée
une_sur_trois = regions_maroc[::3]  # une région sur trois

# Slicing avec début, fin et pas
selection = regions_maroc[1:8:2]  # de l'index 1 à 7, un sur deux

print("Toutes les régions:", regions_maroc)
print("3 premières régions:", premieres_regions)
print("3 dernières régions:", trois_dernieres)
print("Régions une sur deux:", une_sur_deux)
print("Régions inversées:", inverse)

Vérifier l'existence d'un élément

Pour vérifier si un élément existe dans une liste, on utilise le mot-clé in ou la méthode index() qui renvoie la position de l'élément.

existence_elements.py
# Liste de spécialités marocaines
specialites = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui", "Rfissa"]

# Vérification avec 'in'
existe_tajine = "Tajine" in specialites
existe_briouate = "Briouate" in specialites

# Vérification avec 'not in'
pas_briouate = "Briouate" not in specialites

# Trouver l'index d'un élément avec index()
try:
    index_couscous = specialites.index("Couscous")
    index_rfissa = specialites.index("Rfissa")
except ValueError:
    index_couscous = "Non trouvé"
    index_rfissa = "Non trouvé"

# Vérification dans une liste de villes marocaines
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]
ville_a_verifier = "Marrakech"

if ville_a_verifier in villes_maroc:
    resultat_verif = f"La ville {ville_a_verifier} est bien marocaine"
else:
    resultat_verif = f"La ville {ville_a_verifier} n'est pas dans la liste"

# Vérification multiple
villes_cotieres = ["Casablanca", "Tanger", "Agadir", "Essaouira"]
villes_a_verifier = ["Casablanca", "Fès", "Agadir"]

villes_cotieres_trouvees = [ville for ville in villes_a_verifier if ville in villes_cotieres]

print("Le Tajine est dans la liste:", existe_tajine)
print(<

				

Modifier les listes

Les listes Python sont mutables, ce qui signifie que vous pouvez modifier leur contenu après leur création. Plusieurs méthodes permettent d'ajouter, supprimer ou modifier des éléments.

Ajouter des éléments (append, insert, extend)

Python offre plusieurs méthodes pour ajouter des éléments à une liste : append() pour ajouter à la fin, insert() pour insérer à une position spécifique, et extend() pour ajouter plusieurs éléments.

ajouter_elements.py
# Liste initiale de villes marocaines
villes_maroc = ["Casablanca", "Rabat", "Marrakech"]
print("Liste initiale:", villes_maroc)

# Ajout avec append() - ajoute à la fin
villes_maroc.append("Fès")
print("Après append('Fès'):", villes_maroc)

# Insertion avec insert() - à une position spécifique
villes_maroc.insert(1, "Tanger")  # Insère à l'index 1
print("Après insert(1, 'Tanger'):", villes_maroc)

# Ajout multiple avec extend()
nouvelles_villes = ["Agadir", "Meknès", "Oujda"]
villes_maroc.extend(nouvelles_villes)
print("Après extend():", villes_maroc)

# Exemple avec des spécialités culinaires
plats_marocains = ["Tajine", "Couscous"]
plats_marocains.append("Pastilla")
plats_marocains.insert(0, "Harira")  # Ajoute au début
autres_plats = ["Méchoui", "Rfissa"]
plats_marocains.extend(autres_plats)

print("Plats marocains:", plats_marocains)

# Ajout avec l'opérateur +
villes_nord = ["Tétouan", "Chefchaouen"]
villes_sud = ["Laâyoune", "Dakhla"]
villes_maroc_complete = villes_maroc + villes_nord + villes_sud
print("Villes complètes:", villes_maroc_complete)

Supprimer des éléments (remove, pop, del, clear)

Plusieurs méthodes permettent de supprimer des éléments d'une liste : remove() pour supprimer par valeur, pop() pour supprimer par index, del pour supprimer par index ou tranche, et clear() pour vider la liste.

supprimer_elements.py
# Liste de monuments marocains
monuments = ["Hassan II", "Koutoubia", "Chellah", "Kasbah des Oudaias", "Volubilis"]
print("Monuments initiaux:", monuments)

# Suppression avec remove() - par valeur
monuments.remove("Chellah")
print("Après remove('Chellah'):", monuments)

# Suppression avec pop() - par index (retourne l'élément supprimé)
dernier_monument = monuments.pop()
print(f"Après pop(): {monuments}, élément supprimé: {dernier_monument}")

premier_monument = monuments.pop(0)
print(f"Après pop(0): {monuments}, élément supprimé: {premier_monument}")

# Suppression avec del - par index ou tranche
del monuments[0]  # Supprime le premier élément restant
print("Après del monuments[0]:", monuments)

# Recréons une liste pour d'autres exemples
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir"]

# Suppression avec del et slicing
del villes_maroc[1:3]  # Supprime les éléments aux index 1 et 2
print("Après del villes_maroc[1:3]:", villes_maroc)

# Suppression avec clear() - vide complètement la liste
villes_maroc.clear()
print("Après clear():", villes_maroc)

# Exemple avec des plats marocains
plats = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui"]

# Supprimer un plat spécifique
if "Harira" in plats:
    plats.remove("Harira")

# Supprimer le dernier plat
dernier_plat = plats.pop()

print("Plats restants:", plats)
print("Dernier plat supprimé:", dernier_plat)

Modifier des éléments existants

Pour modifier des éléments existants dans une liste, on utilise l'indexation directe ou le slicing pour remplacer une partie de la liste.

modifier_elements.py
# Liste de villes marocaines
villes_maroc = ["Casa", "Rabat", "Marrakech", "Fès", "Tanger"]
print("Villes initiales:", villes_maroc)

# Modification d'un élément par index
villes_maroc[0] = "Casablanca"  # Remplace "Casa" par "Casablanca"
print("Après modification index 0:", villes_maroc)

# Modification avec index négatif
villes_maroc[-1] = "Tanger Ville"  # Modifie le dernier élément
print("Après modification dernier élément:", villes_maroc)

# Modification de plusieurs éléments avec slicing
villes_maroc[1:3] = ["Rabat Capital", "Marrakech City"]  # Remplace 2 éléments
print("Après modification par slicing:", villes_maroc)

# Modification avec remplacement de plusieurs éléments par un seul
villes_maroc[2:4] = ["Fès Médina"]  # Remplace 2 éléments par 1
print("Après remplacement multiple:", villes_maroc)

# Exemple avec des spécialités régionales
specialites = ["Tajine", "Couscous", "Pastilla", "Harira"]

# Ajouter des détails aux spécialités
specialites[0] = "Tajine de poulet"
specialites[1] = "Couscous aux légumes"
specialites[3] = "Harira traditionnelle"

# Remplacer une partie de la liste
specialites[2:] = ["Pastilla au pigeon", "Méchoui", "Rfissa"]

print("Spécialités détaillées:", specialites)

# Exemple avec des données numériques (populations de villes)
populations = [3500000, 1800000, 1000000, 1200000, 800000]

# Mise à jour des populations
populations[0] = 3700000  # Casablanca
populations[1] = 1900000  # Rabat
populations[-1] = 900000   # Tanger

# Ajouter une nouvelle ville avec sa population
populations.append(700000)  # Agadir

print("Populations mises à jour:", populations)

Parcourir et itérer sur les listes

Python offre plusieurs méthodes pour parcourir et itérer sur les éléments d'une liste, permettant de traiter chaque élément selon les besoins.

Boucles for et while avec les listes

Les boucles for et while sont les méthodes fondamentales pour parcourir les listes en Python.

boucles_listes.py
# Liste de villes marocaines
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]

# Boucle for simple pour parcourir les éléments
print("Villes du Maroc (for simple):")
for ville in villes_maroc:
    print(f"- {ville}")

# Boucle for avec range() et len() pour accéder aux index
print("\nVilles avec leurs index (for avec range):")
for i in range(len(villes_maroc)):
    print(f"Index {i}: {villes_maroc[i]}")

# Boucle while pour parcourir la liste
print("\nVilles du Maroc (while):")
i = 0
while i < len(villes_maroc):
    print(f"- {villes_maroc[i]}")
    i += 1

# Exemple avec des plats marocains et modification pendant l'itération
plats_marocains = ["tajine", "couscous", "pastilla", "harira"]
print("\nPlats marocains en majuscules:")
for i in range(len(plats_marocains)):
    plats_marocains[i] = plats_marocains[i].upper()
    print(plats_marocains[i])

# Parcours avec condition
populations = [3500000, 1800000, 1000000, 1200000]
villes = ["Casablanca", "Rabat", "Marrakech", "Fès"]

print("\nVilles de plus d'un million d'habitants:")
for i in range(len(villes)):
    if populations[i] > 1000000:
        print(f"{villes[i]}: {populations[i]} habitants")

Utiliser enumerate() et zip()

Les fonctions enumerate() et zip() sont très utiles pour itérer sur les listes avec des index ou combiner plusieurs listes.

enumerate_zip.py
# Liste de spécialités marocaines
specialites = ["Tajine", "Couscous", "Pastilla", "Harira"]

# Utilisation de enumerate() pour avoir à la fois l'index et la valeur
print("Spécialités marocaines avec enumerate():")
for index, specialite in enumerate(specialites):
    print(f"{index + 1}. {specialite}")

# enumerate() avec début personnalisé
print("\nSpécialités avec numérotation personnalisée:")
for index, specialite in enumerate(specialites, start=1):
    print(f"Spécialité #{index}: {specialite}")

# Utilisation de zip() pour itérer sur plusieurs listes simultanément
villes = ["Casablanca", "Rabat", "Marrakech"]
populations = [3500000, 1800000, 1000000]
superficies = [324, 118, 230]  # en km²

print("\nInformations sur les villes (avec zip()):")
for ville, population, superficie in zip(villes, populations, superficies):
    densite = population / superficie  # habitants par km²
    print(f"{ville}: {population} habitants, {superficie} km², densité: {densite:.0f} hab/km²")

# Combinaison de enumerate() et zip()
regions = ["Casablanca-Settat", "Rabat-Salé-Kénitra", "Marrakech-Safi"]
capitales = ["Casablanca", "Rabat", "Marrakech"]

print("\nRégions et leurs capitales:")
for i, (region, capitale) in enumerate(zip(regions, capitales), 1):
    print(f"{i}. {region} - Capitale: {capitale}")

# zip() avec des listes de longueurs différentes
plats_principaux = ["Tajine", "Couscous", "Pastilla"]
plats_accompagnement = ["Salade marocaine", "Harira"]

print("\nMenus marocains (zip avec listes de longueurs différentes):")
for principal, accompagnement in zip(plats_principaux, plats_accompagnement):
    print(f"Plat: {principal}, Accompagnement: {accompagnement}")

# Conversion du résultat de zip() en liste
menus_complets = list(zip(plats_principaux, plats_accompagnement))
print(f"\nMenus complets: {menus_complets}")

List comprehensions (compréhensions de liste)

Les compréhensions de liste offrent une syntaxe concise pour créer des listes à partir d'itérables, avec possibilité de filtrage et de transformation.

comprehensions_listes.py
# Liste de villes marocaines
villes = ["casablanca", "rabat", "marrakech", "fès", "tanger"]

# Compréhension simple: mettre les villes en majuscules
villes_majuscules = [ville.upper() for ville in villes]
print("Villes en majuscules:", villes_majuscules)

# Compréhension avec condition: villes avec plus de 6 lettres
villes_longues = [ville for ville in villes if len(ville) > 6]
print("Villes avec plus de 6 lettres:", villes_longues)

# Compréhension avec transformation conditionnelle
villes_formatees = [ville.title() if len(ville) > 4 else ville.upper() for ville in villes]
print("Villes formatées:", villes_formatees)

# Compréhension avec des données numériques
populations = [3500000, 1800000, 1000000, 1200000, 800000]

# Villes de plus d'un million d'habitants
villes_grandes = [villes[i] for i in range(len(populations)) if populations[i] > 1000000]
print("Villes de plus d'un million d'habitants:", villes_grandes)

# Population en millions
populations_millions = [pop / 1000000 for pop in populations]
print("Populations en millions:", populations_millions)

# Compréhension de liste imbriquée
regions = ["Nord", "Centre", "Sud"]
villes_par_region = [
    ["Tanger", "Tétouan"],  # Nord
    ["Casablanca", "Rabat"],  # Centre
    ["Marrakech", "Agadir"]   # Sud
]

# Aplatir la liste de listes
toutes_villes = [ville for region in villes_par_region for ville in region]
print("Toutes les villes:", toutes_villes)

# Compréhension avec enumerate
villes_indexees = [f"{i+1}. {ville}" for i, ville in enumerate(villes)]
print("Villes indexées:", villes_indexees)

# Compréhension avec zip
infos_villes = [f"{ville.title()}: {pop/1000000:.1f}M" for ville, pop in zip(villes, populations)]
print("Infos villes:", infos_villes)

Méthodes essentielles des listes

Python offre de nombreuses méthodes intégrées pour manipuler les listes, notamment pour la recherche, le tri, la copie et la transformation des données.

Recherche et tri (sort, reverse, index, count)

Les méthodes de recherche et de tri permettent d'organiser et de trouver des éléments dans une liste.

recherche_tri.py
# Liste de villes marocaines
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir", "Meknès"]

# Trier la liste par ordre alphabétique avec sort()
villes_maroc.sort()
print("Villes triées par ordre alphabétique:", villes_maroc)

# Trier en ordre inverse avec reverse=True
villes_maroc.sort(reverse=True)
print("Villes triées par ordre inverse:", villes_maroc)

# Inverser l'ordre de la liste avec reverse()
villes_maroc.reverse()
print("Villes inversées:", villes_maroc)

# Trouver l'index d'un élément avec index()
index_rabat = villes_maroc.index("Rabat")
index_marrakech = villes_maroc.index("Marrakech")
print(f"Index de Rabat: {index_rabat}, Index de Marrakech: {index_marrakech}")

# Compter les occurrences avec count()
villes_avec_a = [ville for ville in villes_maroc if 'a' in ville.lower()]
nombre_villes_avec_a = len(villes_avec_a)
print(f"Nombre de villes contenant 'a': {nombre_villes_avec_a}")

# Exemple avec des populations
populations = [3500000, 1800000, 1000000, 1200000, 800000, 600000]

# Trier les populations
populations.sort()
print("Populations triées (croissant):", populations)

populations.sort(reverse=True)
print("Populations triées (décroissant):", populations)

# Trouver l'index de la ville la plus peuplée
population_max = max(populations)
index_max = populations.index(population_max)
print(f"Population maximale: {population_max} à l'index {index_max}")

# Compter les villes avec plus d'un million d'habitants
villes_grandes = sum(1 for pop in populations if pop > 1000000)
print(f"Nombre de villes avec plus d'un million d'habitants: {villes_grandes}")

Copier des listes (copy vs deepcopy)

Il est important de comprendre la différence entre copie superficielle (shallow copy) et copie profonde (deep copy) pour éviter les modifications involontaires.

copier_listes.py
# Copie superficielle avec copy()
villes_maroc = ["Casablanca", "Rabat", "Marrakech"]
villes_copie = villes_maroc.copy()

# Modification de la copie n'affecte pas l'original
villes_copie.append("Fès")
print("Original:", villes_maroc)
print("Copie:", villes_copie)

# Copie avec slicing (équivalent à copy())
villes_copie_slice = villes_maroc[:]
villes_copie_slice.append("Tanger")
print("Original après slice copy:", villes_maroc)
print("Copie par slicing:", villes_copie_slice)

# Problème avec les listes imbriquées (copie superficielle)
regions_maroc = ["Casablanca-Settat", ["Casablanca", "Settat"]]
regions_copie = regions_maroc.copy()

# Modification de la sous-liste affecte l'original et la copie
regions_copie[1].append("Mohammedia")
print("Original avec liste imbriquée:", regions_maroc)
print("Copie avec liste imbriquée:", regions_copie)

# Solution: copie profonde avec le module copy
import copy

regions_maroc_deep = ["Casablanca-Settat", ["Casablanca", "Settat"]]
regions_deepcopy = copy.deepcopy(regions_maroc_deep)

# Modification de la copie profonde n'affecte pas l'original
regions_deepcopy[1].append("Berrechid")
print("Original après deepcopy:", regions_maroc_deep)
print("Deepcopy modifiée:", regions_deepcopy)

# Exemple avec des données complexes
donnees_maroc = [
    {"ville": "Casablanca", "population": 3500000},
    {"ville": "Rabat", "population": 1800000},
    ["Marrakech", "Fès"]
]

# Copie superficielle vs profonde
donnees_copie = donnees_maroc.copy()
donnees_deepcopy = copy.deepcopy(donnees_maroc)

# Modification affecte l'original avec copy() mais pas avec deepcopy()
donnees_copie[0]["population"] = 4000000
donnees_deepcopy[1]["population"] = 2000000

print("Original données:", donnees_maroc)
print("Copie superficielle:", donnees_copie)
print("Copie profonde:", donnees_deepcopy)

Joindre et diviser (join, split)

Les méthodes join() et split() permettent de convertir entre chaînes de caractères et listes.

joindre_diviser.py
# Liste de villes marocaines
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]

# Joindre les éléments avec join()
villes_string = ", ".join(villes_maroc)
print("Villes jointes avec ', ':", villes_string)

villes_slash = " / ".join(villes_maroc)
print("Villes jointes avec ' / ':", villes_slash)

# Joindre avec un saut de ligne
villes_lignes = "\n".join(villes_maroc)
print("Villes par ligne:")
print(villes_lignes)

# Diviser une chaîne avec split()
texte_villes = "Casablanca,Rabat,Marrakech,Fès,Tanger"
villes_liste = texte_villes.split(",")
print("Liste à partir de chaîne séparée par des virgules:", villes_liste)

texte_phrase = "Le Maroc est un pays magnifique"
mots = texte_phrase.split()
print("Mots de la phrase:", mots)

# Diviser avec un maximum de splits
adresse = "123,Rue Mohammed V,Casablanca,Maroc"
adresse_split = adresse.split(",", 2)
print("Adresse split avec max 2:", adresse_split)

# Exemple pratique: traitement de données
donnees_brutes = "Casablanca:3500000|Rabat:1800000|Marrakech:1000000|Fès:1200000"
villes_populations = []

# Séparer d'abord par | puis par :
for ville_data in donnees_brutes.split("|"):
    ville, population = ville_data.split(":")
    villes_populations.append({"ville": ville, "population": int(population)})

print("Données structurées:", villes_populations)

# Recréer la chaîne de données
donnees_reconstruites = "|".join(
    [f"{ville['ville']}:{ville['population']}" for ville in villes_populations]
)
print("Données reconstruites:", donnees_reconstruites)

# Exemple avec des plats marocains
plats_string = "Tajine-Couscous-Pastilla-Harira-Méchoui"
plats_liste = plats_string.split("-")
plats_liste_tries = sorted(plats_liste)
plats_tries_string = ", ".join(plats_liste_tries)

print("Plats séparés par '-':", plats_liste)
print("Plats triés et jointes par ', ':", plats_tries_string)

Listes avancées et techniques

Les techniques avancées de manipulation des listes permettent de résoudre des problèmes complexes et d'optimiser les performances de votre code.

Listes imbriquées (listes de listes)

Les listes imbriquées permettent de représenter des structures de données complexes comme des matrices ou des collections hiérarchiques.

listes_imbriquees.py
# Représentation des régions marocaines et leurs villes principales
regions_maroc = [
    ["Tanger-Tétouan-Al Hoceïma", "Tanger", "Tétouan", "Al Hoceïma"],
    ["Oriental", "Oujda", "Nador", "Berkane"],
    ["Fès-Meknès", "Fès", "Meknès", "Ifrane"],
    ["Rabat-Salé-Kénitra", "Rabat", "Salé", "Kénitra"],
    ["Casablanca-Settat", "Casablanca", "Settat", "Mohammedia"]
]

# Accès aux éléments des listes imbriquées
region_rabat = regions_maroc[3]
nom_region = region_rabat[0]
villes_region = region_rabat[1:]

print("Région de Rabat:", nom_region)
print("Villes de la région:", villes_region)

# Parcours des listes imbriquées
print("\nToutes les régions et leurs villes:")
for region in regions_maroc:
    nom_region = region[0]
    villes = region[1:]
    print(f"{nom_region}: {', '.join(villes)}")

# Matrice de distances entre villes marocaines (en km)
distances = [
    [0, 240, 580, 320, 510],  # De Casablanca
    [240, 0, 330, 140, 270],   # De Rabat
    [580, 330, 0, 470, 650],   # De Marrakech
    [320, 140, 470, 0, 410],   # De Fès
    [510, 270, 650, 410, 0]    # De Tanger
]

villes = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]

# Trouver la distance entre deux villes
ville_depart = "Rabat"
ville_arrivee = "Fès"

index_depart = villes.index(ville_depart)
index_arrivee = villes.index(ville_arrivee)
distance = distances[index_depart][index_arrivee]

print(f"\nDistance entre {ville_depart} et {ville_arrivee}: {distance} km")

# Liste imbriquée de plats marocains par région
specialites_regionales = [
    ["Nord", "Bissara", "Pastilla au pigeon"],
    ["Centre", "Tajine", "Couscous", "Harira"],
    ["Sud", "Méchoui", "Tanjia", "Rfissa"]
]

# Transformation en dictionnaire
specialites_dict = {}
for region_data in specialites_regionales:
    region = region_data[0]
    plats = region_data[1:]
    specialites_dict[region] = plats

print("\nSpécialités par région:", specialites_dict)

Filtrage et transformation de données

Le filtrage et la transformation des données sont essentiels pour le traitement des listes et l'extraction d'informations pertinentes.

filtrage_transformation.py
# Données des villes marocaines avec population et région
villes_maroc = [
    {"nom": "Casablanca", "population": 3500000, "region": "Casablanca-Settat"},
    {"nom": "Rabat", "population": 1800000, "region": "Rabat-Salé-Kénitra"},
    {"nom": "Marrakech", "population": 1000000, "region": "Marrakech-Safi"},
    {"nom": "Fès", "population": 1200000, "region": "Fès-Meknès"},
    {"nom": "Tanger", "population": 800000, "region": "Tanger-Tétouan-Al Hoceïma"},
    {"nom": "Agadir", "population": 600000, "region": "Souss-Massa"}
]

# Filtrage: villes de plus d'un million d'habitants
villes_grandes = [ville for ville in villes_maroc if ville["population"] > 1000000]
print("Villes de plus d'un million d'habitants:")
for ville in villes_grandes:
    print(f"{ville['nom']}: {ville['population']} habitants")

# Transformation: noms de villes en majuscules
noms_majuscules = [ville["nom"].upper() for ville in villes_maroc]
print("\nNoms des villes en majuscules:", noms_majuscules)

# Agrégation: population totale par région
population_par_region = {}
for ville in villes_maroc:
    region = ville["region"]
    population = ville["population"]
    if region in population_par_region:
        population_par_region[region] += population
    else:
        population_par_region[region] = population

print("\nPopulation par région:")
for region, population in population_par_region.items():
    print(f"{region}: {population} habitants")

# Filtrage avancé avec plusieurs conditions
villes_selection = [
    ville for ville in villes_maroc
    if ville["population"] > 700000 and "a" in ville["nom"].lower()
]
print("\nVilles avec plus de 700k habitants contenant 'a':")
for ville in villes_selection:
    print(ville["nom"])

# Transformation avec map() et filter()
noms_villes = list(map(lambda x: x["nom"], villes_maroc))
villes_nord = list(filter(lambda x: "Tanger" in x["region"], villes_maroc))

print("\nNoms de toutes les villes:", noms_villes)
print("Villes du nord:", [ville["nom"] for ville in villes_nord])

# Tri complexe: par région puis par population décroissante
villes_triees = sorted(
    villes_maroc,
    key=lambda x: (x["region"], -x["population"])
)

print("\nVilles triées par région et population décroissante:")
for ville in villes_triees:
    print(f"{ville['region']}: {ville['nom']} ({ville['population']})")

Performance et optimisation

L'optimisation des performances est cruciale lorsqu'on travaille avec de grandes listes ou des opérations intensives.

performance_optimisation.py
# Comparaison des performances pour de grandes listes
import time

# Création d'une grande liste de villes simulées
noms_villes = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir", "Meknès"]
grande_liste = noms_villes * 10000  # 70,000 éléments

# Méthode 1: Recherche avec 'in' (lent pour les grandes listes)
debut = time.time()
trouve = "Marrakech" in grande_liste
temps_in = time.time() - debut

# Méthode 2: Conversion en set pour une recherche rapide
debut = time.time()
ensemble_villes = set(grande_liste)
trouve_set = "Marrakech" in ensemble_villes
temps_set = time.time() - debut

print(f"Temps avec 'in' sur liste: {temps_in:.6f} secondes")
print(f"Temps avec set: {temps_set:.6f} secondes")
print(f"Set est {temps_in/temps_set:.1f} fois plus rapide")

# Optimisation des concaténations de listes
villes_nord = ["Tanger", "Tétouan", "Larache"]
villes_sud = ["Agadir", "Marrakech", "Ouarzazate"]
villes_est = ["Oujda", "Figuig", "Berkane"]

# Méthode non optimisée (création de nouvelles listes)
toutes_villes = villes_nord + villes_sud + villes_est

# Méthode optimisée avec extend() (modification sur place)
toutes_villes_opt = []
toutes_villes_opt.extend(villes_nord)
toutes_villes_opt.extend(villes_sud)
toutes_villes_opt.extend(villes_est)

# Pour de très grandes opérations, utiliser itertools.chain()
import itertools
toutes_villes_chain = list(itertools.chain(villes_nord, villes_sud, villes_est))

print("\nNombre total de villes:", len(toutes_villes_opt))

# Optimisation des compréhensions de liste
populations = [3500000, 1800000, 1000000, 1200000, 800000, 600000]

# Méthode non optimisée: deux passes sur la liste
villes_grandes = [pop for pop in populations if pop > 1000000]
moyenne = sum(villes_grandes) / len(villes_grandes) if villes_grandes else 0

# Méthode optimisée: une seule passe
total = 0
count = 0
for pop in populations:
    if pop > 1000000:
        total += pop
        count += 1
moyenne_opt = total / count if count > 0 else 0

print(f"Moyenne des grandes villes: {moyenne_opt:.0f} habitants")

# Utilisation de générateurs pour économiser la mémoire
print("\nCréation d'une liste de grandes villes avec générateur:")

# Sans générateur (crée toute la liste en mémoire)
villes_grandes_liste = [ville for ville in villes_maroc if ville["population"] > 1000000]

# Avec générateur (évalue paresseusement)
villes_grandes_gen = (ville for ville in villes_maroc if ville["population"] > 1000000)

print("Avec liste:", len(villes_grandes_liste), "villes")
print("Avec générateur:", sum(1 for _ in villes_grandes_gen), "villes")

# Optimisation du tri
villes_a_trier = villes_maroc.copy()

# Tri avec key optimisé (meilleure performance)
debut = time.time()
villes_triees = sorted(villes_a_trier, key=lambda x: x["population"])
temps_tri_key = time.time() - debut

print(f"\nTemps de tri avec key: {temps_tri_key:.6f} secondes")

Listes avancées et techniques

Les techniques avancées de manipulation des listes permettent de résoudre des problèmes complexes et d'optimiser les performances de votre code.

Listes imbriquées (listes de listes)

Les listes imbriquées permettent de représenter des structures de données complexes comme des matrices ou des collections hiérarchiques.

listes_imbriquees.py
# Représentation des régions marocaines et leurs villes principales
regions_maroc = [
    ["Tanger-Tétouan-Al Hoceïma", "Tanger", "Tétouan", "Al Hoceïma"],
    ["Oriental", "Oujda", "Nador", "Berkane"],
    ["Fès-Meknès", "Fès", "Meknès", "Ifrane"],
    ["Rabat-Salé-Kénitra", "Rabat", "Salé", "Kénitra"],
    ["Casablanca-Settat", "Casablanca", "Settat", "Mohammedia"]
]

# Accès aux éléments des listes imbriquées
region_rabat = regions_maroc[3]
nom_region = region_rabat[0]
villes_region = region_rabat[1:]

print("Région de Rabat:", nom_region)
print("Villes de la région:", villes_region)

# Parcours des listes imbriquées
print("\nToutes les régions et leurs villes:")
for region in regions_maroc:
    nom_region = region[0]
    villes = region[1:]
    print(f"{nom_region}: {', '.join(villes)}")

# Matrice de distances entre villes marocaines (en km)
distances = [
    [0, 240, 580, 320, 510],  # De Casablanca
    [240, 0, 330, 140, 270],   # De Rabat
    [580, 330, 0, 470, 650],   # De Marrakech
    [320, 140, 470, 0, 410],   # De Fès
    [510, 270, 650, 410, 0]    # De Tanger
]

villes = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]

# Trouver la distance entre deux villes
ville_depart = "Rabat"
ville_arrivee = "Fès"

index_depart = villes.index(ville_depart)
index_arrivee = villes.index(ville_arrivee)
distance = distances[index_depart][index_arrivee]

print(f"\nDistance entre {ville_depart} et {ville_arrivee}: {distance} km")

# Liste imbriquée de plats marocains par région
specialites_regionales = [
    ["Nord", "Bissara", "Pastilla au pigeon"],
    ["Centre", "Tajine", "Couscous", "Harira"],
    ["Sud", "Méchoui", "Tanjia", "Rfissa"]
]

# Transformation en dictionnaire
specialites_dict = {}
for region_data in specialites_regionales:
    region = region_data[0]
    plats = region_data[1:]
    specialites_dict[region] = plats

print("\nSpécialités par région:", specialites_dict)

Filtrage et transformation de données

Le filtrage et la transformation des données sont essentiels pour le traitement des listes et l'extraction d'informations pertinentes.

filtrage_transformation.py
# Données des villes marocaines avec population et région
villes_maroc = [
    {"nom": "Casablanca", "population": 3500000, "region": "Casablanca-Settat"},
    {"nom": "Rabat", "population": 1800000, "region": "Rabat-Salé-Kénitra"},
    {"nom": "Marrakech", "population": 1000000, "region": "Marrakech-Safi"},
    {"nom": "Fès", "population": 1200000, "region": "Fès-Meknès"},
    {"nom": "Tanger", "population": 800000, "region": "Tanger-Tétouan-Al Hoceïma"},
    {"nom": "Agadir", "population": 600000, "region": "Souss-Massa"}
]

# Filtrage: villes de plus d'un million d'habitants
villes_grandes = [ville for ville in villes_maroc if ville["population"] > 1000000]
print("Villes de plus d'un million d'habitants:")
for ville in villes_grandes:
    print(f"{ville['nom']}: {ville['population']} habitants")

# Transformation: noms de villes en majuscules
noms_majuscules = [ville["nom"].upper() for ville in villes_maroc]
print("\nNoms des villes en majuscules:", noms_majuscules)

# Agrégation: population totale par région
population_par_region = {}
for ville in villes_maroc:
    region = ville["region"]
    population = ville["population"]
    if region in population_par_region:
        population_par_region[region] += population
    else:
        population_par_region[region] = population

print("\nPopulation par région:")
for region, population in population_par_region.items():
    print(f"{region}: {population} habitants")

# Filtrage avancé avec plusieurs conditions
villes_selection = [
    ville for ville in villes_maroc
    if ville["population"] > 700000 and "a" in ville["nom"].lower()
]
print("\nVilles avec plus de 700k habitants contenant 'a':")
for ville in villes_selection:
    print(ville["nom"])

# Transformation avec map() et filter()
noms_villes = list(map(lambda x: x["nom"], villes_maroc))
villes_nord = list(filter(lambda x: "Tanger" in x["region"], villes_maroc))

print("\nNoms de toutes les villes:", noms_villes)
print("Villes du nord:", [ville["nom"] for ville in villes_nord])

# Tri complexe: par région puis par population décroissante
villes_triees = sorted(
    villes_maroc,
    key=lambda x: (x["region"], -x["population"])
)

print("\nVilles triées par région et population décroissante:")
for ville in villes_triees:
    print(f"{ville['region']}: {ville['nom']} ({ville['population']})")

Performance et optimisation

L'optimisation des performances est cruciale lorsqu'on travaille avec de grandes listes ou des opérations intensives.

performance_optimisation.py
# Comparaison des performances pour de grandes listes
import time

# Création d'une grande liste de villes simulées
noms_villes = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir", "Meknès"]
grande_liste = noms_villes * 10000  # 70,000 éléments

# Méthode 1: Recherche avec 'in' (lent pour les grandes listes)
debut = time.time()
trouve = "Marrakech" in grande_liste
temps_in = time.time() - debut

# Méthode 2: Conversion en set pour une recherche rapide
debut = time.time()
ensemble_villes = set(grande_liste)
trouve_set = "Marrakech" in ensemble_villes
temps_set = time.time() - debut

print(f"Temps avec 'in' sur liste: {temps_in:.6f} secondes")
print(f"Temps avec set: {temps_set:.6f} secondes")
print(f"Set est {temps_in/temps_set:.1f} fois plus rapide")

# Optimisation des concaténations de listes
villes_nord = ["Tanger", "Tétouan", "Larache"]
villes_sud = ["Agadir", "Marrakech", "Ouarzazate"]
villes_est = ["Oujda", "Figuig", "Berkane"]

# Méthode non optimisée (création de nouvelles listes)
toutes_villes = villes_nord + villes_sud + villes_est

# Méthode optimisée avec extend() (modification sur place)
toutes_villes_opt = []
toutes_villes_opt.extend(villes_nord)
toutes_villes_opt.extend(villes_sud)
toutes_villes_opt.extend(villes_est)

# Pour de très grandes opérations, utiliser itertools.chain()
import itertools
toutes_villes_chain = list(itertools.chain(villes_nord, villes_sud, villes_est))

print("\nNombre total de villes:", len(toutes_villes_opt))

# Optimisation des compréhensions de liste
populations = [3500000, 1800000, 1000000, 1200000, 800000, 600000]

# Méthode non optimisée: deux passes sur la liste
villes_grandes = [pop for pop in populations if pop > 1000000]
moyenne = sum(villes_grandes) / len(villes_grandes) if villes_grandes else 0

# Méthode optimisée: une seule passe
total = 0
count = 0
for pop in populations:
    if pop > 1000000:
        total += pop
        count += 1
moyenne_opt = total / count if count > 0 else 0

print(f"Moyenne des grandes villes: {moyenne_opt:.0f} habitants")

# Utilisation de générateurs pour économiser la mémoire
print("\nCréation d'une liste de grandes villes avec générateur:")

# Sans générateur (crée toute la liste en mémoire)
villes_grandes_liste = [ville for ville in villes_maroc if ville["population"] > 1000000]

# Avec générateur (évalue paresseusement)
villes_grandes_gen = (ville for ville in villes_maroc if ville["population"] > 1000000)

print("Avec liste:", len(villes_grandes_liste), "villes")
print("Avec générateur:", sum(1 for _ in villes_grandes_gen), "villes")

# Optimisation du tri
villes_a_trier = villes_maroc.copy()

# Tri avec key optimisé (meilleure performance)
debut = time.time()
villes_triees = sorted(villes_a_trier, key=lambda x: x["population"])
temps_tri_key = time.time() - debut

print(f"\nTemps de tri avec key: {temps_tri_key:.6f} secondes")

Cas d'usage pratiques

Les listes Python sont utilisées dans de nombreux scénarios pratiques, de la gestion de données utilisateur aux algorithmes complexes en passant par la manipulation de fichiers.

Gestion de données utilisateur

Les listes sont idéales pour gérer des collections de données utilisateur, comme des profils, des préférences ou des historiques.

gestion_donnees_utilisateur.py
# Gestion d'une liste d'utilisateurs marocains
utilisateurs = [
    {"nom": "Ahmed Alami", "ville": "Casablanca", "age": 28, "interests": ["technologie", "voyage"]},
    {"nom": "Fatima Zahra", "ville": "Rabat", "age": 32, "interests": ["cuisine", "art"]},
    {"nom": "Mehdi Bennani", "ville": "Marrakech", "age": 25, "interests": ["sport", "musique"]},
    {"nom": "Youssef Cherkaoui", "ville": "Fès", "age": 35, "interests": ["histoire", "photographie"]}
]

# Ajouter un nouvel utilisateur
nouvel_utilisateur = {
    "nom": "Amina Toumi",
    "ville": "Tanger",
    "age": 29,
    "interests": ["lecture", "randonnée"]
}
utilisateurs.append(nouvel_utilisateur)

# Filtrer les utilisateurs par ville
utilisateurs_casablanca = [
    user for user in utilisateurs
    if user["ville"].lower() == "casablanca"
]

# Trouver les utilisateurs de plus de 30 ans
utilisateurs_ages = [
    user for user in utilisateurs
    if user["age"] > 30
]

# Compter les utilisateurs par ville
ville_count = {}
for user in utilisateurs:
    ville = user["ville"]
    ville_count[ville] = ville_count.get(ville, 0) + 1

# Trier les utilisateurs par âge
utilisateurs_tries = sorted(utilisateurs, key=lambda x: x["age"])

# Afficher les résultats
print("Utilisateurs de Casablanca:")
for user in utilisateurs_casablanca:
    print(f"- {user['nom']} ({user['age']} ans)")

print(f"\nUtilisateurs par ville: {ville_count}")

# Gestion des intérêts communs
tous_interests = set()
for user in utilisateurs:
    tous_interests.update(user["interests"])

print(f"\nTous les intérêts: {sorted(tous_interests)}")

# Recherche d'utilisateurs par intérêt
interet_recherche = "voyage"
utilisateurs_voyage = [
    user["nom"] for user in utilisateurs
    if interet_recherche in user["interests"]
]

print(f"\nUtilisateurs intéressés par {interet_recherche}: {utilisateurs_voyage}")

Manipulation de fichiers et parsing

Les listes sont essentielles pour lire, traiter et manipuler des données à partir de fichiers.

manipulation_fichiers.py
# Simulation de données de villes marocaines à partir d'un fichier
donnees_brutes = """
Casablanca|33.5731|-7.5898|3500000|Casablanca-Settat
Rabat|34.0209|-6.8416|1800000|Rabat-Salé-Kénitra
Marrakech|31.6295|-7.9811|1000000|Marrakech-Safi
Fès|34.0331|-5.0003|1200000|Fès-Meknès
Tanger|35.7595|-5.8340|800000|Tanger-Tétouan-Al Hoceïma
Agadir|30.4278|-9.5981|600000|Souss-Massa
"""

# Lire les données ligne par ligne (simulation de lecture fichier)
lignes = donnees_brutes.strip().split('\n')

# Parser les données dans une liste de dictionnaires
villes = []
for ligne in lignes:
    elements = ligne.split('|')
    ville_data = {
        "nom": elements[0],
        "latitude": float(elements[1]),
        "longitude": float(elements[2]),
        "population": int(elements[3]),
        "region": elements[4]
    }
    villes.append(ville_data)

# Filtrer les villes de plus d'un million d'habitants
villes_importantes = [
    ville for ville in villes
    if ville["population"] > 1000000
]

# Trier par population décroissante
villes_triees = sorted(villes, key=lambda x: x["population"], reverse=True)

# Générer un rapport
rapport = []
rapport.append("RAPPORT SUR LES VILLES MAROCAINES")
rapport.append("=" * 40)
rapport.append(f"Nombre total de villes: {len(villes)}")
rapport.append(f"Villes de plus d'un million: {len(villes_importantes)}")
rapport.append("")
rapport.append("TOP 3 des villes les plus peuplées:")

for i, ville in enumerate(villes_triees[:3], 1):
    rapport.append(f"{i}. {ville['nom']}: {ville['population']} habitants")

# Écrire le rapport dans un fichier (simulation)
rapport_content = '\n'.join(rapport)
print(rapport_content)

# Traitement de données CSV (simulation)
donnees_csv = """
nom,population,region,superficie_km2
Casablanca,3500000,Casablanca-Settat,324
Rabat,1800000,Rabat-Salé-Kénitra,118
Marrakech,1000000,Marrakech-Safi,230
Fès,1200000,Fès-Meknès,500
Tanger,800000,Tanger-Tétouan-Al Hoceïma,200
"""

# Parser le CSV
lignes_csv = donnees_csv.strip().split('\n')
entetes = lignes_csv[0].split(',')
villes_csv = []

for ligne in lignes_csv[1:]:
    valeurs = ligne.split(',')
    ville_dict = {entetes[i]: valeurs[i] for i in range(len(entetes))}
    villes_csv.append(ville_dict)

# Calculer la densité de population
for ville in villes_csv:
    population = int(ville["population"])
    superficie = int(ville["superficie_km2"])
    ville["densite"] = population / superficie

print("\nDonnées CSV avec densité:")
for ville in villes_csv:
    print(f"{ville['nom']}: {ville['densite']:.0f} hab/km²")

Algorithmes courants avec les listes

De nombreux algorithmes classiques utilisent les listes comme structure de données principale.

algorithmes_listes.py
# 1. Algorithme de recherche
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir"]

# Recherche linéaire
def recherche_lineaire(liste, cible):
    for i, element in enumerate(liste):
        if element == cible:
            return i
    return -1

# Recherche binaire (liste doit être triée)
def recherche_binaire(liste, cible):
    gauche, droite = 0, len(liste) - 1
    while gauche <= droite:
        milieu = (gauche + droite) // 2
        if liste[milieu] == cible:
            return milieu
        elif liste[milieu] < cible:
            gauche = milieu + 1
        else:
            droite = milieu - 1
    return -1

# Test des algorithmes de recherche
ville_cible = "Fès"
index_lineaire = recherche_lineaire(villes_maroc, ville_cible)

villes_triees = sorted(villes_maroc)  # Pour la recherche binaire
index_binaire = recherche_binaire(villes_triees, ville_cible)

print(f"Recherche linéaire: '{ville_cible}' trouvé à l'index {index_lineaire}")
print(f"Recherche binaire: '{ville_cible}' trouvé à l'index {index_binaire}")

# 2. Algorithme de tri personnalisé
villes_population = [
    ("Casablanca", 3500000),
    ("Rabat", 1800000),
    ("Marrakech", 1000000),
    ("Fès", 1200000),
    ("Tanger", 800000)
]

# Tri par population (ordre décroissant)
def tri_par_population(liste):
    n = len(liste)
    for i in range(n):
        for j in range(0, n - i - 1):
            if liste[j][1] < liste[j + 1][1]:
                liste[j], liste[j + 1] = liste[j + 1], liste[j]
    return liste

villes_triees_pop = tri_par_population(villes_population.copy())
print("\nVilles triées par population (décroissant):")
for ville, pop in villes_triees_pop:
    print(f"{ville}: {pop} habitants")

# 3. Algorithme de pagination
def paginer_liste(liste, page, elements_par_page):
    debut = (page - 1) * elements_par_page
    fin = debut + elements_par_page
    return liste[debut:fin]

# Données à paginer
toutes_villes = [f"Ville {i}" for i in range(1, 51)]  # 50 villes

# Pagination
page_1 = paginer_liste(toutes_villes, 1, 10)
page_2 = paginer_liste(toutes_villes, 2, 10)
page_3 = paginer_liste(toutes_villes, 3, 10)

print(f"\nPage 1: {page_1}")
print(f"Page 2: {page_2}")
print(f"Page 3: {page_3}")

# 4. Algorithme de fusion de listes triées
def fusionner_listes_triees(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

# Test de fusion
villes_nord = ["Tanger", "Tétouan"]
villes_sud = ["Agadir", "Marrakech"]
villes_centre = ["Casablanca", "Rabat"]

toutes_villes_triees = fusionner_listes_triees(
    fusionner_listes_triees(villes_nord, villes_centre),
    villes_sud
)

print(f"\nVilles fusionnées et triées: {toutes_villes_triees}")

# 5. Algorithme de recherche des doublons
def trouver_doublons(liste):
    vus = set()
    doublons = []
    
    for element in liste:
        if element in vus:
            doublons.append(element)
        else:
            vus.add(element)
    
    return doublons

# Test de recherche de doublons
villes_avec_doublons = ["Casablanca", "Rabat", "Casablanca", "Marrakech", "Rabat"]
doublons = trouver_doublons(villes_avec_doublons)

print(f"\nDoublons trouvés: {doublons}")

Bonnes pratiques et pièges à éviter

Comprendre les bonnes pratiques et les erreurs courantes avec les listes Python permet d'écrire un code plus robuste, efficace et maintenable.

Erreurs communes avec les listes

Plusieurs erreurs sont fréquemment commises lors de l'utilisation des listes en Python. Les connaître permet de les éviter.

erreurs_communes.py
# 1. Modification d'une liste pendant son itération
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès"]

# ERREUR: Supprimer des éléments pendant l'itération
# for ville in villes_maroc:
#     if ville.startswith('M'):
#         villes_maroc.remove(ville)  # Provoque un comportement imprévisible

# SOLUTION: Créer une copie ou utiliser une compréhension de liste
villes_maroc = [ville for ville in villes_maroc if not ville.startswith('M')]
print("Villes sans 'M':", villes_maroc)

# 2. Utilisation incorrecte de la copie de liste
villes_nord = ["Tanger", "Tétouan", ["Chefchaouen", "Larache"]]
villes_copie = villes_nord.copy()  # Copie superficielle

# La sous-liste est toujours partagée!
villes_copie[2].append("Asilah")
print("Original modifié:", villes_nord)  # ['Tanger', 'Tétouan', ['Chefchaouen', 'Larache', 'Asilah']]

# SOLUTION: Utiliser copy.deepcopy() pour les listes imbriquées
import copy
villes_nord_deep = copy.deepcopy(villes_nord)
villes_nord_deep[2].append("Ouazzane")
print("Original intact:", villes_nord)
print("Deep copy modifiée:", villes_nord_deep)

# 3. Confusion entre append() et extend()
villes_maroc = ["Casablanca", "Rabat"]

# ERREUR: Utiliser append() pour ajouter plusieurs éléments
villes_maroc.append(["Marrakech", "Fès"])  # Ajoute une liste comme élément unique
print("Avec append() incorrect:", villes_maroc)

# SOLUTION: Utiliser extend() pour ajouter des éléments individuels
villes_maroc = ["Casablanca", "Rabat"]
villes_maroc.extend(["Marrakech", "Fès"])
print("Avec extend() correct:", villes_maroc)

# 4. Oubli des effets de bord avec les méthodes sur place
villes = ["Casablanca", "Rabat", "Marrakech"]
villes_triees = villes.sort()  # ERREUR: sort() retourne None!

print("villes_triees:", villes_triees)  # None
print("villes modifié:", villes)  # ['Casablanca', 'Marrakech', 'Rabat']

# SOLUTION: Utiliser sorted() pour une nouvelle liste
villes = ["Casablanca", "Rabat", "Marrakech"]
villes_triees = sorted(villes)
print("villes intact:", villes)
print("villes_triees:", villes_triees)

# 5. Index out of range
villes = ["Casablanca", "Rabat", "Marrakech"]

# ERREUR: Accéder à un index qui n'existe pas
try:
    ville = villes[5]  # IndexError
except IndexError as e:
    print(f"Erreur d'index: {e}")

# SOLUTION: Vérifier la longueur ou utiliser try/except
index = 5
if index < len(villes):
    ville = villes[index]
else:
    print(f"Index {index} hors limites")

Quand utiliser les listes vs autres structures

Le choix de la structure de données appropriée est crucial pour des performances optimales et un code clair.

choix_structures.py
# 1. Listes vs Tuples
# Utiliser un tuple pour des données immuables et hétérogènes
ville_rabat = ("Rabat", 34.02, -6.83, 1800000)  # nom, lat, long, population
# Utiliser une liste pour des données mutables
villes_maroc = ["Casablanca", "Rabat", "Marrakech"]

# 2. Listes vs Sets
# Utiliser un set pour les tests d'appartenance et l'élimination des doublons
villes_visitees = {"Casablanca", "Rabat", "Marrakech"}
if "Fès" in villes_visitees:  # Rapide avec les sets
    print("Fès déjà visitée")

# Utiliser une liste pour préserver l'ordre et permettre les doublons
itineraire = ["Casablanca", "Rabat", "Marrakech", "Casablanca"]

# 3. Listes vs Dictionnaires
# Utiliser un dictionnaire pour les données avec clés significatives
villes_info = {
    "Casablanca": {"population": 3500000, "region": "Casablanca-Settat"},
    "Rabat": {"population": 1800000, "region": "Rabat-Salé-Kénitra"}
}

# Utiliser une liste pour des séquences ordonnées
villes_ordre = ["Casablanca", "Rabat", "Marrakech"]

# 4. Exemples concrets avec des données marocaines
# Mauvais: Liste de tuples pour recherche fréquente
villes_population = [
    ("Casablanca", 3500000),
    ("Rabat", 1800000),
    ("Marrakech", 1000000)
]
# Recherche lente: O(n)
for ville, pop in villes_population:
    if ville == "Rabat":
        print(pop)

# Meilleur: Dictionnaire pour recherche rapide O(1)
villes_pop_dict = {
    "Casablanca": 3500000,
    "Rabat": 1800000,
    "Marrakech": 1000000
}
print(villes_pop_dict.get("Rabat", "Ville non trouvée"))

# 5. Choix en fonction des opérations
operations = {
    "Ajout/suppression fréquente en fin de liste": "Liste (append/pop)",
    "Recherche fréquente d'éléments": "Set ou Dictionnaire",
    "Données immuables": "Tuple",
    "Préservation de l'ordre": "Liste",
    "Élimination des doublons": "Set"
}

print("\nGuide de choix des structures:")
for op, conseil in operations.items():
    print(f"- {op}: {conseil}")

Conseils pour un code propre

Adopter de bonnes pratiques avec les listes améliore la lisibilité, la maintenance et les performances du code.

conseils_code_propre.py
# 1. Utiliser des compréhensions de liste pour plus de clarté
villes_maroc = ["casablanca", "rabat", "marrakech"]

# MOINS BON: Boucle traditionnelle
villes_majuscules = []
for ville in villes_maroc:
    villes_majuscules.append(ville.upper())

# MEILLEUR: Compréhension de liste
villes_majuscules = [ville.upper() for ville in villes_maroc]

# 2. Utiliser enumerate() pour avoir l'index et la valeur
print("Villes avec leur index:")
for i, ville in enumerate(villes_maroc, 1):
    print(f"{i}. {ville.title()}")

# 3. Utiliser des noms significatifs
# MAUVAIS:
l = ["Casablanca", "Rabat"]
x = l[0]

# BON:
villes_maroc = ["Casablanca", "Rabat"]
premiere_ville = villes_maroc[0]

# 4. Utiliser des variables intermédiaires pour la clarté
villes_avec_a = [
    ville for ville in villes_maroc
    if 'a' in ville.lower()
]

# 5. Documenter les intentions avec des commentaires
# Filter les villes avec plus d'un million d'habitants
villes_grandes = [
    ville for ville in villes_maroc
    if ville["population"] > 1000000  # Seulement les grandes villes
]

# 6. Utiliser le slicing au lieu de copies manuelles
villes_completes = villes_maroc[:]  # Copie de la liste entière
trois_premieres = villes_maroc[:3]   # Premières 3 villes

# 7. Utiliser zip() pour itérer sur plusieurs listes
villes = ["Casablanca", "Rabat", "Marrakech"]
populations = [3500000, 1800000, 1000000]

for ville, population in zip(villes, populations):
    print(f"{ville}: {population} habitants")

# 8. Éviter les listes complexes quand une classe serait mieux
# MAUVAIS: Liste avec signification positionnelle
ville_data = ["Casablanca", 33.5731, -7.5898, 3500000]  # nom, lat, long, population

# MEILLEUR: Dictionnaire ou classe
ville_data = {
    "nom": "Casablanca",
    "latitude": 33.5731,
    "longitude": -7.5898,
    "population": 3500000
}

# 9. Utiliser any() et all() pour les tests sur les listes
villes_cotieres = ["Casablanca", "Tanger", "Agadir"]

# Au moins une ville contient 'a'
contient_a = any('a' in ville.lower() for ville in villes_cotieres)

# Toutes les villes contiennent 'a'
toutes_contiennent_a = all('a' in ville.lower() for ville in villes_cotieres)

print(f"Au moins une ville avec 'a': {contient_a}")
print(f"Toutes les villes avec 'a': {toutes_contiennent_a}")

# 10. Garder les listes raisonnablement courtes et cohérentes
# Éviter les listes trop longues - les diviser si nécessaire
villes_grandes = [ville for ville in toutes_villes if ville["population"] > 100000]
villes_petites = [ville for ville in toutes_villes if ville["population"] <= 100000]

print(f"Villes grandes: {len(villes_grandes)}, Villes petites: {len(villes_petites)}")
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!