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

Maîtriser le Slicing des Listes Python : Guide Complet pour Débutants et Experts

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

Les Fondamentaux du Slicing des Listes

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.

Qu'est-ce que le slicing sur une liste ?

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).

concept_slicing.py
# 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

Syntaxe de base : liste[start:stop:step]

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.

syntaxe_slicing.py
# 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}")

Différence entre indexation et slicing sur les listes

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.

difference_indexation_slicing.py
# 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}")

Slicing Simple avec Start et Stop

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.

Extraire une portion de liste

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).

extraire_portion.py
# 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)}")

Slicing avec indices positifs

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.

slicing_indices_positifs.py
# 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")

Slicing avec indices négatifs

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.

slicing_indices_negatifs.py
# 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}")

Gestion des indices hors limites dans les listes

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.

gestion_indices_hors_limites.py
# 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 : Contrôler le Pas

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.

Slicing avec un pas personnalisé

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.

pas_personnalise.py
# 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}")

Pas négatif pour inverser une liste

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.

pas_negatif.py
# 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}")

Extraire des éléments alternés

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.

elements_alternes.py
# 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")

Slicing Avancé des Listes

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.

Omission des paramètres (slices partiels)

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.

slices_partiels.py
# 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

Copier une liste avec le slicing

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.

copie_slicing.py
# 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}")

Slicing avec des variables dynamiques

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.

slicing_dynamique.py
# 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)}")

Modification de Listes par Slicing

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.

Remplacement d'éléments par slice

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.

remplacement_slice.py
# 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}")

Insertion d'éléments via slicing

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.

insertion_slicing.py
# 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}")

Suppression d'éléments par slice

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.

suppression_slice.py
# 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}")

Redimensionner une liste avec le slicing

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.

redimensionnement_slicing.py
# 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)}")

Cas Pratiques et Exercices

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.

Inverser une liste sans reverse()

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.

inversion_slicing.py
# 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}")

Extraire les premiers et derniers éléments

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.

extraction_premiers_derniers.py
# 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)}")

Diviser une liste en chunks

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.

division_chunks.py
# 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)}")

Filtrage par position avec slicing

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.

filtrage_position.py
# 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}")

Erreurs Courantes et Bonnes Pratiques

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.

Pièges à éviter avec le slicing de listes

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.

pieges_slicing.py
# 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")

Performance : slicing vs autres méthodes

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.

performance_slicing.py
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")

Quand utiliser le slicing plutôt que les méthodes de liste

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.

choix_slicing_vs_methodes.py
# 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")
Contact

📚 Cours à distance

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

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

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