Maîtriser la fonction Python range() : des bases aux cas avancés

Maîtriser la fonction Python range() : des bases aux cas avancés

Qu'est-ce que Python range ?

La fonction range() de Python est un générateur intégré qui produit une séquence d'entiers basée sur un début, une fin et un pas optionnel. Si la valeur de début est omise, elle vaut 0 par défaut, et la séquence s'incrémente de 1 jusqu'à atteindre la valeur de fin (exclusive). Par exemple, range(5) produit 0, 1, 2, 3, 4. Cette fonction est indispensable pour itérer avec des boucles for.

Dans ce tutoriel, vous apprendrez :

• Définition et syntaxe de range()
• Historique : range() vs xrange()
• Comment utiliser range() avec start, stop et step
• Incrémenter et décrémenter des plages
• Gérer les limites à virgule flottante et alternatives
• Utiliser range() avec listes, tableaux et arange() de NumPy
• Motifs avancés : fusionner des plages, extraire nombres pairs, générer des séquences d'alphabet

Syntaxe

range(start, stop, step)

Paramètres

• start (optionnel) : Le premier entier de la séquence. Vaut 0 par défaut si omis.
• stop (requis) : La borne supérieure (exclusive). La séquence s'arrête avant cette valeur.
• step (optionnel) : L'intervalle entre valeurs consécutives. Vaut 1 par défaut.

Valeur de retour

Renvoie un objet range, qui se comporte comme une séquence immuable d'entiers. Converti en liste, il affiche la séquence complète.

Python range() : fonction et histoire

Introduite en Python 3, range() a remplacé l'ancien xrange() de Python 2. Les différences clés sont résumées ci-dessous :

range()	xrange()
Renvoie une séquence immuable de nombres.	Renvoie un objet générateur.
Consomme de la mémoire proportionnelle à la longueur.	Utilise peu de mémoire ; génère les valeurs paresseusement.
Adapté aux plages petites à moyennes.	Préféré pour les grandes plages ou séquences infinies.
Plus lent sur très grandes plages (allocation mémoire).	Plus rapide pour itérer sur de grandes plages.

Utiliser range()

Exemple de base affichant les nombres de 0 à 9 :

for i in range(10):
    print(i, end=" ")

Sortie :

0 1 2 3 4 5 6 7 8 9

Utiliser start et stop dans range()

Spécifier une valeur de début décale la séquence :

for i in range(3, 10):
    print(i, end=" ")

Sortie :

3 4 5 6 7 8 9

Utiliser start, stop et step

En ajoutant un pas, vous contrôlez l'intervalle entre les nombres :

for i in range(3, 10, 2):
    print(i, end=" ")

Sortie :

3 5 7 9

Incrémenter les valeurs avec un pas positif

Le pas par défaut est 1, mais vous pouvez spécifier tout entier positif :

for i in range(1, 30, 5):
    print(i, end=" ")

Sortie :

1 6 11 16 21 26

Range inversé : décrémenter avec un pas négatif

Fournir un pas négatif crée une séquence descendante :

for i in range(15, 5, -1):
    print(i, end=" ")

Sortie :

15 14 13 12 11 10 9 8 7 6

Utiliser des nombres flottants dans Python range()

Le range() intégré n'accepte que des entiers. Tenter de passer un flottant lève une TypeError :

for i in range(10.5):
    print(i, end=" ")

Sortie :

Traceback (most recent call last):
  File "python_range.py", line 1, in 
    for i in range(10.5):
TypeError: 'float' object cannot be interpreted as an integer

Utiliser une boucle for avec Python range()

Range est souvent associé à len() pour itérer sur les indices d'une liste :

arr_list = ['MySQL', 'MongoDB', 'PostgreSQL', 'Firebase']
for i in range(len(arr_list)):
    print(arr_list[i], end=" ")

Sortie :

MySQL MongoDB PostgreSQL Firebase

Utiliser Python range() comme liste

Convertir un range en liste est simple :

print(list(range(10)))

Sortie :

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Utiliser des caractères dans Python range()

Bien que range() ne fonctionne qu'avec des entiers, vous pouvez générer des séquences d'alphabet en convertissant les caractères en leurs points de code Unicode :

def obtenir_alphabets(lettre_debut, lettre_fin, pas):
    for c in range(ord(lettre_debut.lower()), ord(lettre_fin.lower()), pas):
        yield chr(c)

print(list(obtenir_alphabets("a", "h", 1)))

Sortie :

['a', 'b', 'c', 'd', 'e', 'f', 'g']

Comment accéder aux éléments d'un range

Vous pouvez récupérer les valeurs via itération, indexation ou conversion en liste :

Itération

for i in range(6):
    print(i)

Sortie :

0 1 2 3 4 5

Indexation

premiere_valeur = range(5)[0]
print("Le premier élément du range est = ", premiere_valeur)
seconde_valeur = range(5)[1]
print("Le second élément du range est = ", seconde_valeur)
derniere_valeur = range(5)[-1]
print("Le dernier élément du range est = ", derniere_valeur)

Sortie :

Le premier élément du range est = 0
Le second élément du range est = 1
Le dernier élément du range est = 4

Utiliser list()

print(list(range(10)))

Sortie :

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Exemple : Obtenir les nombres pairs avec range()

Pour générer les nombres pairs jusqu'à 18 :

for i in range(2, 20, 2):
    print(i, end=" ")

Sortie :

2 4 6 8 10 12 14 16 18

Fusionner deux sorties range()

Combiner deux objets range peut se faire avec itertools.chain :

from itertools import chain
print("Fusion de deux range en un")
frange = chain(range(10), range(10, 20, 1))
for i in frange:
    print(i, end=" ")

Sortie :

Fusion de deux range en un
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Utiliser range() avec NumPy

NumPy's arange() miroir range() mais supporte les pas à virgule flottante :

Syntaxe

arange(start, stop, step)

Exemple

import numpy as np
for i in np.arange(10):
    print(i, end=" ")

Sortie :

0 1 2 3 4 5 6 7 8 9

Range à virgule flottante avec NumPy

for i in np.arange(0.5, 1.5, 0.2):
    print(i, end=" ")

Sortie :

0.5 0.7 0.8999999999999999 1.0999999999999999 1.2999999999999998

Comme l'arithmétique à virgule flottante est binaire, la sortie montre parfois de longues expansions décimales. Vous pouvez arrondir les valeurs selon vos besoins.

Résumé

• range() génère une séquence d'entiers définie par start, stop et step.
• Introduite en Python 3 ; xrange() était son prédécesseur en Python 2.
• Utilisez un pas positif pour les séquences ascendantes, négatif pour les descendantes.
• Les nombres flottants ne sont pas supportés ; utilisez NumPy arange() pour les flottants.
• Accédez aux éléments via itération, indexation ou conversion list().
• Combinez les ranges avec itertools.chain ou générez des séquences personnalisées comme l'alphabet.
• Pour de grandes plages numériques, considérez le comportement générateur pour l'efficacité mémoire.