Apprendre à utiliser toutes les techniques de slicing pour extraire, modifier et manipuler les listes Python avec des exemples concrets, des cas pratiques et les bonnes pratiques
Le slicing (trançage) est une technique puissante en Python qui permet d'extraire des portions spécifiques d'une liste de manière efficace et concise. Cette opération est fondamentale pour la manipulation des données séquentielles.
Le slicing consiste à créer une nouvelle liste contenant une sélection d'éléments d'une liste originale, en spécifiant un intervalle d'indices. Contrairement à l'indexation simple qui retourne un seul élément, le slicing retourne toujours une liste (même si elle ne contient qu'un seul élément).
# Liste des villes marocaines villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir", "Meknès"] # Indexation simple vs Slicing ville_unique = villes_maroc[2] # Indexation: retourne un élément print(f"Indexation: {ville_unique}") # Output: Marrakech print(f"Type: {type(ville_unique)}") # Output: <class 'str'> portion_villes = villes_maroc[1:4] # Slicing: retourne une liste print(f"Slicing: {portion_villes}") # Output: ['Rabat', 'Marrakech', 'Fès'] print(f"Type: {type(portion_villes)}") # Output: <class 'list'> # Slicing avec un seul élément slice_unique = villes_maroc[3:4] # Retourne une liste avec un élément print(f"Slice d'un élément: {slice_unique}") # Output: ['Fès'] print(f"Type: {type(slice_unique)}") # Output: <class 'list'> # Le slicing crée une nouvelle liste (copie superficielle) originale = ["Plat marocain 1", "Plat marocain 2", "Plat marocain 3"] copie_slice = originale[0:2] copie_slice[0] = "Tajine modifié" print(f"Originale: {originale}") # Non modifiée print(f"Copie slice: {copie_slice}") # Modifiée
La syntaxe complète du slicing est liste[début:fin:pas]. Chaque paramètre est optionnel et a une signification spécifique dans la sélection des éléments.
# Liste des spécialités culinaires marocaines plats_maroc = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui", "Briouate", "Rfissa"] # Syntaxe de base: [start:stop:step] print("Liste complète:", plats_maroc) # start: indice de début (inclus) print("\nÀ partir de l'indice 2:", plats_maroc[2:]) # ['Pastilla', 'Harira', 'Méchoui', 'Briouate', 'Rfissa'] # stop: indice de fin (exclus) print("Jusqu'à l'indice 4 (exclus):", plats_maroc[:4]) # ['Tajine', 'Couscous', 'Pastilla', 'Harira'] # start et stop combinés print("De l'indice 1 à 5 (exclus):", plats_maroc[1:5]) # ['Couscous', 'Pastilla', 'Harira', 'Méchoui'] # step: pas de sélection print("Un plat sur deux:", plats_maroc[::2]) # ['Tajine', 'Pastilla', 'Méchoui', 'Rfissa'] # Tous les paramètres combinés print("De 1 à 6, un sur deux:", plats_maroc[1:6:2]) # ['Couscous', 'Harira', 'Briouate'] # Exemple pratique: sélectionner les régions du Maroc par groupe 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"] # Régions du nord (premières 4) regions_nord = regions_maroc[:4] print(f"\nRégions du nord: {regions_nord}") # Régions du sud (dernières 4) regions_sud = regions_maroc[-4:] print(f"Régions du sud: {regions_sud}") # Régions centrales (du milieu) regions_centrales = regions_maroc[4:8] print(f"Régions centrales: {regions_centrales}")
Il est crucial de comprendre la distinction fondamentale entre l'indexation (accès à un élément) et le slicing (extraction d'une portion). Cette différence impacte le type de retour et le comportement des opérations.
# Liste des monuments historiques marocains monuments = ["Hassan II", "Koutoubia", "Chellah", "Kasbah des Oudaias", "Médina de Fès"] # DIFFÉRENCE 1: Type de retour indexation_result = monuments[2] # Retourne un élément (string) slicing_result = monuments[2:3] # Retourne une liste print(f"Indexation [2]: {indexation_result} (type: {type(indexation_result)})") print(f"Slicing [2:3]: {slicing_result} (type: {type(slicing_result)})") # DIFFÉRENCE 2: Gestion des indices hors limites try: hors_limites_index = monuments[10] # Indexation: erreur IndexError except IndexError as e: print(f"\nIndexation hors limites: {e}") hors_limites_slice = monuments[10:15] # Slicing: liste vide print(f"Slicing hors limites: {hors_limites_slice}") # DIFFÉRENCE 3: Modification d'éléments sites_touristiques = ["Djemaa el-Fna", "Ouzoud", "Chefchaouen", "Merzouga"] # Modification par indexation (change un élément) sites_touristiques[1] = "Cascades d'Ouzoud" # Remplacement direct print(f"\nAprès modification indexation: {sites_touristiques}") # Modification par slicing (change une portion) sites_touristiques[2:4] = ["Ville bleue de Chefchaouen", "Dunes de Merzouga"] # Remplacement de slice print(f"Après modification slicing: {sites_touristiques}") # DIFFÉRENCE 4: Comportement avec les indices négatifs artisans = ["Potier", "Tisserand", "Brocantier", "Maroquinier", "Céramiste"] # Indexation négative: compte depuis la fin print(f"\nDernier artisan (index -1): {artisans[-1]}") # Slicing négatif: sélection depuis la fin print(f"Deux derniers artisans: {artisans[-2:]}") print(f"Tous sauf les deux derniers: {artisans[:-2]}") # DIFFÉRENCE 5: Utilisation dans les boucles produits_artisanaux = ["Tapis", "Poterie", "Cuir", "Lainage", "Bois sculpté"] # Boucle sur indexation (impossible car élément unique) print("\nParcours d'un élément indexé:") element = produits_artisanaux[0] print(element) # Un seul élément affiché # Boucle sur slicing (possible car liste) print("Parcours d'un slice:") for produit in produits_artisanaux[1:4]: print(f"- {produit}")
Le slicing simple permet d'extraire des portions de listes en utilisant uniquement les paramètres start (début) et stop (fin). Cette approche est la plus courante et essentielle pour manipuler efficacement les données séquentielles.
L'extraction de portions est l'opération de base du slicing. Elle permet de sélectionner un intervalle continu d'éléments depuis une liste, en spécifiant l'indice de début (inclus) et l'indice de fin (exclus).
# Liste des villes impériales du Maroc villes_imperiales = ["Fès", "Marrakech", "Meknès", "Rabat"] # Extraire les deux premières villes deux_premieres = villes_imperiales[0:2] print("Deux premières villes impériales:", deux_premieres) # Output: ['Fès', 'Marrakech'] # Extraire les deux dernières villes deux_dernieres = villes_imperiales[2:4] print("Deux dernières villes impériales:", deux_dernieres) # Output: ['Meknès', 'Rabat'] # Liste des spécialités culinaires par région specialites = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui", "Briouate"] # Extraire les plats principaux (indices 0 à 3) plats_principaux = specialites[0:4] print("\nPlats principaux marocains:", plats_principaux) # Extraire les entrées et desserts (indices 3 à 6) entrees_desserts = specialites[3:6] print("Entrées et desserts:", entrees_desserts) # Cas pratique: organisation d'un festival culturel artistes_festival = ["Najat Aatabou", "Saad Lamjarred", "Maitre Gims", "Asma Lmnawar", "Mohamed Hamaki", "Samira Said"] # Programme du premier jour (3 premiers artistes) jour1 = artistes_festival[0:3] print(f"\n? Programme Jour 1: {', '.join(jour1)}") # Programme du deuxième jour (3 derniers artistes) jour2 = artistes_festival[3:6] print(f"? Programme Jour 2: {', '.join(jour2)}")
Les indices positifs comptent depuis le début de la liste (0 pour le premier élément). Cette approche est intuitive et largement utilisée pour les opérations de slicing standard.
# Liste des sites touristiques marocains populaires sites_touristiques = [ "Djemaa el-Fna", # index 0 "Hassan II", # index 1 "Chefchaouen", # index 2 "Merzouga", # index 3 "Ouzoud", # index 4 "Volubilis", # index 5 "Aït Benhaddou" # index 6 ] # Slicing avec différents indices positifs print("Sites les plus visités (3 premiers):", sites_touristiques[0:3]) print("Sites du milieu (indices 2 à 5):", sites_touristiques[2:5]) print("À partir du 4ème site:", sites_touristiques[3:]) print("Jusqu'au 5ème site (exclus):", sites_touristiques[:4]) # Cas pratique: organisation d'un circuit touristique circuit_complet = ["Casablanca", "Rabat", "Fès", "Meknès", "Marrakech", "Agadir"] # Circuit court (villes du nord) circuit_nord = circuit_complet[0:4] print(f"\n?️ Circuit Nord ({len(circuit_nord)} jours):") for i, ville in enumerate(circuit_nord, 1): print(f" Jour {i}: {ville}") # Circuit sud (villes du sud) circuit_sud = circuit_complet[4:] print(f"\n?️ Circuit Sud ({len(circuit_sud)} jours):") for i, ville in enumerate(circuit_sud, 1): print(f" Jour {i}: {ville}") # Exemple avec des données numériques (températures mensuelles à Marrakech) temperatures_marrakech = [14, 16, 19, 22, 26, 30, 36, 35, 30, 25, 19, 15] # Températures du printemps (mars à mai) printemps = temperatures_marrakech[2:5] print(f"\n?️ Températures printanières à Marrakech: {printemps}°C") print(f"Moyenne printemps: {sum(printemps)/len(printemps):.1f}°C")
Les indices négatifs comptent depuis la fin de la liste (-1 pour le dernier élément). Cette approche est particulièrement utile pour accéder aux éléments de la fin sans connaître la taille exacte de la liste.
# Liste des plats traditionnels marocains plats_traditionnels = [ "Tajine", # index -7 "Couscous", # index -6 "Pastilla", # index -5 "Harira", # index -4 "Méchoui", # index -3 "Rfissa", # index -2 "Briouate" # index -1 ] # Slicing avec indices négatifs print("Les 3 derniers plats:", plats_traditionnels[-3:]) print("Tous sauf les 2 derniers:", plats_traditionnels[:-2]) print("Du 5ème avant-dernier au 2ème avant-dernier:", plats_traditionnels[-5:-2]) # Combinaison d'indices positifs et négatifs print("Du 2ème au 2ème avant-dernier:", plats_traditionnels[1:-2]) # Cas pratique: classement des joueurs de l'équipe nationale joueurs_maroc = ["Bono", "Hakimi", "Saiss", "Amrabat", "Ziyech", "En-Nesyri"] # Les 3 meilleurs buteurs (derniers dans cette liste) meilleurs_buteurs = joueurs_maroc[-3:] print(f"\n⚽ Meilleurs buteurs: {', '.join(meilleurs_buteurs)}") # Les défenseurs et milieux (tous sauf les 3 derniers) defenseurs_milieux = joueurs_maroc[:-3] print(f"? Défenseurs et milieux: {', '.join(defenseurs_milieux)}") # Exemple avec des dates historiques marocaines dates_historiques = [ "1956-03-02", # Indépendance "1961-03-03", # Accession au trône Hassan II "1975-11-06", # Marche verte "1999-07-23", # Accession au trône Mohammed VI "2011-07-01", # Réforme constitutionnelle "2022-12-10" # Quart de finale Mondial 2022 ] # Événements récents (3 derniers) evenements_recents = dates_historiques[-3:] print(f"\n? Événements historiques récents:") for evenement in evenements_recents: print(f" - {evenement}")
Contrairement à l'indexation simple, le slicing gère élégamment les indices hors limites en retournant une liste vide ou en s'arrêtant aux limites de la liste, sans générer d'erreur.
# Liste des régions administratives du Maroc regions_maroc = ["Casablanca-Settat", "Rabat-Salé-Kénitra", "Fès-Meknès"] # Comparaison indexation vs slicing avec indices hors limites print("Liste originale:", regions_maroc) print("Taille de la liste:", len(regions_maroc)) # INDEXATION: génère une erreur si hors limites try: region_hors_limites = regions_maroc[5] print("Région à l'indice 5:", region_hors_limites) except IndexError as e: print(f"❌ Indexation hors limites: {e}") # SLICING: gère silencieusement les indices hors limites slice_hors_limites = regions_maroc[5:10] print("✅ Slice [5:10] (hors limites):", slice_hors_limites) # Slice avec début hors limites mais fin dans les limites slice_debut_hors_limites = regions_maroc[10:2] # Début > fin → liste vide print("Slice [10:2] (début hors limites):", slice_debut_hors_limites) # Slice avec fin supérieure à la taille de la liste slice_fin_hors_limites = regions_maroc[1:100] print("Slice [1:100] (fin hors limites):", slice_fin_hors_limites) # Cas pratiques avec gestion robuste produits_artisanaux = ["Tapis", "Poterie", "Cuir"] # Fonction robuste pour extraire les N premiers produits def extraire_premiers(liste, n): # Le slicing gère automatiquement les cas où n > len(liste) return liste[:n] print(f"\n?️ 2 premiers produits: {extraire_premiers(produits_artisanaux, 2)}") print(f"?️ 5 premiers produits: {extraire_premiers(produits_artisanaux, 5)}") # Gestion des indices négatifs hors limites monuments = ["Tour Hassan", "Koutoubia"] # Indice négatif trop grand (en valeur absolue) slice_neg_hors_limites = monuments[-5:] # Équivalent à [0:] print(f"\n?️ Slice [-5:]: {slice_neg_hors_limites}") # Application pratique: pagination sécurisée def paginer(donnees, page, par_page=3): debut = (page - 1) * par_page fin = debut + par_page # Le slicing gère automatiquement les pages vides return donnees[debut:fin] villes = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] print(f"\n? Page 1: {paginer(villes, 1)}") print(f"? Page 2: {paginer(villes, 2)}") print(f"? Page 3 (hors limites): {paginer(villes, 3)}") # Liste vide
Le paramètre step (pas) dans le slicing permet de contrôler l'incrément entre les éléments sélectionnés. Cette fonctionnalité avancée offre une grande flexibilité pour extraire des motifs complexes, inverser des listes ou sélectionner des éléments alternés.
Le pas personnalisé permet de sauter un nombre spécifique d'éléments entre chaque sélection. Un pas de 2 sélectionne un élément sur deux, un pas de 3 sélectionne un élément sur trois, etc.
# Liste des 12 régions administratives du Maroc regions_maroc = [ "Tanger-Tétouan-Al Hoceïma", # index 0 "L'Oriental", # index 1 "Fès-Meknès", # index 2 "Rabat-Salé-Kénitra", # index 3 "Béni Mellal-Khénifra", # index 4 "Casablanca-Settat", # index 5 "Marrakech-Safi", # index 6 "Drâa-Tafilalet", # index 7 "Souss-Massa", # index 8 "Guelmim-Oued Noun", # index 9 "Laâyoune-Sakia El Hamra", # index 10 "Dakhla-Oued Ed-Dahab" # index 11 ] # Pas de 2: une région sur deux une_sur_deux = regions_maroc[::2] print("Régions avec pas de 2 (une sur deux):") for i, region in enumerate(une_sur_deux, 1): print(f" {i}. {region}") # Pas de 3: une région sur trois une_sur_trois = regions_maroc[::3] print(f"\nRégions avec pas de 3: {une_sur_trois}") # Pas de 4 avec début spécifique pas_quatre = regions_maroc[1::4] print(f"Régions à partir de l'index 1 avec pas de 4: {pas_quatre}") # Cas pratique: organisation d'un festival sur plusieurs jours artistes_mawazine = [ "Najat Aatabou", "Saad Lamjarred", "Maitre Gims", "Asma Lmnawar", "Mohamed Hamaki", "Samira Said", "Rita Ora", "Maroon 5" ] # Artistes des jours pairs (index 0, 2, 4, 6) jours_pairs = artistes_mawazine[::2] print(f"\n? Artistes des jours pairs: {', '.join(jours_pairs)}") # Artistes des jours impairs (index 1, 3, 5, 7) jours_impairs = artistes_mawazine[1::2] print(f"? Artistes des jours impairs: {', '.join(jours_impairs)}") # Exemple avec des données numériques (population des grandes villes) populations = [3700000, 580000, 930000, 1200000, 1150000, 850000] # Casablanca, Rabat, Fès, Marrakech, Tanger, Agadir # Villes avec population supérieure à 1 million (toutes les 2 villes) villes_metropoles = populations[::3] print(f"\n?️ Populations métropolitaines (pas de 3): {villes_metropoles}")
Un pas négatif permet de parcourir la liste en sens inverse. Le slicing [::-1] est la méthode la plus élégante pour inverser une liste sans modifier l'originale.
# Liste chronologique des dynasties marocaines dynasties = ["Idrissides", "Almoravides", "Almohades", "Mérinides", "Alaouites"] print("Ordre chronologique:", dynasties) # Inversion simple avec pas -1 dynasties_inversees = dynasties[::-1] print("Ordre inverse (pas -1):", dynasties_inversees) # Inversion avec sélection partielle trois_dernieres_inversees = dynasties[2::-1] # Depuis l'index 2 vers le début print("Trois dernières dynasties inversées:", trois_dernieres_inversees) # Inversion avec début et fin spécifiques inversion_partielle = dynasties[1:4:-1] # De l'index 1 à 4 en inverse print("Inversion partielle [1:4:-1]:", inversion_partielle) # Cas pratique: parcours touristique inversé circuit_touristique = ["Casablanca", "Rabat", "Fès", "Marrakech", "Agadir"] # Circuit dans l'ordre normal (nord au sud) print(f"\n? Circuit normal: {' → '.join(circuit_touristique)}") # Circuit inversé (sud au nord) circuit_inverse = circuit_touristique[::-1] print(f"? Circuit inversé: {' → '.join(circuit_inverse)}") # Application: lecture de données chronologiques inversées annees_croissance = [2018, 2019, 2020, 2021, 2022, 2023] taux_croissance = [3.0, 2.7, -7.2, 7.9, 1.3, 3.4] # Croissance PIB Maroc # Analyse des données les plus récentes d'abord annees_recentes = annees_croissance[::-1] taux_recents = taux_croissance[::-1] print(f"\n? Analyse économique (du plus récent au plus ancien):") for annee, taux in zip(annees_recentes, taux_recents): print(f" {annee}: {taux}% de croissance") # Pas négatif différent de -1 villes_cotieres = ["Tanger", "Casablanca", "El Jadida", "Safi", "Agadir", "Dakhla"] # Parcours inverse un sur deux cotieres_inverse_sur_deux = villes_cotieres[::-2] print(f"\n? Villes côtières inversées un sur deux: {cotieres_inverse_sur_deux}")
La combinaison du pas avec les paramètres start permet d'extraire des motifs complexes comme les éléments pairs/impairs, ou tout autre motif alterné selon des règles spécifiques.
# Liste des mois de l'année avec événements marocains mois_evenements = [ "Janvier: Nouvel An", "Février: Fête des Amandiers", "Mars: Fête de l'Indépendance", "Avril: Festival des Roses", "Mai: Fête du Travail", "Juin: Festival Gnaoua", "Juillet: Fête du Trône", "Août: Festival Mawazine", "Septembre: Rentrée Scolaire", "Octobre: Marathon de Marrakech", "Novembre: Marche Verte", "Décembre: Festival des Dattes" ] # Événements des mois pairs (index 1, 3, 5, 7, 9, 11) mois_pairs = mois_evenements[1::2] print("? Événements des mois pairs (Février, Avril, Juin...):") for evenement in mois_pairs: print(f" - {evenement}") # Événements des mois impairs (index 0, 2, 4, 6, 8, 10) mois_impairs = mois_evenements[::2] print(f"\n? Événements des mois impairs (Janvier, Mars, Mai...):") for evenement in mois_impairs: print(f" - {evenement}") # Cas pratique: organisation d'un tournoi sportif equipes_football = ["Wydad AC", "Raja CA", "FAR Rabat", "AS FAR", "MAS Fès", "OC Khouribga", "HUS Agadir", "RCA"] # Groupe A (équipes aux positions paires) groupe_a = equipes_football[::2] print(f"\n⚽ Groupe A: {', '.join(groupe_a)}") # Groupe B (équipes aux positions impaires) groupe_b = equipes_football[1::2] print(f"⚽ Groupe B: {', '.join(groupe_b)}") # Motif plus complexe: un sur trois avec décalage produits_export = ["Phosphates", "Agrumes", "Textiles", "Poissons", "Automobile", "Légumes", "Aéronautique", "Dattes", "Électronique", "Huile d'olive"] # Produits stratégiques (un sur trois à partir de l'index 0) strategiques_1 = produits_export[::3] print(f"\n? Produits stratégiques groupe 1: {strategiques_1}") # Produits stratégiques (un sur trois à partir de l'index 1) strategiques_2 = produits_export[1::3] print(f"? Produits stratégiques groupe 2: {strategiques_2}") # Produits stratégiques (un sur trois à partir de l'index 2) strategiques_3 = produits_export[2::3] print(f"? Produits stratégiques groupe 3: {strategiques_3}") # Application: analyse de données météorologiques alternées temperatures_annuelles = [15, 16, 18, 20, 23, 26, 29, 30, 27, 23, 19, 16] # Mensuelles à Rabat # Températures des saisons froides (mois impairs: Janvier, Mars, etc.) saisons_froides = temperatures_annuelles[::2] print(f"\n❄️ Températures saisons froides: {saisons_froides}") print(f" Moyenne: {sum(saisons_froides)/len(saisons_froides):.1f}°C") # Températures des saisons chaudes (mois pairs: Février, Avril, etc.) saisons_chaudes = temperatures_annuelles[1::2] print(f"☀️ Températures saisons chaudes: {saisons_chaudes}") print(f" Moyenne: {sum(saisons_chaudes)/len(saisons_chaudes):.1f}°C")
Le slicing avancé exploite des techniques sophistiquées comme l'omission de paramètres, la copie de listes et l'utilisation de variables dynamiques. Ces approches permettent d'écrire un code plus concis, flexible et maintenable.
L'omission des paramètres dans le slicing permet d'utiliser des valeurs par défaut intelligentes. Python interprète les paramètres manquants de manière à couvrir des cas d'usage courants de manière concise.
# Liste des villes impériales du Maroc et leurs spécialités villes_imperiales = ["Fès", "Marrakech", "Meknès", "Rabat"] specialites = ["Tajine Fassi", "Couscous Marrakchi", "Olives Meknassi", "Harira R'bati"] # Omission complète: [:] copie toute la liste copie_complete = villes_imperiales[:] print("Copie complète:", copie_complete) # Omission du début: [:n] → du début jusqu'à l'indice n (exclus) deux_premieres = specialites[:2] print("Deux premières spécialités:", deux_premieres) # Omission de la fin: [n:] → de l'indice n jusqu'à la fin deux_dernieres = villes_imperiales[2:] print("Deux dernières villes:", deux_dernieres) # Omission du début et de la fin: [::pas] → toute la liste avec un pas une_sur_deux = specialites[::2] print("Une spécialité sur deux:", une_sur_deux) # Cas pratique: organisation d'un festival culturel artistes = ["Najat Aatabou", "Saad Lamjarred", "Maitre Gims", "Asma Lmnawar", "Mohamed Hamaki"] # Programme du premier jour (première moitié) milieu = len(artistes) // 2 jour1 = artistes[:milieu] # Omission du début jour2 = artistes[milieu:] # Omission de la fin print(f"\n? Festival Mawazine - Programme:") print(f"Jour 1: {', '.join(jour1)}") print(f"Jour 2: {', '.join(jour2)}") # Application avec données économiques exportations = [25.3, 28.1, 31.5, 29.8, 33.2, 35.7] # Milliards de DH # Première moitié de l'année (janvier-juin) semestre1 = exportations[:6:2] # Tous les 2 mois semestre2 = exportations[1::2] # Décalé d'un mois print(f"\n? Exportations trimestrielles:") print(f"Trimestres pairs: {semestre1}") print(f"Trimestres impairs: {semestre2}") # Omission intelligente dans des conditions def get_derniers_elements(liste, n=3): # Si n est plus grand que la liste, retourne toute la liste return liste[-n:] monuments = ["Hassan II", "Koutoubia", "Chellah", "Kasbah"] print(f"\n?️ 2 derniers monuments: {get_derniers_elements(monuments, 2)}") print(f"?️ 10 derniers monuments: {get_derniers_elements(monuments, 10)}") # Gère automatiquement
Le slicing [:] est la méthode la plus élégante pour créer une copie superficielle d'une liste. Contrairement à l'affectation directe, cette technique crée un nouvel objet liste indépendant de l'original.
# Liste des produits artisanaux marocains avec leurs prix produits_originaux = [ {"nom": "Tapis Beni Ourain", "prix": 2500}, {"nom": "Poterie de Safi", "prix": 450}, {"nom": "Cuir de Fès", "prix": 1200} ] # COPIE SUPERFICIELLE avec slicing [:] copie_slicing = produits_originaux[:] # AFFECTATION DIRECTE (référence, pas une copie) reference = produits_originaux # Vérification de l'indépendance print("? Comparaison des identités:") print(f"Original == Copie slicing: {produits_originaux is copie_slicing}") print(f"Original == Référence: {produits_originaux is reference}") # Modification de la copie (n'affecte pas l'original) copie_slicing.append({"nom": "Nouveau produit", "prix": 500}) print(f"\n? Après ajout dans la copie:") print(f"Original: {len(produits_originaux)} produits") print(f"Copie: {len(copie_slicing)} produits") # Modification via la référence (affecte l'original) reference[0]["prix"] = 3000 # Modification en place print(f"\n? Après modification de prix via référence:") print(f"Original - Prix tapis: {produits_originaux[0]['prix']} DH") print(f"Copie - Prix tapis: {copie_slicing[0]['prix']} DH") # Cas pratique: gestion de stock avec historique def appliquer_promotion(produits, pourcentage): # Crée une copie pour ne pas modifier l'original produits_promotion = produits[:] for produit in produits_promotion: produit["prix_promo"] = produit["prix"] * (1 - pourcentage / 100) return produits_promotion # Application d'une promotion de 20% produits_promo = appliquer_promotion(produits_originaux, 20) print(f"\n?️ Promotion de 20% appliquée:") for i, (orig, promo) in enumerate(zip(produits_originaux, produits_promo)): print(f" {orig['nom']}: {orig['prix']} DH → {promo['prix_promo']:.0f} DH") # Vérification que l'original est intact print(f"\n✅ Original intact: {'prix_promo' not in produits_originaux[0]}") # Copie partielle avec slicing villes_maroc = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger"] villes_cop_partielle = villes_maroc[1:4] # Copie de Rabat, Fès, Marrakech print(f"\n?️ Copie partielle des villes: {villes_cop_partielle}")
L'utilisation de variables pour les paramètres de slicing permet de créer des extractions dynamiques et adaptatives. Cette approche est essentielle pour les applications où les indices dépendent de calculs ou d'entrées utilisateur.
# Liste des 12 mois avec données touristiques au Maroc mois_touristiques = [ {"mois": "Janvier", "visiteurs": 150000, "saison": "Basse"}, {"mois": "Février", "visiteurs": 180000, "saison": "Basse"}, {"mois": "Mars", "visiteurs": 220000, "saison": "Moyenne"}, {"mois": "Avril", "visiteurs": 280000, "saison": "Moyenne"}, {"mois": "Mai", "visiteurs": 350000, "saison": "Haute"}, {"mois": "Juin", "visiteurs": 420000, "saison": "Haute"}, {"mois": "Juillet", "visiteurs": 500000, "saison": "Pic"}, {"mois": "Août", "visiteurs": 480000, "saison": "Pic"}, {"mois": "Septembre", "visiteurs": 380000, "saison": "Haute"}, {"mois": "Octobre", "visiteurs": 300000, "saison": "Moyenne"}, {"mois": "Novembre", "visiteurs": 200000, "saison": "Basse"}, {"mois": "Décembre", "visiteurs": 170000, "saison": "Basse"} ] # Variables dynamiques pour les saisons debut_printemps, fin_printemps = 2, 5 # Mars à Mai debut_ete, fin_ete = 5, 9 # Juin à Septembre debut_automne, fin_automne = 9, 11 # Octobre à Novembre # Extraction dynamique par saison saison_printemps = mois_touristiques[debut_printemps:fin_printemps] saison_ete = mois_touristiques[debut_ete:fin_ete] saison_automne = mois_touristiques[debut_automne:fin_automne] print("?️ Statistiques touristiques par saison:") def calculer_statistiques(saison, nom_saison): visiteurs = [mois["visiteurs"] for mois in saison] total = sum(visiteurs) moyenne = total / len(visiteurs) print(f"\n{nom_saison}:") print(f" Mois: {', '.join(m['mois'] for m in saison)}") print(f" Total visiteurs: {total:,}") print(f" Moyenne/mois: {moyenne:,.0f}") calculer_statistiques(saison_printemps, "Printemps") calculer_statistiques(saison_ete, "Été") calculer_statistiques(saison_automne, "Automne") # Fonction générique pour extraire des tranches dynamiques def extraire_tranche(donnees, pourcentage_debut, pourcentage_fin): n = len(donnees) debut = int(n * pourcentage_debut / 100) fin = int(n * pourcentage_fin / 100) return donnees[debut:fin] # Application: extraction des 25% du milieu tranche_milieu = extraire_tranche(mois_touristiques, 25, 75) print(f"\n? Tranche 25%-75%: {len(tranche_milieu)} mois") for mois in tranche_milieu: print(f" - {mois['mois']}: {mois['visiteurs']:,} visiteurs") # Slicing avec calcul dynamique d'indices regions_maroc = ["Tanger", "Rabat", "Casablanca", "Fès", "Marrakech", "Agadir"] # Extraire le tiers central dynamiquement tiers = len(regions_maroc) // 3 regions_centrales = regions_maroc[tiers:-tiers] print(f"\n?️ Régions centrales (tiers médian): {regions_centrales}") # Slicing avec pas variable def echantillonner(donnees, frequence): # Retourne un élément tous les 'frequence' éléments return donnees[::frequence] temperatures = [15, 16, 17, 18, 19, 20, 21, 22, 23, 24] print(f"\n?️ Échantillonnage des températures:") print(f"Frequence 2: {echantillonner(temperatures, 2)}") print(f"Frequence 3: {echantillonner(temperatures, 3)}") print(f"Frequence 4: {echantillonner(temperatures, 4)}")
Le slicing ne se limite pas à l'extraction de données - il permet également de modifier les listes de manière précise et efficace. Ces techniques offrent un contrôle granulaire sur l'insertion, le remplacement et la suppression d'éléments.
Le remplacement par slice permet de substituer une portion de liste par de nouveaux éléments. Cette technique est plus efficace que les modifications élément par élément lorsqu'on travaille avec des intervalles contigus.
# Liste des villes impériales du Maroc avec leurs anciens noms villes_imperiales = ["Fès", "Marrakech", "Meknès", "Rabat"] print("Villes impériales originales:", villes_imperiales) # Remplacement simple: un élément villes_imperiales[1] = "Marrakech la Rouge" print("Après remplacement index 1:", villes_imperiales) # Remplacement par slice: plusieurs éléments villes_imperiales[2:4] = ["Meknès la Verte", "Rabat la Blanche"] print("Après remplacement slice [2:4]:", villes_imperiales) # Cas pratique: mise à jour de menu de restaurant marocain menu_restaurant = ["Tajine poulet", "Couscous viande", "Pastilla pigeon", "Harira", "Méchoui"] print(f"\n?️ Menu original: {menu_restaurant}") # Remplacement des plats principaux (indices 0 à 2) menu_restaurant[0:3] = ["Tajine de veau aux pruneaux", "Couscous aux 7 légumes", "Pastilla fruits de mer"] print(f"?️ Menu mis à jour: {menu_restaurant}") # Remplacement avec taille différente produits_artisanaux = ["Tapis", "Poterie", "Cuir", "Bois"] print(f"\n?️ Produits originaux: {produits_artisanaux}") # Remplacer 2 éléments par 3 éléments (liste s'agrandit) produits_artisanaux[1:3] = ["Poterie de Safi", "Cuir de Fès", "Zellige"] print(f"?️ Après expansion: {produits_artisanaux}") # Remplacer 3 éléments par 1 élément (liste rétrécit) produits_artisanaux[0:3] = ["Tapis Beni Ourain"] print(f"?️ Après réduction: {produits_artisanaux}") # Application: correction de données historiques dates_historiques = ["1956", "1961", "1971", "1999"] # Erreur: 1971 devrait être 1975 evenements = ["Indépendance", "Hassan II", "Réforme", "Mohammed VI"] # Correction groupée dates_historiques[2:3] = ["1975"] # Correction de la date evenements[2:3] = ["Marche Verte"] # Correction de l'événement print(f"\n? Données historiques corrigées:") for date, evenement in zip(dates_historiques, evenements): print(f" {date}: {evenement}")
L'insertion par slicing utilise un slice de longueur zéro pour insérer des éléments à une position spécifique sans supprimer d'éléments existants. Cette technique est plus élégante que l'utilisation de insert() pour des insertions multiples.
# Liste des monuments historiques du Maroc monuments = ["Hassan II", "Koutoubia", "Chellah"] print("Monuments initiaux:", monuments) # Insertion simple avec slice de longueur zéro monuments[1:1] = ["Tour Hassan"] # Insert à l'index 1 print("Après insertion à index 1:", monuments) # Insertion multiple monuments[3:3] = ["Kasbah des Oudaias", "Médina de Fès"] print("Après insertion multiple à index 3:", monuments) # Insertion au début (index 0) monuments[0:0] = ["Volubilis"] print("Après insertion au début:", monuments) # Insertion à la fin (équivalent à append mais pour multiples éléments) monuments[len(monuments):] = ["Aït Benhaddou", "Mausolée Mohammed V"] print("Après insertion à la fin:", monuments) # Cas pratique: planning d'événements culturels programme_festival = ["Concert Najat", "Spectacle Gnaoua", "Exposition artisanat"] print(f"\n? Programme initial: {programme_festival}") # Insertion d'événements supplémentaires programme_festival[1:1] = ["Atelier cuisine", "Défilé mode"] # Entre concert et spectacle programme_festival[len(programme_festival):] = ["Feu d'artifice"] # En finale print(f"? Programme enrichi: {programme_festival}") # Application: gestion de stock avec réapprovisionnement def reapprovisionner(stock, nouveaux_produits, position=0): # Insertion de nouveaux produits à une position spécifique stock[position:position] = nouveaux_produits return stock stock_epicerie = ["Huile d'olive", "Miel", "Amandes"] nouveaux = ["Dattes", "Figues", "Raisins secs"] stock_epicerie = reapprovisionner(stock_epicerie, nouveaux, 1) print(f"\n? Stock après réapprovisionnement: {stock_epicerie}") # Insertion stratégique dans une liste triée villes_par_population = ["Casablanca", "Fès", "Marrakech", "Salé"] nouvelle_ville = "Tanger" # Doit être insérée entre Fès et Marrakech # Trouver la position d'insertion position_insertion = 2 # Après Fès, avant Marrakech villes_par_population[position_insertion:position_insertion] = [nouvelle_ville] print(f"\n?️ Villes par population: {villes_par_population}")
La suppression par slice utilise l'affectation d'une liste vide à un slice pour supprimer des éléments. Cette méthode est plus efficace que les suppressions individuelles pour des intervalles contigus.
# Liste des spécialités culinaires marocaines specialites = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui", "Briouate"] print("Spécialités complètes:", specialites) # Suppression d'un seul élément specialites[2:3] = [] # Supprime Pastilla print("Après suppression index 2:", specialites) # Suppression d'une plage d'éléments specialites[3:5] = [] # Supprime Harira et Méchoui print("Après suppression slice [3:5]:", specialites) # Suppression depuis le début specialites[:1] = [] # Supprime le premier élément print("Après suppression du début:", specialites) # Suppression depuis la fin specialites[1:] = [] # Supprime tout sauf le premier print("Après suppression de la fin:", specialites) # Cas pratique: gestion des participants à un événement participants = ["Ahmed", "Fatima", "Mehdi", "Samira", "Youssef", "Leila"] print(f"\n? Participants initiaux ({len(participants)}): {participants}") # Suppression des participants qui annulent (indices 1 et 4) participants[4:5] = [] # Youssef annule participants[1:2] = [] # Fatima annule print(f"? Participants après annulations ({len(participants)}): {participants}") # Application: nettoyage de données avec critères def filtrer_donnees_aberrantes(donnees, seuil_min, seuil_max): # Supprime les données en dehors des seuils donnees_propres = donnees[:] # Copie i = 0 while i < len(donnees_propres): if donnees_propres[i] < seuil_min or donnees_propres[i] > seuil_max: donnees_propres[i:i+1] = [] # Suppression sécurisée else: i += 1 return donnees_propres temperatures = [15, 18, 22, 45, 25, -5, 28, 30] # Données avec valeurs aberrantes temperatures_filtrees = filtrer_donnees_aberrantes(temperatures, 10, 40) print(f"\n?️ Températures originales: {temperatures}") print(f"?️ Températures filtrées: {temperatures_filtrees}") # Suppression alternative avec del produits = ["Tapis", "Poterie", "Cuir", "Bois", "Zellige"] print(f"\n?️ Avant suppression del: {produits}") # Equivalent à produits[1:3] = [] del produits[1:3] print(f"?️ Après suppression del: {produits}")
Le slicing permet de redimensionner dynamiquement une liste en contrôlant précisément sa longueur. Cette technique est utile pour le padding, le truncating ou l'ajustement de données à une taille spécifique.
# Liste des régions touristiques du Maroc regions = ["Marrakech", "Agadir", "Fès"] print("Régions initiales:", regions) # Agrandissement avec valeur par défaut regions[len(regions):] = ["Nouvelle région"] * 2 # Ajoute 2 éléments print("Après agrandissement:", regions) # Réduction (troncature) regions[3:] = [] # Garde seulement les 3 premiers éléments print("Après réduction:", regions) # Fonction de redimensionnement générique def redimensionner_liste(liste, nouvelle_taille, valeur_par_defaut=None): taille_actuelle = len(liste) if nouvelle_taille > taille_actuelle: # Agrandissement liste.extend([valeur_par_defaut] * (nouvelle_taille - taille_actuelle)) elif nouvelle_taille < taille_actuelle: # Réduction liste[:] = liste[:nouvelle_taille] # Si égale, ne rien faire return liste # Test de la fonction villes = ["Casablanca", "Rabat"] print(f"\n?️ Test redimensionnement:") print(f"Original: {villes}") print(f"Agrandi à 5: {redimensionner_liste(villes[:], 5, 'À définir')}") print(f"Réduit à 1: {redimensionner_liste(villes[:], 1)}") # Cas pratique: normalisation de données pour traitement notes_eleves = [15, 18, 12] # Notes de 3 élèves notes_eleves[3:] = [0] * 2 # Pad avec des 0 pour 5 élèves print(f"\n? Notes padées: {notes_eleves}") # Application: ajustement de budget par département budgets = [100000, 150000, 200000, 180000] # Budgets de 4 départements nouveau_budget_total = 500000 # Ajustement proportionnel budget_actuel = sum(budgets) facteur_ajustement = nouveau_budget_total / budget_actuel budgets_ajustes = [int(b * facteur_ajustement) for b in budgets] # Redimensionnement si nécessaire if len(budgets_ajustes) > 4: budgets_ajustes[4:] = [] # Troncature elif len(budgets_ajustes) < 4: budgets_ajustes[len(budgets_ajustes):] = [0] * (4 - len(budgets_ajustes)) # Padding print(f"\n? Budgets ajustés: {budgets_ajustes}") print(f"? Total: {sum(budgets_ajustes)} DH") # Redimensionnement circulaire pour animations def animation_chargement(symboles, largeur=10): # Ajuste la liste de symboles à la largeur désirée symboles = symboles[:largeur] # Troncature si trop long if len(symboles) < largeur: symboles.extend([' '] * (largeur - len(symboles))) # Padding avec espaces return '[' + ''.join(symboles) + ']' barre_chargement = ['█', '█', '█'] # 3/10 de progression print(f"\n? Barre de chargement: {animation_chargement(barre_chargement)}")
Cette section présente des cas concrets d'utilisation du slicing pour résoudre des problèmes courants en programmation. Ces exercices permettent de consolider les concepts abordés et de développer une maîtrise avancée des techniques de manipulation de listes.
L'inversion d'une liste est une opération fréquente. Bien que Python fournisse la méthode reverse(), le slicing offre une alternative élégante qui préserve la liste originale.
# Liste des dynasties marocaines dans l'ordre chronologique dynasties = ["Idrissides", "Almoravides", "Almohades", "Mérinides", "Alaouites"] print("Ordre chronologique:", dynasties) # Méthode 1: Slicing avec pas négatif (recommandée) dynasties_inversees = dynasties[::-1] print("Inversion avec [::-1]:", dynasties_inversees) # Méthode 2: Slicing avec indices négatifs explicites dynasties_inversees2 = dynasties[-1::-1] print("Inversion avec [-1::-1]:", dynasties_inversees2) # Vérification que l'original est intact print("Original intact:", dynasties) # Comparaison avec la méthode reverse() dynasties_copie = dynasties.copy() dynasties_copie.reverse() # Modifie la liste originale print("Avec reverse():", dynasties_copie) print("Original modifié?:", dynasties is dynasties_copie) # Cas pratique: parcours touristique inversé circuit_touristique = ["Casablanca", "Rabat", "Fès", "Marrakech", "Agadir"] circuit_retour = circuit_touristique[::-1] print(f"\n? Circuit aller: {' → '.join(circuit_touristique)}") print(f"? Circuit retour: {' → '.join(circuit_retour)}") # Application: analyse de données chronologiques inversées annees = [2018, 2019, 2020, 2021, 2022, 2023] croissance_pib = [3.0, 2.7, -7.2, 7.9, 1.3, 3.4] # % # Analyse du plus récent au plus ancien annees_recentes = annees[::-1] croissance_recente = croissance_pib[::-1] print(f"\n? Analyse économique (du plus récent):") for annee, taux in zip(annees_recentes, croissance_recente): print(f" {annee}: {taux}% de croissance") # Exercice: inversion partielle villes = ["Tanger", "Tétouan", "Chefchaouen", "Fès", "Meknès"] villes_partiellement_inversees = villes[0:2] + villes[2:5][::-1] print(f"\n?️ Inversion partielle: {villes_partiellement_inversees}")
L'extraction des éléments de début et de fin d'une liste est une opération très courante. Le slicing offre des techniques concises pour ces extractions sans avoir besoin de connaître la taille exacte de la liste.
# Liste des 12 régions administratives du Maroc 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" ] # Extraction des premiers éléments trois_premieres = regions_maroc[:3] print("Trois premières régions:", trois_premieres) # Extraction des derniers éléments trois_dernieres = regions_maroc[-3:] print("Trois dernières régions:", trois_dernieres) # Extraction combinée: premiers et derniers premiers_et_derniers = regions_maroc[:2] + regions_maroc[-2:] print("Deux premières et deux dernières:", premiers_et_derniers) # Cas pratique: classement des joueurs de football joueurs_maroc = ["Bono", "Hakimi", "Saiss", "Amrabat", "Ziyech", "En-Nesyri", "Boufal"] # Les 3 meilleurs (défenseurs) et 3 attaquants defenseurs = joueurs_maroc[:3] attaquants = joueurs_maroc[-3:] print(f"\n⚽ Défenseurs: {', '.join(defenseurs)}") print(f"⚽ Attaquants: {', '.join(attaquants)}") # Fonction générique pour extraire les N premiers et derniers def extraire_extremites(liste, n=1): # Retourne les n premiers et n derniers éléments if len(liste) <= n * 2: return liste # Si liste trop courte, retourner tout return liste[:n] + liste[-n:] # Test de la fonction specialites_culinaires = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui", "Briouate"] print(f"\n?️ 2 premières et dernières spécialités:") print(extraire_extremites(specialites_culinaires, 2)) # Application: analyse des températures extrêmes temperatures_annuelles = [8, 10, 12, 15, 18, 22, 26, 30, 28, 24, 19, 14] # Mensuelles à Rabat # Mois les plus froids (premiers et derniers de l'année) mois_froids = temperatures_annuelles[:3] + temperatures_annuelles[-2:] moyenne_froide = sum(mois_froids) / len(mois_froids) print(f"\n❄️ Températures des mois froids: {mois_froids}") print(f"❄️ Moyenne: {moyenne_froide:.1f}°C") # Extraction sécurisée avec gestion des petites listes def premiers_et_derniers_securise(liste, n): # Gère les cas où n est plus grand que la moitié de la liste n = min(n, len(liste) // 2) return liste[:n] + liste[-n:] petite_liste = ["A", "B", "C"] print(f"\n? Extraction sécurisée: {premiers_et_derniers_securise(petite_liste, 2)}")
La division d'une liste en sous-listes de taille égale (chunks) est essentielle pour le traitement par lots, la pagination ou le parallélisme. Le slicing permet d'implémenter cette fonctionnalité de manière élégante.
# Liste des villes marocaines à visiter villes_visite = ["Casablanca", "Rabat", "Fès", "Meknès", "Marrakech", "Agadir", "Tanger", "Tétouan", "Chefchaouen", "Essaouira"] # Division en chunks de 3 villes taille_chunk = 3 chunks = [villes_visite[i:i + taille_chunk] for i in range(0, len(villes_visite), taille_chunk)] print("Villes divisées en chunks de 3:") for i, chunk in enumerate(chunks, 1): print(f" Semaine {i}: {', '.join(chunk)}") # Fonction générique pour diviser en chunks def diviser_en_chunks(liste, taille_chunk): # Divise la liste en sous-listes de taille spécifiée return [liste[i:i + taille_chunk] for i in range(0, len(liste), taille_chunk)] # Cas pratique: organisation d'un tournoi de football equipes = ["Wydad AC", "Raja CA", "FAR Rabat", "AS FAR", "MAS Fès", "OC Khouribga", "HUS Agadir", "RCA"] groupes = diviser_en_chunks(equipes, 4) print(f"\n⚽ Groupes du tournoi:") for i, groupe in enumerate(groupes, 1): print(f" Groupe {i}: {', '.join(groupe)}") # Application: traitement de données par lots donnees_capteurs = [25.3, 26.1, 24.8, 25.9, 26.5, 25.7, 24.9, 25.2, 26.0, 25.5, 24.7, 25.8] # Températures horaires # Calcul des moyennes par tranches de 4 heures tranches_4h = diviser_en_chunks(donnees_capteurs, 4) moyennes_4h = [sum(tranche) / len(tranche) for tranche in tranches_4h] print(f"\n?️ Moyennes par tranche de 4h:") for i, moyenne in enumerate(moyennes_4h, 1): print(f" Tranche {i}: {moyenne:.1f}°C") # Gestion des chunks de taille variable def chunks_adaptatifs(liste, n_chunks): # Divise en approximativement n chunks de taille similaire taille_base = len(liste) // n_chunks reste = len(liste) % n_chunks chunks = [] debut = 0 for i in range(n_chunks): fin = debut + taille_base + (1 if i < reste else 0) chunks.append(liste[debut:fin]) debut = fin return chunks artistes = ["Najat", "Saad", "Maitre Gims", "Asma", "Hamaki", "Samira"] jours_festival = chunks_adaptatifs(artistes, 3) print(f"\n? Programmation festival (3 jours):") for i, jour in enumerate(jours_festival, 1): print(f" Jour {i}: {', '.join(jour)}")
Le filtrage par position permet de sélectionner des éléments selon leur index plutôt que leur valeur. Cette technique est utile pour l'échantillonnage systématique ou la sélection d'éléments à intervalles réguliers.
# Liste des mois avec données touristiques au Maroc mois_touristiques = [ {"mois": "Janvier", "visiteurs": 150000, "saison": "Basse"}, {"mois": "Février", "visiteurs": 180000, "saison": "Basse"}, {"mois": "Mars", "visiteurs": 220000, "saison": "Moyenne"}, {"mois": "Avril", "visiteurs": 280000, "saison": "Moyenne"}, {"mois": "Mai", "visiteurs": 350000, "saison": "Haute"}, {"mois": "Juin", "visiteurs": 420000, "saison": "Haute"}, {"mois": "Juillet", "visiteurs": 500000, "saison": "Pic"}, {"mois": "Août", "visiteurs": 480000, "saison": "Pic"}, {"mois": "Septembre", "visiteurs": 380000, "saison": "Haute"}, {"mois": "Octobre", "visiteurs": 300000, "saison": "Moyenne"}, {"mois": "Novembre", "visiteurs": 200000, "saison": "Basse"}, {"mois": "Décembre", "visiteurs": 170000, "saison": "Basse"} ] # Filtrage des mois pairs (index impairs: 1, 3, 5, ...) mois_pairs = mois_touristiques[1::2] print("? Mois pairs (Février, Avril, Juin...):") for mois in mois_pairs: print(f" {mois['mois']}: {mois['visiteurs']:,} visiteurs") # Filtrage des trimestres (un mois sur trois) premiers_mois_trimestres = mois_touristiques[::3] print(f"\n? Premier mois de chaque trimestre:") for mois in premiers_mois_trimestres: print(f" {mois['mois']}: {mois['saison']} saison") # Cas pratique: sélection d'échantillons pour étude def echantillon_systematique(population, taille_echantillon): # Sélectionne un échantillon systématique if taille_echantillon <= 0: return [] pas = max(1, len(population) // taille_echantillon) return population[::pas][:taille_echantillon] # Application: étude sur les régions marocaines regions_etude = [ "Région Nord", "Région Centre", "Région Sud", "Région Est", "Région Ouest", "Région Côtière", "Région Montagneuse", "Région Désertique", "Région Urbaine", "Région Rurale" ] echantillon = echantillon_systematique(regions_etude, 4) print(f"\n? Échantillon systématique (4 régions):") print(echantillon) # Filtrage par plages de positions def filtrer_par_tranches(donnees, tranches): # Filtre les données selon des plages d'indices resultat = [] for debut, fin in tranches: resultat.extend(donnees[debut:fin]) return resultat # Sélection des saisons touristiques (printemps et été) tranches_saisons = [(2, 6)] # Mars à Juin (indices 2 à 5) saisons_selection = filtrer_par_tranches(mois_touristiques, tranches_saisons) print(f"\n?️ Saisons printemps-été:") for mois in saisons_selection: print(f" {mois['mois']}: {mois['visiteurs']:,} visiteurs ({mois['saison']})") # Application avancée: sélection alternée pour équilibrage produits = ["Tapis", "Poterie", "Cuir", "Bois", "Zellige", "Céramique", "Vannerie"] # Pour une exposition, sélectionner un produit sur deux produits_exposition = produits[::2] print(f"\n? Produits sélectionnés pour exposition:") print(produits_exposition) # Filtrage avec condition de position complexe def positions_multiples(liste, pas=1, decalage=0): # Filtre avec pas et décalage personnalisés return liste[decalage::pas] villes = ["Casablanca", "Rabat", "Fès", "Marrakech", "Agadir", "Tanger"] selection = positions_multiples(villes, pas=2, decalage=1) print(f"\n?️ Sélection avec pas=2, décalage=1: {selection}")
Maîtriser le slicing implique non seulement de connaître ses fonctionnalités, mais aussi d'éviter les pièges courants et de choisir les bonnes approches selon le contexte. Cette section couvre les erreurs fréquentes, les considérations de performance et les guidelines d'utilisation.
Le slicing, bien que puissant, présente plusieurs pièges subtils qui peuvent conduire à des bugs difficiles à détecter. La compréhension de ces pièges est essentielle pour écrire du code robuste.
# PIÈGE 1: Confusion entre copie et référence villes_originales = ["Casablanca", "Rabat", "Fès"] # MAUVAISE APPROCHE: affectation directe (référence) villes_reference = villes_originales # Crée une référence, pas une copie villes_reference.append("Marrakech") # Modifie aussi l'originale! print("? Piège référence - Originale modifiée:", villes_originales) # BONNE APPROCHE: copie avec slicing villes_originales = ["Casablanca", "Rabat", "Fès"] # Reset villes_copie = villes_originales[:] # Crée une vraie copie villes_copie.append("Marrakech") print("? Bonne pratique - Originale intacte:", villes_originales) # PIÈGE 2: Slicing avec indices négatifs mal compris produits = ["Tapis", "Poterie", "Cuir", "Bois"] # MAUVAISE COMPRÉHENSION: [-2:-1] vs [-2:] slice_erreur = produits[-2:-1] # Un seul élément (indice -2 seulement) slice_correct = produits[-2:] # Deux éléments (indices -2 et -1) print(f"\n? Piège indices négatifs: {slice_erreur}") print(f"? Compréhension correcte: {slice_correct}") # PIÈGE 3: Modification pendant l'itération monuments = ["Hassan II", "Koutoubia", "Chellah", "Kasbah"] # DANGER: modifier une liste pendant l'itération print("\n⚠️ Piège modification pendant itération:") try: for i, monument in enumerate(monuments): if "II" in monument: monuments[i:i+1] = [] # Supprime pendant l'itération print(monument) except Exception as e: print(f"Erreur: {e}") # BONNE APPROCHE: itérer sur une copie monuments = ["Hassan II", "Koutoubia", "Chellah", "Kasbah"] print("\n? Itération sécurisée sur copie:") for monument in monuments[:]: # Itère sur une copie if "II" in monument: monuments.remove(monument) # Sûr car on modifie l'originale print(monument) # PIÈGE 4: Slicing avec step 0 (erreur) villes = ["Casablanca", "Rabat", "Fès"] try: resultat = villes[::0] # Step 0 interdit except ValueError as e: print(f"\n? Piège step 0: {e}") # PIÈGE 5: Oubli que le slicing crée une nouvelle liste donnees_lourdes = ["grosse_donnee"] * 1000000 # MAUVAIS: copie inutile de données volumineuses sous_ensemble = donnees_lourdes[:] # Copie coûteuse! print(f"\n⚠️ Copie de liste volumineuse: {len(sous_ensemble)} éléments") # MEILLEUR: utiliser des vues ou itérer directement for i in range(0, len(donnees_lourdes), 100000): traitement = donnees_lourdes[i:i+1000] # Petites copies successives # Traiter le sous-ensemble print("? Traitement par petits chunks pour économiser la mémoire")
Le choix entre le slicing et d'autres méthodes doit prendre en compte les considérations de performance. Le slicing est généralement efficace, mais peut être contre-productif dans certains scénarios.
import time # Données de test: liste des codes postaux marocains codes_postaux = [str(i).zfill(5) for i in range(10000, 20000)] # 10,000 éléments # TEST 1: Copie complète - slicing vs copy() print("? Test performance - Copie complète de 10,000 éléments") start = time.time() copie_slicing = codes_postaux[:] # Slicing temps_slicing = time.time() - start start = time.time() copie_method = codes_postaux.copy() # Méthode copy() temps_copy = time.time() - start print(f"Slicing [:]: {temps_slicing:.6f} secondes") print(f"Méthode copy(): {temps_copy:.6f} secondes") print(f"Rapport: {temps_slicing/temps_copy:.2f}x") # TEST 2: Extraction vs Filtrage print("\n? Test performance - Extraction de sous-ensemble") # Méthode 1: Slicing simple start = time.time() sous_ensemble_slice = codes_postaux[2000:3000] # 1,000 éléments temps_slice = time.time() - start # Méthode 2: Comprehension list avec condition start = time.time() sous_ensemble_comp = [cp for i, cp in enumerate(codes_postaux) if 2000 <= i < 3000] temps_comp = time.time() - start print(f"Slicing direct: {temps_slice:.6f} secondes") print(f"Compréhension liste: {temps_comp:.6f} secondes") print(f"Slicing est {temps_comp/temps_slice:.1f}x plus rapide") # TEST 3: Inversion - slicing vs reverse() villes = ["Casablanca", "Rabat", "Fès", "Marrakech"] * 1000 # 4,000 éléments print("\n? Test performance - Inversion de liste") # Méthode 1: Slicing (crée une nouvelle liste) start = time.time() inverse_slice = villes[::-1] temps_inverse_slice = time.time() - start # Méthode 2: reverse() (modifie sur place) villes_copie = villes.copy() # Copie pour test équitable start = time.time() villes_copie.reverse() temps_reverse = time.time() - start print(f"Slicing [::-1]: {temps_inverse_slice:.6f} secondes") print(f"Méthode reverse(): {temps_reverse:.6f} secondes") print(f"reverse() est {temps_inverse_slice/temps_reverse:.1f}x plus rapide") # CONSIDÉRATIONS MÉMOIRE print("\n? Considérations mémoire:") # Slicing crée une nouvelle liste → consommation mémoire grande_liste = list(range(1000000)) # 1 million d'éléments import sys mem_originale = sys.getsizeof(grande_liste) mem_slice = sys.getsizeof(grande_liste[:]) print(f"Taille mémoire originale: {mem_originale / 1024 / 1024:.2f} MB") print(f"Taille mémoire après slicing: {mem_slice / 1024 / 1024:.2f} MB") print(f"⚠️ Slicing double l'utilisation mémoire!") # RECOMMANDATION: utiliser des générateurs pour les grandes données def generateur_slice(liste, taille_chunk=1000): # Génère des chunks sans tout charger en mémoire for i in range(0, len(liste), taille_chunk): yield liste[i:i + taille_chunk] print("\n? Solution mémoire: générateur avec chunks")
Le choix entre le slicing et les méthodes natives de liste dépend du contexte d'utilisation. Chaque approche a ses avantages spécifiques qu'il faut connaître pour faire les bons choix architecturaux.
# SCÉNARIO 1: Extraction de sous-ensemble → SLICING villes_maroc = ["Casablanca", "Rabat", "Fès", "Marrakech", "Agadir", "Tanger"] # BON: Slicing pour extraction contiguë villes_nord = villes_maroc[:3] # Clarté et performance villes_sud = villes_maroc[3:] # Élégant et efficace # MAUVAIS: Boucle manuelle inutile villes_nord_manuelles = [] for i in range(3): villes_nord_manuelles.append(villes_maroc[i]) print("?️ Extraction géographique - Slicing recommandé:") print(f"Villes du nord: {villes_nord}") print(f"Villes du sud: {villes_sud}") # SCÉNARIO 2: Recherche d'élément → MÉTHODES DE LISTE specialites = ["Tajine", "Couscous", "Pastilla", "Harira"] # BON: index() pour recherche try: position = specialites.index("Couscous") print(f"\n?️ Couscous trouvé à l'index: {position}") except ValueError: print("Couscous non trouvé") # MAUVAIS: Slicing manuel pour recherche for i in range(len(specialites)): if specialites[i] == "Couscous": position_manuelle = i break # SCÉNARIO 3: Inversion → CHOIX STRATÉGIQUE dates_historiques = ["1956", "1961", "1975", "1999"] # SLICING si on veut garder l'originale dates_inversees = dates_historiques[::-1] # Originale préservée # reverse() si modification sur place acceptable dates_copie = dates_historiques.copy() dates_copie.reverse() # Plus rapide, modifie la liste print(f"\n? Slicing pour inversion non-destructive: {dates_inversees}") print(f"? reverse() pour performance: {dates_copie}") # SCÉNARIO 4: Suppression multiple → SLICING AVANCÉ participants = ["Ahmed", "Fatima", "Mehdi", "Samira", "Youssef"] # BON: Slicing pour suppression de plage participants[1:3] = [] # Supprime Fatima et Mehdi en une opération # MAUVAIS: Suppressions individuelles multiples del participants[1] # Moins efficace pour plusieurs éléments del participants[2] # Réindexation à chaque suppression print(f"\n? Suppression par slicing: {participants}") # GUIDE DE DÉCISION RAPIDE print("\n? Guide de décision:") print("✅ UTILISER SLICING quand:") print(" - Extraction de sous-ensembles contigus") print(" - Création de copies non modifiables") print(" - Opérations avancées (pas, inversion)") print(" - Suppression/insertion de plages") print("✅ UTILISER MÉTHODES quand:") print(" - Recherche d'éléments (index, in)") print(" - Ajout/suppression ponctuelle (append, remove)") print(" - Modification sur place acceptable (reverse)") print(" - Opérations globales (sort, count)") # EXEMPLE D'UTILISATION HYBRIDE OPTIMALE def traiter_donnees_optimise(donnees): # Combinaison intelligente des techniques # Slicing pour extraction efficace donnees_traitees = donnees[100:900] # Ignorer les bords # Méthodes pour manipulations spécifiques if "erreur" in donnees_traitees: donnees_traitees.remove("erreur") # Slicing pour réorganisation return donnees_traitees[::2] # Un élément sur deux print("\n? Utilisation hybride optimale recommandée")
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!