Ce tutoriel vous permettra de comprendre parfaitement le fonctionnement de la fonction range() en Python, depuis sa syntaxe de base jusqu'à ses utilisations avancées. Vous apprendrez à générer des séquences numériques efficacement pour vos boucles et à optimiser vos programmes. À la fin de ce guide, vous maîtriserez tous les paramètres de range() et saurez l'utiliser dans différents contextes de programmation.
La fonction range() est une fonction intégrée à Python qui génère une séquence immuable de nombres, souvent utilisée pour les boucles et itérations.
La fonction range() retourne un objet de type range qui représente une séquence de nombres. Contrairement aux listes, les ranges n'occupent pas d'espace mémoire important car ils génèrent les nombres à la volée.
# Création d'un objet range ma_sequence = range(5) print(type(ma_sequence)) # <class 'range'> print(ma_sequence) # range(0, 5) # Conversion en liste pour visualisation liste_sequence = list(ma_sequence) print(liste_sequence) # [0, 1, 2, 3, 4] # Utilisation avec des villes marocaines villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] for i in range(len(villes_maroc)): print(f"Ville {i}: {villes_maroc[i]}")
La fonction range() est principalement utilisée pour :
for# Boucle for classique for i in range(3): print(f"Itération numéro {i}") # Génération d'une séquence de nombres pairs nombres_pairs = list(range(0, 10, 2)) print(nombres_pairs) # [0, 2, 4, 6, 8] # Application avec des données marocaines annees = list(range(2020, 2025)) evenements_maroc = ["Lancement du projet", "Construction", "Inauguration", "Expansion", "Consolidation"] for i in range(len(annees)): print(f"{annees[i]}: {evenements_maroc[i]}")
Range() offre plusieurs avantages par rapport à d'autres méthodes d'itération :
# Comparaison d'utilisation mémoire import sys # Mémoire utilisée par un range seq_range = range(1000) print(f"Mémoire utilisée par range(1000): {sys.getsizeof(seq_range)} octets") # Mémoire utilisée par une liste équivalente seq_list = list(range(1000)) print(f"Mémoire utilisée par list(range(1000)): {sys.getsizeof(seq_list)} octets") # Exemple pratique avec des données marocaines regions_maroc = ["Casablanca-Settat", "Rabat-Salé-Kénitra", "Fès-Meknès", "Marrakech-Safi", "Tanger-Tétouan-Al Hoceïma", "Oriental", "Drâa-Tafilalet", "Souss-Massa", "Guelmim-Oued Noun", "Laâyoune-Sakia El Hamra", "Dakhla-Oued Ed-Dahab"] # Méthode optimale avec range() for i in range(len(regions_maroc)): print(f"Région {i+1}: {regions_maroc[i]}") # Alternative moins efficace (crée une copie inutile) indices = [i for i in range(len(regions_maroc))] # Crée une liste inutilement for i in indices: print(f"Région {i+1}: {regions_maroc[i]}")
La fonction range() en Python accepte différentes formes de paramètres pour générer des séquences de nombres selon des besoins spécifiques.
La forme la plus simple de range() prend un seul paramètre stop qui définit la fin de la séquence (non incluse). La séquence commence à 0 par défaut.
# Générer une séquence de 0 à 4 sequence = range(5) print(list(sequence)) # [0, 1, 2, 3, 4] # Utilisation avec des données marocaines villes_principales = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger"] # Parcourir les 5 premières villes for i in range(5): print(f"Ville {i+1}: {villes_principales[i]}") # Générer les codes d'identification pour 3 régions codes_regions = [f"MA-{i:02d}" for i in range(3)] print(codes_regions) # ['MA-00', 'MA-01', 'MA-02']
La syntaxe complète permet de spécifier le début, la fin et le pas de la séquence :
start : valeur de départ (incluse)stop : valeur d'arrêt (non incluse)step : pas d'incrément (peut être négatif)# Différentes utilisations de range() avec trois paramètres # Séquence de 2 à 8 avec un pas de 2 sequence1 = list(range(2, 9, 2)) print(sequence1) # [2, 4, 6, 8] # Séquence décroissante de 10 à 0 sequence2 = list(range(10, -1, -1)) print(sequence2) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] # Application avec des données marocaines annees_development = list(range(2020, 2030, 2)) # Tous les 2 ans projets_maroc = ["Plan Vert", "Vision 2030", "Initiative Atlantique", "Développement Rural", "Transformation Numérique"] for i, annee in enumerate(annees_development): if i < len(projets_maroc): print(f"{annee}: Lancement du projet {projets_maroc[i]}") # Générer des températures pour différentes villes marocaines villes_temperatures = { "Marrakech": list(range(25, 36, 2)), # De 25 à 35°C par pas de 2 "Ifrane": list(range(-2, 6, 1)), # De -2 à 5°C "Agadir": list(range(20, 31, 5)) # De 20 à 30°C par pas de 5 } for ville, temperatures in villes_temperatures.items(): print(f"{ville}: {temperatures}")
La fonction range() n'accepte que des nombres entiers (int) comme paramètres. Les nombres à virgule flottante (float) ne sont pas autorisés.
# Paramètres entiers valides valide1 = range(5) valide2 = range(1, 10) valide3 = range(0, 10, 2) # Ces instructions généreront des erreurs TypeError # range(2.5) # Erreur: le paramètre doit être un entier # range(1, 5.5) # Erreur # range(0, 10, 0.5) # Erreur # Solution: convertir les floats en entiers si nécessaire population_casablanca = 3.36 # en millions arrondi = int(population_casablanca) quartiers = list(range(arrondi)) # [0, 1, 2] # Application avec des données marocaines altitudes = [416, 1350, 1665, 468, 710] # Altitudes de villes marocaines en mètres altitude_min = min(altitudes) altitude_max = max(altitudes) # Générer des plages d'altitude pour classification plages_altitude = list(range(0, 2001, 500)) # [0, 500, 1000, 1500, 2000] # Classer les villes par altitude villes_altitude = ["Casablanca", "Ifrane", "Marrakech", "Tanger", "Fès"] for i in range(len(villes_altitude)): altitude = altitudes[i] # Trouver la plage correspondante plage = None for j in range(len(plages_altitude) - 1): if plages_altitude[j] <= altitude < plages_altitude[j+1]: plage = f"{plages_altitude[j]}-{plages_altitude[j+1]}m" break if plage is None: plage = f">{plages_altitude[-1]}m" print(f"{villes_altitude[i]}: {altitude}m (Plage: {plage})")
La fonction range() avec un seul paramètre est la forme la plus simple et la plus courante d'utilisation. Elle génère une séquence de nombres commençant à 0 et s'arrêtant avant la valeur spécifiée.
Lorsqu'on utilise range() avec un seul paramètre n, la fonction génère une séquence de nombres de 0 à n-1. C'est particulièrement utile pour les boucles qui doivent s'exécuter un nombre précis de fois.
# Génération d'une séquence simple sequence = range(5) print("Séquence range(5):", list(sequence)) # [0, 1, 2, 3, 4] # Utilisation dans une boucle for simple for i in range(3): print(f"Exécution numéro {i+1}") # Application avec des données marocaines regions_maroc = ["Casablanca-Settat", "Rabat-Salé-Kénitra", "Fès-Meknès"] for i in range(len(regions_maroc)): print(f"Région {i+1}: {regions_maroc[i]}") # Génération d'identifiants uniques nombre_villes = 4 ids_villes = [f"MA_{id:03d}" for id in range(nombre_villes)] print("IDs des villes:", ids_villes) # ['MA_000', 'MA_001', 'MA_002', 'MA_003']
Voici plusieurs exemples concrets montrant comment utiliser range(n) dans des situations réelles avec des données marocaines.
# Exemple 1: Simulation de températures pour différentes villes marocaines villes_maroc = ["Marrakech", "Casablanca", "Fès", "Tanger"] jours_semaine = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi"] print("Prévisions météo pour la semaine:") for i in range(len(villes_maroc)): print(f"\n{villes_maroc[i]}:") for j in range(len(jours_semaine)): temperature = 20 + i + j # Simulation de températures print(f" {jours_semaine[j]}: {temperature}°C") # Exemple 2: Calcul de statistiques pour des provinces marocaines provinces = ["Settat", "El Jadida", "Safi", "Béni Mellal"] populations = [634000, 786000, 691000, 550000] print("\nStatistiques démographiques:") for i in range(len(provinces)): densite = populations[i] / 1000 # Simplification pour l'exemple print(f"{provinces[i]}: {populations[i]} habitants (densité: {densite:.1f}/km²)") # Exemple 3: Création d'un menu de plats marocains plats_marocains = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui"] print("\nMenu de spécialités marocaines:") for i in range(len(plats_marocains)): prix = 30 + i * 5 # Prix simulés print(f"{i+1}. {plats_marocains[i]} - {prix} DH")
Bien que range() soit souvent utilisé directement dans les boucles, il peut être utile de le convertir en liste pour visualisation ou manipulation. Cette conversion se fait à l'aide du constructeur list().
# Conversion basique de range() en liste sequence_range = range(7) liste_nombres = list(sequence_range) print("Range converti en liste:", liste_nombres) # [0, 1, 2, 3, 4, 5, 6] # Application avec des données marocaines: création d'annuaires nombre_entreprises = 5 secteurs = ["Agroalimentaire", "Textile", "Tourisme", "Artisanat", "Technologie"] # Création d'un annuaire d'entreprises marocaines annuaire = {} for i in range(nombre_entreprises): nom_entreprise = f"Entreprise_{secteurs[i]}_{i+1}" annuaire[nom_entreprise] = { "secteur": secteurs[i], "contact": f"contact{i+1}@entreprise.ma", "ville": ["Casablanca", "Rabat", "Marrakech", "Tanger", "Fès"][i] } print("\nAnnuaire des entreprises marocaines:") for entreprise, details in annuaire.items(): print(f"{entreprise}: {details}") # Création d'une liste d'années pour un projet de développement debut_projet = 2023 duree_projet = 5 annees_projet = list(range(debut_projet, debut_projet + duree_projet)) projet_maroc = "Développement des énergies renouvelables" etapes = ["Planification", "Construction", "Mise en service", "Optimisation", "Expansion"] print(f"\nCalendrier du projet '{projet_maroc}':") for i in range(len(annees_projet)): print(f"{annees_projet[i]}: {etapes[i]}") # Conversion pour manipulation des données indices_modifiables = list(range(10)) indices_modifiables[0] = 100 # Modification possible car c'est une liste print("\nListe modifiée:", indices_modifiables) # Attention: range() original est immuable range_original = range(10) print("Range original:", list(range_original)) # Non modifié
La fonction range() avec deux paramètres permet de définir un intervalle personnalisé en spécifiant à la fois le début et la fin de la séquence. Cette forme offre une flexibilité accrue pour générer des séquences numériques précises.
La syntaxe range(start, stop) génère une séquence de nombres commençant à start (inclus) et se terminant à stop-1. C'est particulièrement utile lorsque vous ne voulez pas commencer à 0.
# Génération d'une séquence avec début personnalisé sequence = range(3, 8) print("range(3, 8):", list(sequence)) # [3, 4, 5, 6, 7] # Application avec des données marocaines: années de règne debut_regne = 1999 fin_regne = 2024 annees_regne = list(range(debut_regne, fin_regne)) print(f"\nAnnées de règne de SM Mohammed VI ({debut_regne}-{fin_regne-1}):") for i, annee in enumerate(annees_regne): if i % 5 == 0 and i != 0: print() # Nouvelle ligne tous les 5 ans print(annee, end=" ") # Utilisation pour indexer une liste partielle villes_maroc = ["Tanger", "Tétouan", "Fès", "Meknès", "Rabat", "Casablanca", "Marrakech", "Agadir"] print("\n\nVilles du nord au centre du Maroc:") for i in range(0, 6): # De l'index 0 à 5 print(f"{i+1}. {villes_maroc[i]}") # Création de codes postaux pour une région debut_code = 10000 fin_code = 10010 codes_postaux = list(range(debut_code, fin_code)) print(f"\nCodes postaux de la région de Casablanca: {codes_postaux}")
Voici plusieurs exemples pratiques utilisant range(start, stop) avec des valeurs positives, appliqués à des contextes marocains.
# Exemple 1: Planification de projets de développement debut_plan = 2024 fin_plan = 2030 annees_plan = list(range(debut_plan, fin_plan)) projets = ["Extension TGV", "Energie solaire", "Désalinisation", "IA et innovation", "Tourisme durable", "Agriculture smart"] print("Plan Vision 2030 - Projets par année:") for i in range(len(annees_plan)): if i < len(projets): print(f"{annees_plan[i]}: {projets[i]}") # Exemple 2: Températures mensuelles à Marrakech mois = ["Jan", "Fév", "Mar", "Avr", "Mai", "Juin", "Juil", "Août", "Sep", "Oct", "Nov", "Déc"] temperatures_marrakech = [12, 14, 17, 19, 23, 27, 31, 31, 27, 22, 17, 13] print("\nSaison estivale à Marrakech (Juin à Septembre):") for i in range(5, 9): # Index 5 à 8 (Juin à
Le troisième paramètre de la fonction range(), appelé step, permet de contrôler l'incrément entre les valeurs successives de la séquence. Ce paramètre offre une flexibilité supplémentaire pour générer des séquences avec des pas personnalisés.
Un step positif génère une séquence croissante. La valeur du step détermine l'écart entre chaque nombre de la séquence.
# Différents pas positifs sequence1 = list(range(0, 10, 2)) # [0, 2, 4, 6, 8] sequence2 = list(range(1, 20, 3)) # [1, 4, 7, 10, 13, 16, 19] sequence3 = list(range(5, 26, 5)) # [5, 10, 15, 20, 25] print("Pas de 2:", sequence1) print("Pas de 3:", sequence2) print("Pas de 5:", sequence3) # Application: années de recensement au Maroc premier_recensement = 1960 dernier_recensement = 2024 annees_recensement = list(range(premier_recensement, dernier_recensement, 10)) print(f"\nAnnées de recensement au Maroc ({premier_recensement}-{dernier_recensement-1}):") for annee in annees_recensement: print(annee, end=" ") # Application: fréquences des trains Al Boraq (TGV marocain) premier_depart = 6 # 6h00 dernier_depart = 22 # 22h00 departs_tgv = list(range(premier_depart, dernier_depart, 2)) # Départs toutes les 2 heures print("\n\nDéparts du TGV Al Boraq Casablanca-Tanger:") for heure in departs_tgv: print(f"{heure}h00") # Application: altitudes des stations de ski de l'Atlas altitude_min = 1800 altitude_max = 2600 altitudes_stations = list(range(altitude_min, altitude_max, 200)) stations = ["Oukaïmeden", "Michlifen", "Jbel Habri", "Bou Iblane"] print("\nAltitudes des stations de ski marocaines:") for i, altitude in enumerate(altitudes_stations): if i < len(stations): print(f"{stations[i]}: {altitude}m")
Un step négatif génère une séquence décroissante. Dans ce cas, la valeur de start doit être supérieure à stop pour obtenir une séquence non vide.
# Différents pas négatifs sequence1 = list(range(10, 0, -1)) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] sequence2 = list(range(20, 0, -3)) # [20, 17, 14, 11, 8, 5, 2] sequence3 = list(range(100, 40, -10)) # [100, 90, 80, 70, 60, 50] print("Décompte de 10 à 1:", sequence1) print("Décompte de 20 à 0 par pas de 3:", sequence2) print("Décompte de 100 à 40 par pas de 10:", sequence3) # Application: compte à rebours pour le Nouvel An print("\nCompte à rebours du Nouvel An à Casablanca:") for i in range(10, 0, -1): print(f"{i}...") print("Bonne année 2025! ?") # Application: décompte des jours avant Aid Al Adha jours_restants = 30 print(f"\nDécompte des jours avant Aid Al Adha:") for jour in range(jours_restants, 0, -1): if jour == 1: print(f"Plus que {jour} jour! Aid Mubarak!") else: print(f"Plus que {jour} jours") # Application: températures nocturnes à Ifrane en hiver print("\nBaisse des températures nocturnes à Ifrane:") for temperature in range(5, -6, -1): if temperature > 0: print(f"{temperature}°C") elif temperature == 0: print("0°C - Point de congélation") else: print(f"{temperature}°C - Température négative!")
Le paramètre step peut prendre différentes valeurs, mais il existe des cas particuliers à connaître, notamment lorsque step = 0 qui génère une erreur.
# Pas personnalisés variés grand_pas = list(range(0, 100, 25)) # [0, 25, 50, 75] petit_pas = list(range(1, 5, 1)) # [1, 2, 3, 4] (step=1 par défaut) pas_negatif = list(range(10, 0, -2)) # [10, 8, 6, 4, 2] print("Pas de 25:", grand_pas) print("Pas de 1:", petit_pas) print("Pas de -2:", pas_negatif) # Cas particulier: step = 0 (génère une erreur) try: erreur = list(range(1, 10, 0)) except ValueError
La fonction range() est particulièrement utile lorsqu'elle est combinée avec des boucles for pour itérer un nombre spécifique de fois ou parcourir des séquences de manière contrôlée.
La forme la plus courante d'utilisation de range() dans les boucles for permet d'exécuter un bloc de code un nombre déterminé de fois :
# Exécuter une action 5 fois for i in range(5): print("Maroc") # Résultat: # Maroc # Maroc # Maroc # Maroc # Maroc # Afficher les valeurs générées par range() for nombre in range(3): print(f"Valeur: {nombre}") # Résultat: # Valeur: 0 # Valeur: 1 # Valeur: 2 # Calculer la somme des 10 premiers nombres somme = 0 for i in range(1, 11): somme += i print(f"La somme des nombres de 1 à 10 est: {somme}") # Résultat: La somme des nombres de 1 à 10 est: 55
La combinaison de range() et len() permet de parcourir une liste en accédant à ses éléments par leur index :
# Liste de villes marocaines villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] # Parcourir avec range() et len() for i in range(len(villes_maroc)): print(f"Index {i}: {villes_maroc[i]}") # Résultat: # Index 0: Casablanca # Index 1: Rabat # Index 2: Marrakech # Index 3: Fès # Index 4: Tanger # Modifier des éléments pendant le parcours plats_marocains = ["tajine", "couscous", "pastilla", "harira"] for i in range(len(plats_marocains)): plats_marocains[i] = plats_marocains[i].upper() print(plats_marocains) # Résultat: ['TAJINE', 'COUSCOUS', 'PASTILLA', 'HARIRA'] # Parcourir à l'envers avec un step négatif for i in range(len(villes_maroc)-1, -1, -1): print(villes_maroc[i]) # Résultat: # Tanger # Fès # Marrakech # Rabat # Casablanca
Les boucles imbriquées avec range() sont utiles pour travailler avec des structures multidimensionnelles comme les matrices :
# Création d'une matrice 3x3 for i in range(3): for j in range(3): print(f"({i}, {j})", end=" ") print() # Nouvelle ligne après chaque ligne de la matrice # Résultat: # (0, 0) (0, 1) (0, 2) # (1, 0) (1, 1) (1, 2) # (2, 0) (2, 1) (2, 2) # Table de multiplication (exemple avec les tables marocaines) print("Table de multiplication par 7:") for i in range(1, 11): print(f"7 × {i} = {7 * i}") # Table de multiplication complète print("\nTables de multiplication de 1 à 5:") for table in range(1, 6): print(f"\nTable de {table}:") for multiplicateur in range(1, 11): print(f"{table} × {multiplicateur} = {table * multiplicateur}") # Création d'un motif avec des boucles imbriquées print("\nMotif triangulaire:") for i in range(1, 6): for j in range(i): print("*", end="") print() # Résultat: # * # ** # *** # **** # *****
La fonction range() trouve de nombreuses applications pratiques en programmation Python, allant de la génération de séquences à des calculs mathématiques complexes.
La fonction range() est idéale pour créer des séquences numériques variées selon des motifs spécifiques :
# Générer une séquence d'années (ex: années de règne d'un roi du Maroc) annees_regne = list(range(1999, 2024)) print("Années de règne:", annees_regne) # Résultat: [1999, 2000, 2001, ..., 2023] # Générer des numéros de téléphone marocains (exemple fictif) prefixes = ["06", "07"] numeros_test = [f"{prefix}{str(i).zfill(8)}" for prefix in prefixes for i in range(100, 105)] print("Numéros de test:", numeros_test) # Résultat: ['0600000100', '0600000101', ..., '0700000104'] # Créer des identifiants uniques pour des villes marocaines villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] ids_villes = {ville: id_num for id_num, ville in zip(range(1000, 1000 + len(villes_maroc)), villes_maroc)} print("IDs des villes:", ids_villes) # Résultat: {'Casablanca': 1000, 'Rabat': 1001, 'Marrakech': 1002, 'Fès': 1003, 'Tanger': 1004} # Générer des dates pour un calendrier d'événements culturels marocains jours_festival = list(range(1, 16)) # 15 jours de festival print("Jours du Festival des Arts de Marrakech:", jours_festival) # Résultat: [1, 2, 3, ..., 15]
Range() est particulièrement utile pour créer et manipuler des index de listes :
# Indexer des monuments historiques marocains monuments = ["Hassan II Casablanca", "Koutoubia Marrakech", "Chellah Rabat", "Médina Fès", "Kasbah des Oudaias", "Volubilis"] # Créer un catalogue indexé des monuments catalogue = {} for i in range(len(monuments)): catalogue[i+100] = monuments[i] # Codes à partir de 100 print("Catalogue des monuments:") for code, monument in catalogue.items(): print(f"{code}: {monument}") # Sélectionner un échantillon de monuments (premiers et derniers) premiers_indices = list(range(0, 3)) # Premiers 3 derniers_indices = list(range(len(monuments)-2, len(monuments))) # Derniers 2 selection = [monuments[i] for i in premiers_indices + derniers_indices] print("Monuments sélectionnés:", selection) # Créer un menu de plats marocains avec numérotation plats_marocains = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui"] print("Menu des plats marocains:") for i in range(len(plats_marocains)): print(f"{i+1}. {plats_marocains[i]}") # Résultat: # 1. Tajine # 2. Couscous # 3. Pastilla # 4. Harira # 5. Méchoui
Range() est très utile pour les calculs mathématiques, les statistiques et les simulations :
# Calculer la moyenne des températures à Marrakech sur 7 jours temperatures = [28, 30, 32, 29, 31, 27, 26] somme_temp = 0 for i in range(len(temperatures)): somme_temp += temperatures[i] moyenne = somme_temp / len(temperatures) print(f"Température moyenne à Marrakech: {moyenne:.1f}°C") # Résultat: Température moyenne à Marrakech: 29.0°C # Calculer la croissance démographique d'une ville marocaine population_2010 = 500000 taux_croissance = 0.02 # 2% par an projections = [] for annee in range(10): # Projection sur 10 ans population_2010 *= (1 + taux_croissance) projections.append((2020 + annee, round(population_2010))) print("Projection de population:") for annee, pop in projections: print(f"{annee}: {pop} habitants") # Générer une table de multiplication marocaine (base 12 comme le système monétaire historique) print("Table de multiplication par 12 (système doucimal):") for i in range(1, 13): print(f"12 × {i} = {12 * i}") # Calculer les distances entre villes marocaines (exemple simplifié) villes = ["Casablanca", "Rabat", "Marrakech", "Fès"] distances = [ [0, 86, 239, 299], # De Casablanca [86, 0, 327, 206], # De Rabat [239, 327, 0, 478], # De Marrakech [299, 206, 478, 0] # De Fès ] print("Distances entre villes marocaines (en km):") for i in range(len(villes)): for j in range(len(villes)): if i != j: print(f"{villes[i]} - {villes[j]}: {distances[i][j]} km") # Calculer la factorielle d'un nombre (mathématiques) n = 5 factorielle = 1 for i in range(1, n+1): factorielle *= i print(f"{n}! = {factorielle}") # Résultat: 5! = 120
Comprendre quand et comment utiliser efficacement la fonction range() est essentiel pour écrire du code Python propre, performant et maintenable.
Le choix entre range() et enumerate() dépend du contexte et des besoins spécifiques du code :
# Liste de spécialités culinaires marocaines specialites = ["Tajine", "Couscous", "Pastilla", "Harira", "Méchoui"] # Utilisation appropriée de range() - quand on a besoin de l'index seulement print("Classement des spécialités:") for i in range(len(specialites)): print(f"{i + 1}. {specialites[i]}") # Utilisation appropriée d'enumerate() - quand on a besoin de l'index et de la valeur print("\nDétails des spécialités:") for index, specialite in enumerate(specialites, start=1): print(f"{index}. {specialite} (longueur: {len(specialite)} caractères)") # Cas où range() est préférable - modification d'éléments par index villes_maroc = ["casablanca", "rabat", "marrakech"] for i in range(len(villes_maroc)): villes_maroc[i] = villes_maroc[i].capitalize() print("\nVilles capitalisées:", villes_maroc) # Cas où enumerate() est préférable - accès en lecture seule aux éléments notes = [15, 18, 12, 16] matieres = ["Maths", "Physique", "Histoire", "Géographie"] print("\nBulletin de notes:") for i, (matiere, note) in enumerate(zip(matieres, notes), 1): print(f"{i}. {matiere}: {note}/20")
La fonction range() est optimisée pour la performance et une faible consommation mémoire :
# Comparaison de consommation mémoire import sys # range() - génération paresseuse, faible consommation mémoire grand_range = range(1000000) print(f"Taille mémoire d'un range(1,000,000): {sys.getsizeof(grand_range)} octets") # Liste équivalente - consommation mémoire importante grande_liste = list(range(1000000)) print(f"Taille mémoire d'une liste de 1,000,000 éléments: {sys.getsizeof(grande_liste)} octets") # Performance dans les boucles - range() est optimisé import time # Test de performance avec range() start_time = time.time() somme = 0 for i in range(1000000): somme += i range_time = time.time() - start_time # Test de performance avec liste start_time = time.time() somme = 0 liste_nombres = list(range(1000000)) for nombre in liste_nombres: somme += nombre liste_time = time.time() - start_time print(f"\nTemps avec range(): {range_time:.4f} secondes") print(f"Temps avec liste: {liste_time:.4f} secondes") print(f"Ratio de performance: {liste_time/range_time:.1f}x") # Utilisation mémoire avec de grands intervalles immense_range = range(10**12) # 1 trillion d'éléments print(f"\nTaille mémoire d'un range(1,000,000,000,000): {sys.getsizeof(immense_range)} octets") print(f"Premier élément: {immense_range[0]}") print(f"Dernier élément: {immense_range[-1]}")
Plusieurs pièges courants peuvent être évités avec une bonne compréhension de range() :
# ERREUR: Oubli que range() commence à 0 par défaut villes = ["Casablanca", "Rabat", "Marrakech"] print("Accès incorrect avec range():") try: for i in range(1, len(villes) + 1): # Erreur: index 3 n'existe pas print(villes[i]) except IndexError as e: print(f"Erreur: {e}") # SOLUTION: Utiliser correctement les indices print("\nAccès correct avec range():") for i in range(len(villes)): print(villes[i]) # ERREUR: Confusion entre range() et slice nombres = [1, 2, 3, 4, 5] print(f"\nOriginal: {nombres}") print("Slice [1:4]:", nombres[1:4]) # [2, 3, 4] print("range(1, 4):", list(range(1, 4))) # [1, 2, 3] - différent! # ERREUR: Step de zéro print("\nTentative avec step=0:") try: list(range(1, 10, 0)) # ValueError: step must not be zero except ValueError as e: print(f"Erreur: {e}") # ERREUR: Mauvais sens pour le step print("\nRange avec step inapproprié:") try: list(range(10, 1, 1)) # Step positif mais start > stop except Exception as e: print(f"Résultat vide: {list(range(10, 1, 1))}") # SOLUTION: Utiliser un step négatif pour décroître print("Range avec step négatif:", list(range(10, 1, -1))) # [10, 9, 8, 7, 6, 5, 4, 3, 2] # ERREUR: Modification de liste pendant l'itération avec range() produits = ["Tajine", "Couscous", "Harira", "Pastilla"] print(f"\nListe originale: {produits}") for i in range(len(produits)): if "a" in produits[i]: produits.pop(i) # ERREUR: Modifie la liste pendant l'itération print("Cette ligne ne sera pas atteinte à cause de l'erreur")
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!