En programmation Python, comprendre comment utiliser range avec des pas non entiers peut considérablement améliorer votre capacité à générer des séquences numériques flexibles. Ce tutoriel explore des techniques avancées pour travailler avec les fonctions range au-delà des incréments entiers traditionnels, offrant aux développeurs des outils puissants pour créer des progressions numériques personnalisées.
rangerange() de PythonLa fonction range() est un outil fondamental en Python pour générer des séquences de nombres. Par défaut, elle crée des séquences d'entiers avec des pas entiers, ce qui la rend incroyablement utile pour les boucles, les compréhensions de liste et d'autres tâches itératives.
La fonction standard range() prend en charge trois formes principales :
## Créer une plage de 0 à n-1
range(stop)
## Créer une plage de start à stop-1
range(start, stop)
## Créer une plage avec un pas spécifique
range(start, stop, step)Explorons quelques utilisations de base de range :
## Générer des nombres de 0 à 4
basic_range = list(range(5))
print(basic_range) ## Sortie : [0, 1, 2, 3, 4]
## Générer des nombres de 2 à 7
custom_start_range = list(range(2, 8))
print(custom_start_range) ## Sortie : [2, 3, 4, 5, 6, 7]
## Générer des nombres pairs
even_numbers = list(range(0, 10, 2))
print(even_numbers) ## Sortie : [0, 2, 4, 6, 8]| Caractéristique | Description |
|---|---|
| Début par défaut | 0 (lorsqu'il n'est pas spécifié) |
| Fin exclusive | La valeur de stop n'est pas incluse |
| Direction du pas | Pas positifs ou négatifs pris en charge |
La fonction range() est efficace en termes de mémoire, car elle génère les valeurs à la volée plutôt que de stocker des séquences entières en mémoire. Cela la rend idéale pour les grandes séquences et les environnements à mémoire limitée.
Lorsque vous apprenez Python, il est essentiel de pratiquer avec range(). LabEx propose des environnements interactifs pour expérimenter ces concepts de manière pratique.
range() standardLa fonction intégrée range() de Python ne prend en charge que des pas entiers, ce qui limite son utilisation pour les séquences à virgule flottante. Cette contrainte nécessite des approches alternatives pour générer des séquences à base de décimales.
arange() de NumPyNumPy propose une alternative puissante pour créer des séquences à virgule flottante :
import numpy as np
## Générer une séquence à virgule flottante
decimal_range = np.arange(0, 1.1, 0.2)
print(decimal_range) ## Sortie : [0. 0.2 0.4 0.6 0.8 1. ]def float_range(start, stop, step):
"""
Générer des séquences à virgule flottante avec un contrôle précis
"""
current = start
while current < stop:
yield current
current += step
## Exemple d'utilisation
precise_range = list(float_range(0, 1.1, 0.3))
print(precise_range) ## Sortie : [0, 0.3, 0.6, 0.9]| Méthode | Avantages | Inconvénients |
|---|---|---|
arange() de NumPy |
Haute performance | Nécessite la bibliothèque NumPy |
| Fonction personnalisée | Pure Python | Moins efficace |
| Module Decimal | Calculs précis | Implémentation plus complexe |
from decimal import Decimal
def precise_float_range(start, stop, step):
start, stop, step = map(Decimal, (start, stop, step))
while start < stop:
yield float(start)
start += step
## Séquence décimale précise
precise_sequence = list(precise_float_range(0, 1.1, '0.3'))
print(precise_sequence)Lorsque vous travaillez avec des séquences à virgule flottante, les environnements LabEx offrent des plateformes interactives pour expérimenter et comprendre ces techniques nuancées.
import numpy as np
import matplotlib.pyplot as plt
def generate_sine_wave(frequency, duration, sample_rate=100):
time = np.arange(0, duration, 1/sample_rate)
signal = np.sin(2 * np.pi * frequency * time)
return time, signal
## Générer des signaux à plusieurs fréquences
frequencies = [1, 5, 10]
plt.figure(figsize=(10, 6))
for freq in frequencies:
time, signal = generate_sine_wave(freq, duration=2)
plt.plot(time, signal, label=f'{freq} Hz')
plt.title('Sine Wave Frequencies')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.legend()
plt.show()def investment_projection(initial_amount, interest_rate, years):
return [
initial_amount * (1 + interest_rate) ** year
for year in np.arange(0, years + 0.5, 0.5)
]
## Calculer la croissance de l'investissement
initial_investment = 1000
rates = [0.05, 0.08, 0.12]
for rate in rates:
projection = investment_projection(initial_investment, rate, 10)
print(f"Growth at {rate*100}% interest: {projection}")import numpy as np
from scipy import interpolate
def create_custom_sampling():
## Créer des points d'échantillonnage non uniformes
x = np.concatenate([
np.arange(0, 10, 2), ## Échantillonnage grossier
np.arange(0, 10, 0.5) ## Échantillonnage fin
])
## Générer les valeurs y correspondantes
y = np.sin(x)
## Interpoler entre les points
f = interpolate.interp1d(x, y)
return x, y, f
x, y, interpolation_func = create_custom_sampling()def custom_normalization(data, start=0, end=1):
min_val, max_val = min(data), max(data)
return [
start + (x - min_val) * (end - start) / (max_val - min_val)
for x in data
]
## Exemple d'utilisation
raw_data = [10, 20, 30, 40, 50]
normalized_data = custom_normalization(raw_data)
print(normalized_data)| Technique | Cas d'utilisation | Complexité | Performance |
|---|---|---|---|
| Plages NumPy | Calcul scientifique | Moyenne | Haute |
| Générateurs personnalisés | Scénarios flexibles | Élevée | Moyenne |
| Interpolation | Échantillonnage de données | Élevée | Moyenne - Basse |
Expérimentez avec ces techniques dans les environnements Python interactifs de LabEx pour acquérir une expérience pratique des méthodes avancées de génération de plages et de séquences.
En maîtrisant les techniques de plage avec des pas non entiers, les développeurs Python peuvent créer des séquences numériques plus sophistiquées et précises. Ces méthodes avancées élargissent la fonctionnalité traditionnelle de range, offrant une plus grande flexibilité dans la génération de progressions numériques pour diverses tâches de calcul et d'algorithme.
