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.
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.
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.
# 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)
Les listes sont essentielles en Python pour plusieurs raisons :
# 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))
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 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)
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.
Les listes peuvent être créées vides pour être remplies ultérieurement, ou pré-remplies avec des valeurs initiales.
# 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)
Contrairement à de nombreux autres langages, les listes Python peuvent contenir des éléments de types différents.
# 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))
La fonction range() combinée avec le constructeur list() permet de générer facilement des séquences de nombres.
# 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)
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.
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).
# 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)
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].
# 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)
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.
# 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(<
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.
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.
# 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)
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.
# 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)
Pour modifier des éléments existants dans une liste, on utilise l'indexation directe ou le slicing pour remplacer une partie de la liste.
# 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)
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.
Les boucles for et while sont les méthodes fondamentales pour parcourir les listes en Python.
# 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")
Les fonctions enumerate() et zip() sont très utiles pour itérer sur les listes avec des index ou combiner plusieurs listes.
# 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}")
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.
# 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)
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.
Les méthodes de recherche et de tri permettent d'organiser et de trouver des éléments dans une liste.
# 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}")
Il est important de comprendre la différence entre copie superficielle (shallow copy) et copie profonde (deep copy) pour éviter les modifications involontaires.
# 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)
Les méthodes join() et split() permettent de convertir entre chaînes de caractères et listes.
# 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)
Les techniques avancées de manipulation des listes permettent de résoudre des problèmes complexes et d'optimiser les performances de votre code.
Les listes imbriquées permettent de représenter des structures de données complexes comme des matrices ou des collections hiérarchiques.
# 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)
Le filtrage et la transformation des données sont essentiels pour le traitement des listes et l'extraction d'informations pertinentes.
# 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']})")
L'optimisation des performances est cruciale lorsqu'on travaille avec de grandes listes ou des opérations intensives.
# 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")
Les techniques avancées de manipulation des listes permettent de résoudre des problèmes complexes et d'optimiser les performances de votre code.
Les listes imbriquées permettent de représenter des structures de données complexes comme des matrices ou des collections hiérarchiques.
# 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)
Le filtrage et la transformation des données sont essentiels pour le traitement des listes et l'extraction d'informations pertinentes.
# 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']})")
L'optimisation des performances est cruciale lorsqu'on travaille avec de grandes listes ou des opérations intensives.
# 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")
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.
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 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}")
Les listes sont essentielles pour lire, traiter et manipuler des données à partir de fichiers.
# 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²")
De nombreux algorithmes classiques utilisent les listes comme structure de données principale.
# 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}")
Comprendre les bonnes pratiques et les erreurs courantes avec les listes Python permet d'écrire un code plus robuste, efficace et maintenable.
Plusieurs erreurs sont fréquemment commises lors de l'utilisation des listes en Python. Les connaître permet de les éviter.
# 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")
Le choix de la structure de données appropriée est crucial pour des performances optimales et un code clair.
# 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}")
Adopter de bonnes pratiques avec les listes améliore la lisibilité, la maintenance et les performances du code.
# 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)}")
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!