La list comprehension est une méthode élégante et concise pour créer des listes en Python. Dans ce tutoriel, vous allez découvrir son fonctionnement, comprendre sa syntaxe et apprendre à remplacer des boucles classiques par cette approche plus lisible. À travers des exemples concrets, vous serez capable d’améliorer la clarté et l’efficacité de vos programmes.
La list comprehension (compréhension de liste) est une construction syntaxique puissante en Python qui permet de créer des listes de manière concise et élégante, en combinant une boucle et une expression en une seule ligne de code.
Une list comprehension est une façon compacte de créer une nouvelle liste en appliquant une opération à chaque élément d'une séquence existante. Elle remplace avantageusement les boucles traditionnelles pour de nombreux cas d'usage.
# Exemple avec une boucle classique # Créer une liste des carrés des nombres de 0 à 9 carres_classique = [] for i in range(10): carres_classique.append(i ** 2) print("Avec boucle classique:", carres_classique) # Même résultat avec une list comprehension carres_comprehension = [i ** 2 for i in range(10)] print("Avec list comprehension:", carres_comprehension) # Exemple avec des données marocaines # Liste des principales villes du Maroc villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] # Créer une liste des longueurs des noms de villes longueurs_noms = [len(ville) for ville in villes_maroc] print("Longueurs des noms de villes:", longueurs_noms) # Créer une liste des villes en majuscules villes_majuscules = [ville.upper() for ville in villes_maroc] print("Villes en majuscules:", villes_majuscules) # List comprehension avec transformation complexe # Ajouter "Maroc" après chaque nom de ville villes_completes = [ville + ", Maroc" for ville in villes_maroc] print("Villes complètes:", villes_completes)
Les list comprehensions offrent plusieurs avantages significatifs par rapport aux boucles traditionnelles :
# AVANTAGE 1: Code plus concis et lisible # Traitement de données économiques marocaines productions = ["Phosphates", "Agrumes", "Poisson", "Textile", "Automobile"] # Avec boucle classique productions_upper = [] for produit in productions: productions_upper.append(produit.upper()) # Avec list comprehension (beaucoup plus compact) productions_upper = [produit.upper() for produit in productions] # AVANTAGE 2: Meilleures performances # Les list comprehensions sont généralement plus rapides import time # Données: populations de régions marocaines (en milliers) populations = [7000, 4500, 3500, 2500, 1800, 1200] # Test de performance avec boucle classique debut = time.time() populations_double = [] for pop in populations: populations_double.append(pop * 2) temps_boucle = time.time() - debut # Test de performance avec list comprehension debut = time.time() populations_double = [pop * 2 for pop in populations] temps_comprehension = time.time() - debut print(f"Temps boucle classique: {temps_boucle:.6f} secondes") print(f"Temps list comprehension: {temps_comprehension:.6f} secondes") # AVANTAGE 3: Intégration naturelle avec d'autres fonctionnalités Python # Exemple avec des conditions et des fonctions # Liste des températures mensuelles à Marrakech (en °C) temperatures = [12, 14, 18, 22, 26, 30, 35, 34, 29, 24, 18, 13] # Filtrer les températures supérieures à 25°C temperatures_chaudes = [temp for temp in temperatures if temp > 25] print("Mois chauds à Marrakech:", temperatures_chaudes) # Convertir en Fahrenheit avec une fonction def celsius_vers_fahrenheit(celsius): return (celsius * 9/5) + 32 temperatures_fahrenheit = [celsius_vers_fahrenheit(temp) for temp in temperatures] print("Températures en Fahrenheit:", [round(t, 1) for t in temperatures_fahrenheit]) # AVANTAGE 4: Facilité de maintenance # Le code est plus concentré et donc plus facile à comprendre et modifier # Exemple: calcul des taxes marocaines sur différents produits prix_ht = [100, 250, 75, 500, 150] # Prix hors taxes en DH taux_tva = 0.20 # TVA marocaine à 20% # Calcul des prix TTC en une ligne claire prix_ttc = [prix * (1 + taux_tva) for prix in prix_ht] print("Prix TTC:", [round(p, 2) for p in prix_ttc])
La list comprehension en Python suit une structure simple mais puissante qui permet de créer des listes de manière concise. Comprendre cette syntaxe est essentiel pour maîtriser cette fonctionnalité.
La syntaxe générale d'une list comprehension suit le modèle : [expression for élément in séquence]. Cette structure peut être enrichie avec des conditions pour filtrer les éléments.
# SYNTAXE GÉNÉRALE D'UNE LIST COMPREHENSION # [expression for élément in séquence] # Exemple 1: Syntaxe de base sans condition nombres = [1, 2, 3, 4, 5] carres = [x ** 2 for x in nombres] print("Carrés:", carres) # [1, 4, 9, 16, 25] # SYNTAXE AVEC CONDITION FILTRANTE # [expression for élément in séquence if condition] # Exemple 2: Avec condition de filtrage nombres_pairs = [x for x in nombres if x % 2 == 0] print("Nombres pairs:", nombres_pairs) # [2, 4] # SYNTAXE AVEC CONDITION TERNIAIRE (if-else) # [expression_if if condition else expression_else for élément in séquence] # Exemple 3: Avec condition ternaire etiquettes = ["Pair" if x % 2 == 0 else "Impair" for x in nombres] print("Étiquettes:", etiquettes) # ['Impair', 'Pair', 'Impair', 'Pair', 'Impair'] # EXEMPLES CONCRETS AVEC DES DONNÉES MAROCAINES # Données: populations de villes marocaines (en milliers) villes_populations = { "Casablanca": 3700, "Rabat": 580, "Marrakech": 930, "Fès": 1100, "Tanger": 950, "Agadir": 600 } # Syntaxe avec dictionnaire - extraction des noms de villes noms_villes = [ville for ville in villes_populations.keys()] print("Noms des villes:", noms_villes) # Syntaxe avec condition - villes de plus de 800,000 habitants villes_grandes = [ville for ville, pop in villes_populations.items() if pop > 800] print("Grandes villes (>800k):", villes_grandes) # Syntaxe avec transformation et condition populations_formatees = [f"{ville}: {pop}k habitants" for ville, pop in villes_populations.items() if pop > 700] print("Populations formatées:") for ligne in populations_formatees: print(" -", ligne) # RÉSUMÉ DES DIFFÉRENTES SYNTAXES print("\n=== RÉSUMÉ DES SYNTAXES ===") print("1. Basique: [expr for x in seq]") print("2. Avec filtre: [expr for x in seq if cond]") print("3. Avec if-else: [expr1 if cond else expr2 for x in seq]") print("4. Imbriquée: [expr for x in seq1 for y in seq2]")
Décortiquons ensemble la création d'une list comprehension à travers un exemple concret étape par étape, en utilisant des données touristiques marocaines.
# EXEMPLE PAS À PAS : CRÉATION D'UNE LIST COMPREHENSION # Objectif: Créer une liste des monuments marocains avec leur ville # ÉTAPE 1: Données de départ monuments_maroc = [ {"nom": "Hassan II", "ville": "Casablanca", "type": "Religieux"}, {"nom": "Koutoubia", "ville": "Marrakech", "type": "Religieux"}, {"nom": "Kasbah des Oudaias", "ville": "Rabat", "type": "Historique"}, {"nom": "Médina de Fès", "ville": "Fès", "type": "Historique"}, {"nom": "Grottes d'Hercule", "ville": "Tanger", "type": "Naturel"} ] # ÉTAPE 2: Approche avec boucle classique (pour comparaison) print("=== APPROCHE BOUCLE CLASSIQUE ===") resultat_boucle = [] for monument in monuments_maroc: description = f"{monument['nom']} à {monument['ville']}" resultat_boucle.append(description) print("Résultat boucle:") for item in resultat_boucle: print(" -", item) # ÉTAPE 3: Transformation en list comprehension print("\n=== TRANSFORMATION EN LIST COMPREHENSION ===") # Étape 3.1: Identifier l'élément de la boucle # for monument in monuments_maroc # Étape 3.2: Identifier l'expression à appliquer # f"{monument['nom']} à {monument['ville']}" # Étape 3.3: Combiner les deux parties resultat_comprehension = [f"{monument['nom']} à {monument['ville']}" for monument in monuments_maroc] print("Résultat list comprehension:") for item in resultat_comprehension: print(" -", item) # ÉTAPE 4: Ajouter une condition de filtrage print("\n=== AJOUT D'UNE CONDITION ===") # Filtrer uniquement les monuments historiques monuments_historiques = [f"{monument['nom']} ({monument['ville']})" for monument in monuments_maroc if monument["type"] == "Historique"] print("Monuments historiques uniquement:") for item in monuments_historiques: print(" -", item) # ÉTAPE 5: Utilisation d'une condition ternaire print("\n=== CONDITION TERNAIRE ===") # Ajouter une étiquette selon le type de monument monuments_etiquettes = [f"{monument['nom']} [{monument['type'].upper()}]" if monument["type"] in ["Historique", "Religieux"] else f"{monument['nom']} (Nature)" for monument in monuments_maroc] print("Monuments avec étiquettes:") for item in monuments_etiquettes: print(" -", item) # ÉTAPE 6: Comparaison finale print("\n=== COMPARAISON FINALE ===") print(f"Boucle classique: {len(resultat_boucle)} lignes de code") print(f"List comprehension: 1 ligne de code") print(f"Résultats identiques: {resultat_boucle == resultat_comprehension}") # EXEMPLE SUPPLÉMENTAIRE : TEMPÉRATURES MAROCAINES print("\n=== EXEMPLE SUPPLÉMENTAIRE : TEMPÉRATURES ===") # Températures moyennes mensuelles à Marrakech (°C) temperatures = [12, 14, 18, 22, 26, 30, 35, 34, 29, 24, 18, 13] mois = ["Jan", "Fév", "Mar", "Avr", "Mai", "Jun", "Jul", "Aoû", "Sep", "Oct", "Nov", "Déc"] # Créer une liste des mois avec leur température formatée temperatures_formatees = [f"{mois[i]}: {temp}°C" for i, temp in enumerate(temperatures)] print("Températures à Marrakech:") for temp in temperatures_formatees: print(" -", temp)
Les conditions dans les list comprehensions permettent de filtrer les éléments ou d'appliquer des transformations conditionnelles. Cette fonctionnalité rend les comprehensions encore plus puissantes et expressives.
Le filtrage avec if permet de sélectionner uniquement les éléments qui satisfont une condition spécifique. C'est l'une des utilisations les plus courantes des list comprehensions.
# FILTRAGE SIMPLE AVEC CONDITION IF # Syntaxe: [expression for élément in séquence if condition] # Exemple 1: Filtrer les villes marocaines de plus de 1 million d'habitants villes_maroc = [ {"nom": "Casablanca", "population": 3700000, "region": "Casablanca-Settat"}, {"nom": "Fès", "population": 1100000, "region": "Fès-Meknès"}, {"nom": "Tanger", "population": 950000, "region": "Tanger-Tétouan-Al Hoceïma"}, {"nom": "Marrakech", "population": 930000, "region": "Marrakech-Safi"}, {"nom": "Salé", "population": 890000, "region": "Rabat-Salé-Kénitra"}, {"nom": "Meknès", "population": 630000, "region": "Fès-Meknès"} ] # Villes de plus d'1 million d'habitants villes_grandes = [ville["nom"] for ville in villes_maroc if ville["population"] > 1000000] print("Villes de plus d'1 million d'habitants:", villes_grandes) # Exemple 2: Filtrer les produits agricoles marocains par saison produits_agricoles = [ {"nom": "Orange", "saison": "Hiver", "region": "Souss-Massa"}, {"nom": "Olive", "saison": "Automne", "region": "Fès-Meknès"}, {"nom": "Amande", "saison": "Été", "region": "Oriental"}, {"nom": "Datte", "saison": "Automne", "region": "Drâa-Tafilalet"}, {"nom": "Raisin", "saison": "Été", "region": "Meknès"} ] # Produits de saison été produits_ete = [produit["nom"] for produit in produits_agricoles if produit["saison"] == "Été"] print("Produits de saison été:", produits_ete) # Exemple 3: Conditions multiples avec AND # Villes de la région Fès-Meknès avec plus de 500,000 habitants villes_fes_meknes = [ ville["nom"] for ville in villes_maroc if ville["region"] == "Fès-Meknès" and ville["population"] > 500000 ] print("Grandes villes de Fès-Meknès:", villes_fes_meknes) # Exemple 4: Conditions multiples avec OR # Villes côtières ou ayant une médina classée UNESCO villes_touristiques = [ {"nom": "Casablanca", "cotiere": True, "medina_unesco": False}, {"nom": "Fès", "cotiere": False, "medina_unesco": True}, {"nom": "Marrakech", "cotiere": False, "medina_unesco": True}, {"nom": "Essaouira", "cotiere": True, "medina_unesco": True}, {"nom": "Rabat", "cotiere": True, "medina_unesco": True} ] villes_selection = [ ville["nom"] for ville in villes_touristiques if ville["cotiere"] or ville["medina_unesco"] ] print("Villes côtières ou avec médina UNESCO:", villes_selection) # Exemple 5: Filtrage avec fonctions personnalisées def est_ville_imperiale(nom_ville): villes_imperiales = {"Fès", "Marrakech", "Meknès", "Rabat"} return nom_ville in villes_imperiales noms_villes = [ville["nom"] for ville in villes_maroc] villes_imperiales = [ville for ville in noms_villes if est_ville_imperiale(ville)] print("Villes impériales du Maroc:", villes_imperiales) # Exemple 6: Filtrage complexe avec transformation # Informations détaillées sur les grandes villes côtières villes_detaillees = [ {"nom": "Casablanca", "population": 3700000, "altitude": 115, "cotiere": True}, {"nom": "Fès", "population": 1100000, "altitude": 410, "cotiere": False}, {"nom": "Tanger", "population": 950000, "altitude": 80, "cotiere": True}, {"nom": "Agadir", "population": 600000, "altitude": 74, "cotiere": True} ] grandes_villes_cotieres = [ f"{ville['nom']} ({ville['population']//1000}k hab, altitude: {ville['altitude']}m)" for ville in villes_detaillees if ville["cotiere"] and ville["population"] > 500000 ] print("Grandes villes côtières:") for ville in grandes_villes_cotieres: print(" -", ville)
La condition ternaire if-else permet d'appliquer des transformations différentes selon qu'une condition est vraie ou fausse. La syntaxe est inversée par rapport au filtrage simple.
# CONDITION TERNAIRE AVEC IF-ELSE # Syntaxe: [expression_if if condition else expression_else for élément in séquence] # ATTENTION: L'ordre est différent du filtrage simple! # Filtrage: [expr for x in seq if cond] # Ternaire: [expr1 if cond else expr2 for x in seq] # Exemple 1: Classifier les températures marocaines temperatures = [35, 28, 22, 18, 12, 8, 5, 30, 25] classifications = [ "Chaud" if temp > 25 else "Doux" if temp > 15 else "Froid" for temp in temperatures ] print("Classifications des températures:") for i, (temp, classe) in enumerate(zip(temperatures, classifications)): print(f" {temp}°C: {classe}") # Exemple 2: Appliquer des taxes différentes selon le type de produit produits = [ {"nom": "Laptop", "prix_ht": 8000, "categorie": "électronique"}, {"nom": "Livre", "prix_ht": 80, "categorie": "culture"}, {"nom": "Café", "prix_ht": 45, "categorie": "alimentation"}, {"nom": "Téléphone", "prix_ht": 5000, "categorie": "électronique"}, {"nom": "Médicament", "prix_ht": 120, "categorie": "santé"} ] # TVA marocaine: 20% standard, 10% réduite, 0% exonéré prix_ttc = [ { "produit": p["nom"], "prix_ttc": round(p["prix_ht"] * 1.20, 2) if p["categorie"] == "électronique" else round(p["prix_ht"] * 1.10, 2) if p["categorie"] in ["alimentation", "culture"] else round(p["prix_ht"] * 1.0, 2) # santé exonérée } for p in produits ] print("\nPrix TTC des produits:") for produit in prix_ttc: print(f" {produit['produit']}: {produit['prix_ttc']} DH") # Exemple 3: Classifier les régions marocaines par taille regions_maroc = [ {"nom": "Casablanca-Settat", "superficie": 20165, "population": 6850000}, {"nom": "Marrakech-Safi", "superficie": 39167, "population": 4500000}, {"nom": "Fès-Meknès", "superficie": 40076, "population": 4300000}, {"nom": "Souss-Massa", "superficie": 51642, "population": 2700000}, {"nom": "Drâa-Tafilalet", "superficie": 88685, "population": 1600000} ] classifications_regions = [ f"{region['nom']} - Grande" if region["population"] > 4000000 else f"{region['nom']} - Moyenne" if region["population"] > 2000000 else f"{region['nom']} - Petite" for region in regions_maroc ] print("\nClassification des régions par population:") for classification in classifications_regions: print(" -", classification) # Exemple 4: Gestion des étudiants marocains avec notes etudiants = [ {"nom": "Ahmed Alami", "note": 16.5, "filiere": "Informatique"}, {"nom": "Fatima Zahra", "note": 12.0, "filiere": "Commerce"}, {"nom": "Mehdi Benani", "note": 8.5, "filiere": "Droit"}, {"nom": "Samira Kassi", "note": 14.0, "filiere": "Médecine"}, {"nom": "Youssef Cherkaoui", "note": 19.0, "filiere": "Ingénierie"} ] resultats_etudiants = [ f"{etudiant['nom']}: Admis avec mention" if etudiant["note"] >= 16 else f"{etudiant['nom']}: Admis" if etudiant["note"] >= 10 else f"{etudiant['nom']}: Redouble" for etudiant in etudiants ] print("\nRésultats des étudiants:") for resultat in resultats_etudiants: print(" -", resultat) # Exemple 5: Combinaison de filtrage et condition ternaire # Calculer les impôts uniquement pour les entreprises rentables entreprises = [ {"nom": "Maroc Telecom", "chiffre_affaires": 35000000, "benefice": 5000000}, {"nom": "OCP", "chiffre_affaires": 80000000, "benefice": 12000000}, {"nom": "Royal Air Maroc", "chiffre_affaires": 15000000, "benefice": -2000000}, {"nom": "Banque Populaire", "chiffre_affaires": 25000000, "benefice": 3000000} ] calcul_impots = [ f"{e['nom']}: Impôt de {e['benefice'] * 0.30:,.0f} DH" if e["benefice"] > 0 else f"{e['nom']}: Exonéré (déficit)" for e in entreprises if e["chiffre_affaires"] > 10000000 # Filtrage: seulement grandes entreprises ] print("\nCalcul d'impôts des grandes entreprises:") for impôt in calcul_impots: print(" -", impôt)
Les list comprehensions deviennent véritablement puissantes lorsqu'on les utilise pour des scénarios complexes comme les imbrications multiples ou la transformation de structures de données élaborées.
Les comprehensions imbriquées permettent de travailler avec des structures multidimensionnelles en combinant plusieurs boucles dans une seule expression. Elles sont particulièrement utiles pour les matrices et les combinaisons d'éléments.
# COMPRÉHENSIONS IMBRIQUÉES - SYNTAXE GÉNÉRALE # [expression for élément1 in séquence1 for élément2 in séquence2] # Exemple 1: Création d'une matrice d'identité 3x3 matrice_identite = [[1 if i == j else 0 for j in range(3)] for i in range(3)] print("Matrice identité 3x3:") for ligne in matrice_identite: print(ligne) # Exemple 2: Table de multiplication marocaine (de 1 à 5) table_multiplication = [[i * j for j in range(1, 6)] for i in range(1, 6)] print("\nTable de multiplication 5x5:") for i, ligne in enumerate(table_multiplication, 1): print(f"{i}: {ligne}") # Exemple 3: Combinaisons de plats marocains et boissons plats_marocains = ["Tajine", "Couscous", "Pastilla", "Harira"] boissons = ["Thé à la menthe", "Jus d'orange", "Lben"] menus_combines = [[plat, boisson] for plat in plats_marocains for boisson in boissons] print("\nCombinaisons de menus marocains:") for i, menu in enumerate(menus_combines, 1): print(f"{i}. {menu[0]} avec {menu[1]}") # Exemple 4: Planification d'itinéraires touristiques villes_depart = ["Casablanca", "Marrakech", "Fès"] villes_arrivee = ["Chefchaouen", "Merzouga", "Essaouira"] transports = ["Train", "Bus", "Voiture"] itineraires = [ f"De {depart} à {arrivee} en {transport}" for depart in villes_depart for arrivee in villes_arrivee for transport in transports if depart != arrivee # Éviter les itinéraires identiques ] print("\nItinéraires touristiques possibles:") for i, itineraire in enumerate(itineraires[:10], 1): # Afficher seulement les 10 premiers print(f"{i}. {itineraire}") # Exemple 5: Tableau des distances entre villes marocaines villes_principales = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] # Matrice symétrique des distances (en km) distances = [ [0 if i == j else abs(i - j) * 100 + 50 # Distances simulées for j, ville2 in enumerate(villes_principales)] for i, ville1 in enumerate(villes_principales) ] print("\nTableau des distances entre villes (km):") print(" " + " ".join([f"{ville:<10}" for ville in villes_principales])) for i, ville in enumerate(villes_principales): ligne_distances = [f"{dist:<10}" for dist in distances[i]] print(f"{ville:<8} {''.join(ligne_distances)}") # Exemple 6: Planification budgétaire pour projets régionaux regions_maroc = ["Casablanca-Settat", "Marrakech-Safi", "Fès-Meknès"] types_projets = ["Infrastructure", "Éducation", "Santé"] budgets = [1000000, 500000, 750000] # en milliers de DH projets_regionaux = [ { "region": region, "projet": projet, "budget": budget, "code": f"{region[:3].upper()}-{projet[:3].upper()}-{i+j+k}" } for i, region in enumerate(regions_maroc) for j, projet in enumerate(types_projets) for k, budget in enumerate(budgets) ] print("\nPlanification des projets régionaux:") for projet in projets_regionaux[:6]: # Afficher 6 projets print(f" {projet['code']}: {projet['projet']} à {projet['region']} - Budget: {projet['budget']:,} KDH")
Les list comprehensions excellent dans la transformation de structures de données complexes, permettant de restructurer, filtrer et agréger des informations en une seule expression concise.
# TRANSFORMATION DE DONNÉES COMPLEXES # Exemple 1: Restructuration de données touristiques donnees_touristiques = [ {"ville": "Marrakech", "attractions": ["Jardin Majorelle", "Place Jemaa el-Fna", "Médina"], "visiteurs_an": 2000000}, {"ville": "Fès", "attractions": ["Médina", "Université Al Quaraouiyine", "Tanneries"], "visiteurs_an": 800000}, {"ville": "Casablanca", "attractions": ["Mosquée Hassan II", "Corniche", "Habous"], "visiteurs_an": 1500000} ] # Transformer en liste plate d'attractions avec leur ville attractions_par_ville = [ {"attraction": attraction, "ville": ville["ville"], "frequentation": ville["visiteurs_an"]} for ville in donnees_touristiques for attraction in ville["attractions"] ] print("Attractions touristiques par ville:") for attraction in attractions_par_ville: print(f" - {attraction['attraction']} ({attraction['ville']}) - {attraction['frequentation']:,} visiteurs/an") # Exemple 2: Agrégation de données économiques régionales donnees_economiques = [ {"region": "Casablanca-Settat", "secteur": "Industrie", "pib": 120, "emplois": 500000}, {"region": "Casablanca-Settat", "secteur": "Services", "pib": 180, "emplois": 800000}, {"region": "Marrakech-Safi", "secteur": "Tourisme", "pib": 90, "emplois": 300000}, {"region": "Marrakech-Safi", "secteur": "Agriculture", "pib": 60, "emplois": 400000}, {"region": "Fès-Meknès", "secteur": "Artisanat", "pib": 40, "emplois": 200000} ] # Agrégation par région avec calcul du PIB total et emplois totaux regions_uniques = list(set([d["region"] for d in donnees_economiques])) agregation_regionale = [ { "region": region, "pib_total": sum([d["pib"] for d in donnees_economiques if d["region"] == region]), "emplois_totaux": sum([d["emplois"] for d in donnees_economiques if d["region"] == region]), "secteurs": [d["secteur"] for d in donnees_economiques if d["region"] == region] } for region in regions_uniques ] print("\nAgrégation économique par région (PIB en milliards DH):") for region in agregation_regionale: print(f" {region['region']}:") print(f" PIB Total: {region['pib_total']} milliards DH") print(f" Emplois: {region['emplois_totaux']:,}") print(f" Secteurs: {', '.join(region['secteurs'])}") # Exemple 3: Transformation de données météorologiques complexes donnees_meteo = [ {"ville": "Marrakech", "mois": "Janvier", "temp_moy": 12, "precipitations": 32}, {"ville": "Marrakech", "mois": "Juillet", "temp_moy": 35, "precipitations": 2}, {"ville": "Fès", "mois": "Janvier", "temp_moy": 10, "precipitations": 80}, {"ville": "Fès", "mois": "Juillet", "temp_moy": 32, "precipitations": 5}, {"ville": "Tanger", "mois": "Janvier", "temp_moy": 14, "precipitations": 100}, {"ville": "Tanger", "mois": "Juillet", "temp_moy": 28, "precipitations": 1} ] # Restructuration pour analyse comparative analyse_meteo = [ { "ville": ville, "amplitude_thermique": (max([d["temp_moy"] for d in donnees_meteo if d["ville"] == ville]) - min([d["temp_moy"] for d in donnees_meteo if d["ville"] == ville])), "precipitations_annuelles": sum([d["precipitations"] for d in donnees_meteo if d["ville"] == ville]) * 6, "climat": "Chaud et sec" if max([d["temp_moy"] for d in donnees_meteo if d["ville"] == ville]) > 30 else "Tempéré" } for ville in set([d["ville"] for d in donnees_meteo]) ] print("\nAnalyse climatique des villes:") for analyse in analyse_meteo: print(f" {analyse['ville']}:") print(f" Amplitude thermique: {analyse['amplitude_thermique']}°C") print(f" Précipitations annuelles estimées: {analyse['precipitations_annuelles']} mm") print(f" Type de climat: {analyse['climat']}") # Exemple 4: Transformation de données éducatives universites_maroc = [ {"nom": "Université Mohammed V", "ville": "Rabat", "filieres": ["Droit", "Médecine", "Sciences"], "etudiants": 50000}, {"nom": "Université Cadi Ayyad", "ville": "Marrakech", "filieres": ["Ingénierie", "Commerce", "Lettres"], "etudiants": 40000}, {"nom": "Université Sidi Mohamed Ben Abdellah", "ville": "Fès", "filieres": ["Droit", "Sciences", "Arts"], "etudiants": 35000} ] # Création d'un répertoire complet des filières repertoire_filieres = [ { "filiere": filiere, "universite": uni["nom"], "ville": uni["ville"], "etudiants_estimes": uni["etudiants"] // len(uni["filieres"]) # Estimation } for uni in universites_maroc for filiere in uni["filieres"] ] print("\nRépertoire des filières universitaires:") for filiere in repertoire_filieres: print(f" {filiere['filiere']} - {filiere['universite']} ({filiere['ville']}) - ~{filiere['etudiants_estimes']} étudiants")
Bien que les list comprehensions offrent de nombreux avantages, il est important de savoir quand les utiliser et quand privilégier les boucles traditionnelles pour maintenir un code clair et efficace.
Les list comprehensions sont idéales pour les transformations simples et lisibles de données. Voici les situations où elles excellent par rapport aux boucles classiques.
# SITUATION 1: Transformations simples et lisibles # Données: populations des régions marocaines (en milliers) populations = [7000, 4500, 3500, 2500, 1800] # ✅ LIST COMPREHENSION (idéale) populations_double = [pop * 2 for pop in populations] # ❌ BOUCLE CLASSIQUE (moins concise) populations_double_boucle = [] for pop in populations: populations_double_boucle.append(pop * 2) print("Populations doublées:", populations_double) # SITUATION 2: Filtrage avec conditions simples # Villes marocaines de plus de 1 million d'habitants villes = [ {"nom": "Casablanca", "population": 3700000}, {"nom": "Fès", "population": 1100000}, {"nom": "Tanger", "population": 950000}, {"nom": "Marrakech", "population": 930000} ] # ✅ LIST COMPREHENSION (très lisible) villes_grandes = [ville["nom"] for ville in villes if ville["population"] > 1000000] # ❌ BOUCLE CLASSIQUE (plus verbeuse) villes_grandes_boucle = [] for ville in villes: if ville["population"] > 1000000: villes_grandes_boucle.append(ville["nom"]) print("Villes de plus d'1 million:", villes_grandes) # SITUATION 3: Performance sur grandes datasets import time # Données: températures mensuelles de 10 villes marocaines sur 10 ans donnees_temperatures = [[25 for _ in range(12)] for _ in range(100)] # ✅ TEST PERFORMANCE LIST COMPREHENSION debut = time.time() temperatures_celsius = [[(temp - 32) * 5/9 for temp in annee] for annee in donnees_temperatures] temps_comprehension = time.time() - debut # ❌ TEST PERFORMANCE BOUCLE CLASSIQUE debut = time.time() temperatures_celsius_boucle = [] for annee in donnees_temperatures: annee_convertie = [] for temp in annee: annee_convertie.append((temp - 32) * 5/9) temperatures_celsius_boucle.append(annee_convertie) temps_boucle = time.time() - debut print(f"\nPerformance sur grandes données:") print(f"List comprehension: {temps_comprehension:.6f} secondes") print(f"Boucle classique: {temps_boucle:.6f} secondes") print(f"Gain de performance: {((temps_boucle - temps_comprehension) / temps_boucle * 100):.1f}%") # SITUATION 4: Code fonctionnel et immuable # Calcul des taxes TVA marocaines prix_ht = [100, 250, 75, 500] taux_tva = 0.20 # ✅ LIST COMPREHENSION (style fonctionnel) prix_ttc = [prix * (1 + taux_tva) for prix in prix_ht] # ❌ BOUCLE CLASSIQUE (style impératif) prix_ttc_boucle = [] for prix in prix_ht: prix_ttc_boucle.append(prix * (1 + taux_tva)) print(f"\nPrix TTC: {prix_ttc}") # SITUATION 5: Intégration avec d'autres fonctionnalités Python # Traitement de données touristiques marocaines visites = [1500000, 800000, 1200000, 600000] villes_touristiques = ["Marrakech", "Fès", "Agadir", "Essaouira"] # ✅ LIST COMPREHENSION + ZIP (très pythonique) statistiques = [f"{ville}: {visite:,} visiteurs/an" for ville, visite in zip(villes_touristiques, visites)] print("\nStatistiques touristiques:") for stat in statistiques: print(" -", stat) # RÉSUMÉ DES AVANTAGES print("\n" + "="*50) print("QUAND PRÉFÉRER LES LIST COMPREHENSIONS:") print("✓ Transformations simples et lisibles") print("✓ Filtrage avec conditions claires") print("✓ Besoin de performances sur grandes données") print("✓ Style de programmation fonctionnelle") print("✓ Intégration avec d'autres features Python") print("✓ Code concis et expressif")
Les list comprehensions ne sont pas toujours la meilleure solution. Dans certains cas, les boucles classiques sont plus appropriées pour la lisibilité et la maintenabilité du code.
# SITUATION 1: Logique complexe avec plusieurs étapes # Traitement de données d'étudiants marocains etudiants = [ {"nom": "Ahmed Alami", "notes": [14, 16, 12], "filiere": "Informatique"}, {"nom": "Fatima Zahra", "notes": [18, 15, 17], "filiere": "Médecine"}, {"nom": "Mehdi Benani", "notes": [8, 10, 9], "filiere": "Droit"} ] # ❌ LIST COMPREHENSION COMPLEXE (illisible) # Tentative maladroite de tout faire en une ligne resultats_complexes = [ (etu["nom"], sum(etu["notes"])/len(etu["notes"]), "Admis" if sum(etu["notes"])/len(etu["notes"]) >= 10 else "Redouble", "Excellent" if sum(etu["notes"])/len(etu["notes"]) >= 16 else "Bon" if sum(etu["notes"])/len(etu["notes"]) >= 14 else "Moyen") for etu in etudiants ] # ✅ BOUCLE CLASSIQUE (beaucoup plus lisible) resultats_clairs = [] for etudiant in etudiants: moyenne = sum(etudiant["notes"]) / len(etudiant["notes"]) # Détermination du statut statut = "Admis" if moyenne >= 10 else "Redouble" # Détermination de l'appréciation if moyenne >= 16: appreciation = "Excellent" elif moyenne >= 14: appreciation = "Bon" else: appreciation = "Moyen" resultats_clairs.append((etudiant["nom"], moyenne, statut, appreciation)) print("Résultats des étudiants (version claire):") for nom, moyenne, statut, appreciation in resultats_clairs: print(f" {nom}: Moyenne={moyenne:.1f}, {statut}, {appreciation}") # SITUATION 2: Effets de bord nécessaires # Gestion de comptes bancaires marocains comptes = [ {"titulaire": "Karim Amrani", "solde": 5000, "operations": []}, {"titulaire": "Leila Benjelloun", "solde": 3000, "operations": []}, {"titulaire": "Youssef Cherkaoui", "solde": 7000, "operations": []} ] # ❌ LIST COMPREHENSION INAPPROPRIÉE (effets de bord) # Ne modifie pas les comptes originaux - crée une nouvelle liste comptes_apres_depot = [ {"titulaire": compte["titulaire"], "solde": compte["solde"] + 1000, "operations": compte["operations"] + ["Dépôt 1000 DH"]} for compte in comptes ] # ✅ BOUCLE CLASSIQUE (modification en place appropriée) for compte in comptes: compte["solde"] += 1000 compte["operations"].append("Dépôt 1000 DH") print("\nSoldes après dépôt (modification en place):") for compte in comptes: print(f" {compte['titulaire']}: {compte['solde']} DH") # SITUATION 3: Conditions complexes multiples # Éligibilité pour un programme d'aide marocain candidats = [ {"nom": "Amina", "age": 25, "revenu": 8000, "region": "Souss-Massa", "diplome": True}, {"nom": "Hassan", "age": 35, "revenu": 12000, "region": "Casablanca", "diplome": False}, {"nom": "Samira", "age": 28, "revenu": 6000, "region": "Oriental", "diplome": True} ] # ❌ LIST COMPREHENSION ILLISIBLE (conditions trop complexes) eligibles_complexe = [ candidat["nom" for candidat in candidats if (candidat["age"] < 30 and candidat["revenu"] < 10000 and candidat["diplome"]) or (candidat["region"] in ["Souss-Massa", "Oriental"] and candidat["revenu"] < 15000) ] # ✅ BOUCLE CLASSIQUE (conditions claires et documentées) eligibles_clairs = [] for candidat in candidats: # Critère 1: Jeunes diplômés à faible revenu critere1 = (candidat["age"] < 30 and candidat["revenu"] < 10000 and candidat["diplome"]) # Critère 2: Habitants de régions prioritaires critere2 = (candidat["region"] in ["Souss-Massa", "Oriental"] and candidat["revenu"] < 15000) if critere1 or critere2: eligibles_clairs.append(candidat["nom"]) print(f"\nCandidats éligibles: {eligibles_clairs}") # SITUATION 4: Gestion d'exceptions nécessaire # Traitement de données potentiellement erronées donnees_utilisateurs = ["1000", "2000", "abc", "3000", "def"] # ❌ LIST COMPREHENSION (gestion d'erreurs difficile) # Provoque une erreur si une valeur n'est pas convertible # nombres = [int(x) for x in donnees_utilisateurs] # ERREUR! # ✅ BOUCLE CLASSIQUE (gestion d'erreurs appropriée) nombres_valides = [] for donnee in donnees_utilisateurs: try: nombre = int(donnee) nombres_valides.append(nombre) except ValueError: print(f"Valeur ignorée: '{donnee}' n'est pas un nombre valide") print(f"Nombres valides: {nombres_valides}") # RÉSUMÉ DES CAS À ÉVITER print("\n" + "="*50) print("QUAND ÉVITER LES LIST COMPREHENSIONS:") print("✗ Logique complexe avec plusieurs étapes") print("✗ Effets de bord nécessaires (modifications en place)") print("✗ Conditions trop complexes ou multiples") print("✗ Gestion d'exceptions nécessaire") print("✗ Lisibilité compromise") print("✗ Debugging difficile")
Pratiquez vos compétences en list comprehension avec ces exercices progressifs. Chaque exercice comprend un énoncé, une solution et des explications détaillées.
Cet exercice fondamental vous permet de maîtriser la syntaxe de base des list comprehensions en transformant des données numériques.
# EXERCICE 1: CRÉER UNE LISTE DE CARRÉS # ==================================== # ÉNONCÉ: # Créez une liste contenant les carrés des nombres de 1 à 10 # Utilisez une list comprehension pour obtenir le résultat suivant: # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] # VOTRE SOLUTION: # Essayez de compléter le code ci-dessous # carres = [_______ for _______ in _______] # SOLUTION CORRIGÉE: carres = [n ** 2 for n in range(1, 11)] print("Exercice 1 - Carrés de 1 à 10:") print(carres) # EXERCICE 1B: APPLICATION CONCRÈTE - SURFACES DE PROVINCES # Calculez les surfaces carrées de provinces marocaines cotes_provinces = [15, 20, 25, 30, 35] # en km surfaces = [cote ** 2 for cote in cotes_provinces] print("\nExercice 1B - Surfaces de provinces (km²):") for i, surface in enumerate(surfaces): print(f" Province {i+1}: {surface} km²") # EXERCICE 1C: CARRÉS AVEC CONDITIONS # Calculez les carrés uniquement pour les nombres pairs de 1 à 15 carres_pairs = [n ** 2 for n in range(1, 16) if n % 2 == 0] print("\nExercice 1C - Carrés des nombres pairs de 1 à 15:") print(carres_pairs) # EXPLICATIONS DÉTAILLÉES: print("\n" + "="*50) print("EXPLICATIONS EXERCICE 1:") print("1. range(1, 11) génère les nombres de 1 à 10") print("2. n ** 2 calcule le carré de chaque nombre") print("3. La syntaxe [expression for variable in sequence] crée la liste") print("4. Le filtre 'if n % 2 == 0' sélectionne uniquement les nombres pairs")
Apprenez à filtrer des données avec des conditions simples pour extraire des éléments spécifiques d'une liste.
# EXERCICE 2: EXTRAIRE LES NOMBRES PAIRS # ===================================== # ÉNONCÉ: # À partir d'une liste de nombres, extrayez uniquement les nombres pairs # Utilisez une condition dans votre list comprehension # DONNÉES DE DÉPART: nombres_maroc = [15, 22, 37, 44, 58, 63, 70, 81, 96, 100] # VOTRE SOLUTION: # Essayez de compléter le code ci-dessous # pairs = [_______ for _______ in _______ if _______] # SOLUTION CORRIGÉE: pairs = [n for n in nombres_maroc if n % 2 == 0] print("Exercice 2 - Nombres pairs:") print(pairs) # EXERCICE 2B: APPLICATION CONCRÈTE - ÂGES POUR LE SERVICE CIVIQUE # Filtrer les âges éligibles pour le service civique marocain (18-25 ans pairs) ages_candidats = [17, 18, 19, 20, 21, 22, 23, 24, 25, 26] ages_eligibles = [age for age in ages_candidats if age % 2 == 0 and 18 <= age <= 25] print("\nExercice 2B - Âges éligibles pour service civique (pairs):") print(ages_eligibles) # EXERCICE 2C: FILTRAGE MULTIPLE - TEMPÉRATURES IDÉALES # Extraire les températures idéales pour le tourisme (20-28°C et paires) temperatures = [18, 22, 25, 28, 30, 32, 20, 24, 26] temperatures_ideales = [temp for temp in temperatures if temp % 2 == 0 and 20 <= temp <= 28] print("\nExercice 2C - Températures idéales pour tourisme (paires):") print(temperatures_ideales) # EXERCICE 2D: AVEC TRANSFORMATION - DOUBLER LES PAIRS # Extraire les nombres pairs et les doubler nombres_depart = [5, 12, 8, 15, 20, 3, 24] pairs_doubles = [n * 2 for n in nombres_depart if n % 2 == 0] print("\nExercice 2D - Nombres pairs doublés:") print(f"Original: {nombres_depart}") print(f"Pairs doublés: {pairs_doubles}") # EXPLICATIONS DÉTAILLÉES: print("\n" + "="*50) print("EXPLICATIONS EXERCICE 2:") print("1. n % 2 == 0 vérifie si le nombre est pair") print("2. On peut combiner plusieurs conditions avec 'and'") print("3. La transformation (n * 2) s'applique après le filtrage") print("4. L'ordre est important: [expr for var in seq if condition]")
Découvrez comment utiliser les list comprehensions pour transformer et filtrer des données textuelles de manière efficace.
# EXERCICE 3: MANIPULER DES CHAÎNES DE CARACTÈRES # ============================================== # ÉNONCÉ: # Transformez une liste de noms de villes marocaines en majuscules # et ajoutez "MAROC" à la fin de chaque nom # DONNÉES DE DÉPART: villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] # VOTRE SOLUTION: # Essayez de compléter le code ci-dessous # villes_formatees = [_______ for _______ in _______] # SOLUTION CORRIGÉE: villes_formatees = [ville.upper() + ", MAROC" for ville in villes_maroc] print("Exercice 3 - Villes formatées:") for ville in villes_formatees: print(" -", ville) # EXERCICE 3B: FILTRER LES VILLES PAR LONGUEUR # Sélectionner uniquement les villes avec plus de 6 caractères villes_longues = [ville for ville in villes_maroc if len(ville) > 6] print("\nExercice 3B - Villes avec plus de 6 caractères:") print(villes_longues) # EXERCICE 3C: EXTRACTIONS DE PRÉFIXES # Extraire les 3 premières lettres de chaque ville prefixes = [ville[:3].upper() for ville in villes_maroc] print("\nExercice 3C - Préfixes des villes (3 premières lettres):") print(prefixes) # EXERCICE 3D: TRAITEMENT DE DONNÉES COMPLEXES # Créer des descriptions formatées à partir de données structurées donnees_villes = [ {"nom": "Casablanca", "population": 3700000, "region": "Casablanca-Settat"}, {"nom": "Marrakech", "population": 930000, "region": "Marrakech-Safi"}, {"nom": "Fès", "population": 1100000, "region": "Fès-Meknès"} ] descriptions = [ f"{ville['nom'].upper()} ({ville['region']}) - Pop: {ville['population']:,} hab." for ville in donnees_villes ] print("\nExercice 3D - Descriptions détaillées des villes:") for desc in descriptions: print(" -", desc) # EXERCICE 3E: FILTRAGE AVEC CONDITIONS COMPLEXES # Sélectionner les villes de plus de 1 million d'habitants # et formater leur nom en minuscules avec la première lettre en majuscule villes_grandes = [ ville["nom"].capitalize() for ville in donnees_villes if ville["population"] > 1000000 ] print("\nExercice 3E - Grandes villes (>1M hab) formatées:") print(villes_grandes) # EXERCICE 3F: MANIPULATION DE TEXTE AVEC SPLIT # Extraire les premiers mots de phrases décrivant les villes descriptions_villes = [ "Casablanca est la capitale économique", "Marrakech est la ville ocre", "Fès est la capitale culturelle", "Tanger est la porte de l'Afrique" ] premiers_mots = [phrase.split()[0] for phrase in descriptions_villes] print("\nExercice 3F - Premiers mots des descriptions:") print(premiers_mots) # CHALLENGE FINAL: CRÉATION D'UN RAPPORT TOURISTIQUE villes_touristiques = [ {"nom": "Marrakech", "visiteurs": 2000000, "hotels": 450}, {"nom": "Agadir", "visiteurs": 1500000, "hotels": 300}, {"nom": "Fès", "visiteurs": 800000, "hotels": 200}, {"nom": "Essaouira", "visiteurs": 500000, "hotels": 120} ] rapport_touristique = [ f"{ville['nom'].upper():<12} | Visiteurs: {ville['visiteurs']:<8,} | Hôtels: {ville['hotels']:<4} | Ratio: {ville['visiteurs']//ville['hotels']:<5,}" for ville in villes_touristiques if ville["visiteurs"] > 600000 ] print("\n" + "="*60) print("CHALLENGE FINAL - RAPPORT TOURISTIQUE MAROCAIN") print("="*60) print("VILLE | VISITEURS | HÔTELS | RATIO") print("-"*60) for ligne in rapport_touristique: print(ligne) # EXPLICATIONS DÉTAILLÉES: print("\n" + "="*50) print("EXPLICATIONS EXERCICE 3:") print("1. .upper() convertit en majuscules, .capitalize() met la première en majuscule") print("2. Les f-strings permettent un formatage complexe") print("3. split()[0] extrait le premier mot d'une phrase") print("4. On peut combiner filtrage et transformation complexe")
Les list comprehensions sont un outil puissant qui, utilisé à bon escient, peut grandement améliorer la qualité et l'efficacité de votre code Python. Maîtriser leur usage demande de comprendre à la fois leurs forces et leurs limites.
Retour sur les concepts fondamentaux des list comprehensions et leur application dans des contextes marocains concrets.
# RÉCAPITULATIF DES POINTS CLÉS DES LIST COMPREHENSIONS # ==================================================== # 1. SYNTAXE DE BASE # [expression for élément in séquence] # Exemple: Calcul des surfaces de régions marocaines largeurs_regions = [100, 150, 200, 120] # en km longueurs_regions = [80, 120, 180, 90] # en km surfaces = [largeur * longueur for largeur, longueur in zip(largeurs_regions, longueurs_regions)] print("1. Syntaxe de base - Surfaces des régions (km²):", surfaces) # 2. FILTRAGE AVEC CONDITION # [expression for élément in séquence if condition] # Exemple: Villes marocaines de plus de 1 million d'habitants villes_populations = { "Casablanca": 3700000, "Fès": 1100000, "Marrakech": 930000, "Tanger": 950000 } villes_grandes = [ville for ville, pop in villes_populations.items() if pop > 1000000] print("2. Filtrage - Villes de plus d'1 million:", villes_grandes) # 3. CONDITION TERNAIRE # [expression_if if condition else expression_else for élément in séquence] # Exemple: Classification des températures marocaines temperatures = [12, 18, 25, 32, 8, 28] classifications = [ "Froid" if temp < 15 else "Doux" if temp < 25 else "Chaud" for temp in temperatures ] print("3. Condition ternaire - Classifications:", classifications) # 4. COMPRÉHENSIONS IMBRIQUÉES # [expression for élément1 in séquence1 for élément2 in séquence2] # Exemple: Combinaisons de plats et boissons marocains plats = ["Tajine", "Couscous"] boissons = ["Thé à la menthe", "Jus d'orange"] menus = [[plat, boisson] for plat in plats for boisson in boissons] print("4. Imbriquées - Combinaisons de menus:", menus) # 5. PERFORMANCE ET LISIBILITÉ import time # Comparaison des performances donnees = list(range(10000)) # List comprehension debut = time.time() resultat_comprehension = [x * 2 for x in donnees if x % 2 == 0] temps_comprehension = time.time() - debut # Boucle classique debut = time.time() resultat_boucle = [] for x in donnees: if x % 2 == 0: resultat_boucle.append(x * 2) temps_boucle = time.time() - debut print(f"5. Performance - Comprehension: {temps_comprehension:.6f}s, Boucle: {temps_boucle:.6f}s") # SYNTHÈSE DES AVANTAGES print("\n" + "="*60) print("SYNTHÈSE DES AVANTAGES DES LIST COMPREHENSIONS") print("="*60) print("✓ CONCISION: Code plus court et expressif") print("✓ PERFORMANCE: Généralement plus rapide que les boucles") print("✓ LISIBILITÉ: Intentions claires pour des transformations simples") print("✓ FONCTIONNEL: Style de programmation fonctionnelle") print("✓ INTÉGRATION: S'intègre bien avec le reste de Python") # APPLICATIONS TYPIQUES AU MAROC print("\nAPPLICATIONS TYPIQUES DANS UN CONTEXTE MAROCAIN:") print("• Traitement de données démographiques et urbaines") print("• Analyse de données touristiques et économiques") print("• Transformation de données géographiques") print("• Génération de rapports et de statistiques") print("• Filtrage et classification de données métier")
Adopter les bonnes pratiques permet de tirer le meilleur parti des list comprehensions tout en maintenant un code de qualité professionnelle.
# BONNES PRATIQUES POUR DES LIST COMPREHENSIONS EFFICACES # ====================================================== # CONSEIL 1: PRIVILÉGIER LA LISIBILITÉ # ------------------------------------ # ❌ À ÉVITER: Comprehension trop complexe donnees_complexes = [ {"ville": "Casablanca", "habitants": 3700000, "superficie": 220}, {"ville": "Marrakech", "habitants": 930000, "superficie": 230} ] # ❌ ILLISIBLE: Trop d'opérations en une ligne # resultat = [f"{d['ville']}: {d['habitants']/d['superficie']:.0f} hab/km²" # for d in donnees_complexes if d['habitants'] > 500000] # ✅ RECOMMANDÉ: Séparation des préoccupations def calculer_densite(ville): return ville["habitants"] / ville["superficie"] villes_grandes = [ville for ville in donnees_complexes if ville["habitants"] > 500000] densites = [f"{ville['ville']}: {calculer_densite(ville):.0f} hab/km²" for ville in villes_grandes] print("1. Lisibilité - Densités des grandes villes:") for densite in densites: print(" -", densite) # CONSEIL 2: ÉVITER LES EFFETS DE BORD # ----------------------------------- # Les comprehensions créent de nouvelles listes, elles ne modifient pas les originales produits_maroc = ["huile d'olive", "dattes", "amandes", "safran"] # ✅ CORRECT: Création d'une nouvelle liste produits_majuscules = [produit.upper() for produit in produits_maroc] print("\n2. Effets de bord - Liste originale préservée:") print("Original:", produits_maroc) print("Transformé:", produits_majuscules) # CONSEIL 3: UTILISER LES BONNES STRUCTURES DE DONNÉES # ---------------------------------------------------- # Pour des vérifications d'appartenance, préférer les sets villes_imperiales = {"Fès", "Marrakech", "Meknès", "Rabat"} villes_test = ["Casablanca", "Fès", "Agadir", "Marrakech"] # ✅ EFFICACE: Utilisation d'un set pour l'appartenance villes_imperiales_trouvees = [ville for ville in villes_test if ville in villes_imperiales] print("\n3. Structures de données - Villes impériales trouvées:") print(villes_imperiales_trouvees) # CONSEIL 4: OPTIMISER LES PERFORMANCES # ------------------------------------ # Éviter les appels de fonctions répétés dans les conditions import math # ❌ NON OPTIMAL: Appel répété à math.sqrt() nombres = [4, 16, 25, 36, 49] # racines = [math.sqrt(n) for n in nombres if math.sqrt(n) > 4] # Double calcul # ✅ OPTIMAL: Calcul unique avec condition ternaire racines = [racine for n in nombres if (racine := math.sqrt(n)) > 4] print("\n4. Performance - Racines carrées > 4:") print(racines) # CONSEIL 5: CHOISIR ENTRE COMPREHENSION ET BOUCLE # ---------------------------------------------- # ✅ COMPREHENSION: Pour des transformations simples prix_ht = [100, 200, 300] prix_ttc = [prix * 1.20 for prix in prix_ht] # Parfait! # ✅ BOUCLE: Pour une logique complexe avec effets de bord comptes = [ {"nom": "Client1", "solde": 1000, "operations": []}, {"nom": "Client2", "solde": 2000, "operations": []} ] # Boucle plus appropriée pour la modification en place for compte in comptes: compte["solde"] += 100 compte["operations"].append("Dépôt de 100 DH") print("\n5. Choix approprié - Comptes après dépôt:") for compte in comptes: print(f" {compte['nom']}: {compte['solde']} DH") # CONSEIL 6: DOCUMENTATION ET MAINTENANCE # ------------------------------------- # Ajouter des commentaires pour les comprehensions complexes employes = [ {"nom": "Ahmed", "salaire": 8000, "anciennete": 3}, {"nom": "Fatima", "salaire": 12000, "anciennete": 7} ] # Comprehension bien documentée bonus_employes = [ { "nom": emp["nom"], "bonus": emp["salaire"] * 0.1 if emp["anciennete"] > 5 else emp["salaire"] * 0.05 } for emp in employes # Bonus de 10% pour ancienneté > 5 ans, 5% sinon ] print("\n6. Documentation - Bonus des employés:") for bonus in bonus_employes: print(f" {bonus['nom']}: {bonus['bonus']:.0f} DH") # GUIDE DE DÉCISION RAPIDE print("\n" + "="*60) print("GUIDE DE DÉCISION: COMPREHENSION VS BOUCLE") print("="*60) print("✅ UTILISER UNE COMPREHENSION QUAND:") print(" • Transformation simple et claire") print(" • Filtrage avec conditions simples") print(" • Performance importante") print(" • Style fonctionnel approprié") print("") print("✅ PRÉFÉRER UNE BOUCLE QUAND:") print(" • Logique complexe avec plusieurs étapes") print(" • Effets de bord nécessaires") print(" • Gestion d'exceptions requise") print(" • Lisibilité compromise") print(" • Debugging difficile") # CONCLUSION FINALE print("\n" + "#"*70) print("CONCLUSION: Les list comprehensions sont un outil puissant") print("qui, utilisé judicieusement, améliore significativement") print("la qualité et l'efficacité du code Python.") print("#"*70)
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!