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

La fonction range() en Python
Tout ce que vous devez savoir

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.

Introduction à la fonction range()

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.

Qu'est-ce que la fonction range() ?

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.

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

À quoi sert range() en programmation Python ?

La fonction range() est principalement utilisée pour :

  • Contrôler le nombre d'itérations dans les boucles for
  • Générer des séquences numériques sans stocker tous les éléments en mémoire
  • Créer des index pour accéder aux éléments d'autres séquences
  • Générer des suites arithmétiques avec un pas personnalisé
utilisation_range.py
# 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]}")

Pourquoi utiliser range() plutôt que d'autres méthodes ?

Range() offre plusieurs avantages par rapport à d'autres méthodes d'itération :

  • Efficacité mémoire : Ne stocke pas tous les éléments en mémoire
  • Performance : Plus rapide que la création de listes pour les grandes séquences
  • Flexibilité : Permet de définir des débuts, fins et pas personnalisés
  • Compatibilité : Fonctionne parfaitement avec les boucles for et autres structures de contrôle
comparaison_range.py
# 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]}")

Syntaxe et paramètres de range()

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.

Syntaxe de base : range(stop)

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.

syntaxe_range_stop.py
# 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']

Syntaxe complète : range(start, stop, step)

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

Types de données acceptés par range()

La fonction range() n'accepte que des nombres entiers (int) comme paramètres. Les nombres à virgule flottante (float) ne sont pas autorisés.

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

Utilisation simple de range()

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.

range() avec un seul paramètre

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.

range_un_parametre.py
# 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']

Exemples pratiques avec range(n)

Voici plusieurs exemples concrets montrant comment utiliser range(n) dans des situations réelles avec des données marocaines.

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

Conversion de range() en liste

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_range_liste.py
# 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é

Utilisation avancée avec deux paramètres

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.

range(start, stop) : définir un intervalle

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.

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

Exemples avec valeurs positives

Voici plusieurs exemples pratiques utilisant range(start, stop) avec des valeurs positives, appliqués à des contextes marocains.

exemples_valeurs_positives.py
# 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 paramètre step : contrôler l'incrément

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.

Utilisation de step positif

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.

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

Utilisation de step négatif (décompte)

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.

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

Pas personnalisés et cas particuliers

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

range() dans les boucles for

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.

Boucle for classique avec range()

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 :

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

Parcourir une liste avec range() et len()

La combinaison de range() et len() permet de parcourir une liste en accédant à ses éléments par leur index :

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

Boucles imbriquées avec range()

Les boucles imbriquées avec range() sont utiles pour travailler avec des structures multidimensionnelles comme les matrices :

boucles_imbriquees_range.py
# 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:
# *
# **
# ***
# ****
# *****

Cas d'usage pratiques

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.

Générer des séquences numériques

La fonction range() est idéale pour créer des séquences numériques variées selon des motifs spécifiques :

generer_sequences.py
# 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]

Créer des index pour les listes

Range() est particulièrement utile pour créer et manipuler des index de listes :

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

Applications en mathématiques et calculs

Range() est très utile pour les calculs mathématiques, les statistiques et les simulations :

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

Bonnes pratiques et optimisation

Comprendre quand et comment utiliser efficacement la fonction range() est essentiel pour écrire du code Python propre, performant et maintenable.

Quand utiliser range() vs enumerate()

Le choix entre range() et enumerate() dépend du contexte et des besoins spécifiques du code :

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

Performance et consommation mémoire

La fonction range() est optimisée pour la performance et une faible consommation mémoire :

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

Erreurs courantes à éviter

Plusieurs pièges courants peuvent être évités avec une bonne compréhension de range() :

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