Python range() — полное руководство

Одна из вещей в программировании, о которой многие руководства умалчивают — это объём циклов и подсчётов, которые придётся выполнять. Любой язык стоит того, чтобы уметь удобно перечислять числа. В Python для этого есть тип последовательности range().

В этой статье подробно разберём, как работает range(), когда его применять, какие есть альтернативы и как тестировать корректность использования.

Что такое range()

Несмотря на внешний вид функции, range() в Python 3 — это встроенный неизменяемый тип последовательности. Его можно рассматривать как «виртуальный массив» целых чисел: он описывает последовательность значений без немедленного создания полного списка в памяти.

Краткое определение: range — ленивый объект-последовательность целых чисел. Он поддерживает индексацию, срезы и итерацию.

Важно: range возвращает объект типа range, а не список или кортеж. Чтобы получить явный список — используйте list(range(…)) или tuple(range(…)).

Базовый синтаксис

range(y)

Здесь y — целое число. На практике чаще используется одна из форм:

range(start, stop, step)

Трактовка параметров:

• start — начальное значение (включительно). По умолчанию 0.
• stop — значение, на котором последовательность останавливается (не включая stop).
• step — шаг между элементами; может быть отрицательным для убывающей последовательности. По умолчанию 1.

Примеры базового использования и поведения:

# простая итерация от 0 до 4
for i in range(5):
    print(i)  # 0,1,2,3,4

# от 2 до 8 (2,3,4,5,6,7)
list(range(2, 8))

# только чётные числа от 0 до 10
list(range(0, 11, 2))

# убывающая последовательность
list(range(10, 0, -2))  # 10,8,6,4,2

Практические сценарии

• Повторение операции фиксированное число раз (цикл for i in range(n)).
• Индексация коллекций: for i in range(len(a)): … — хотя часто лучше использовать enumerate().
• Генерация последовательностей с шагом: арифметические прогрессии, чётные/нечётные числа.
• Обход по убыванию с отрицательным шагом.

Комбинации с другими функциями

Чтобы получить стандартную коллекцию:

nums = list(range(5))        # [0,1,2,3,4]
tpl = tuple(range(3))        # (0,1,2)

С enumerate():

for idx, val in enumerate(some_list):
    # удобнее, чем for i in range(len(some_list))
    pass

Ментальная модель: «виртуальный массив» и почему это важно

Представляйте range как описание массива, а не сам массив. Это означает две вещи:

• Низкое потребление памяти даже для больших диапазонов.
• Поддержка индексирования и срезов без материального размещения всех элементов.

Это полезно, когда нужно пройтись по миллионам чисел без выделения памяти под весь список.

Важно: range работает только с целыми числами. Если нужны дробные шаги — используйте numpy.arange, itertools.count с фильтрацией или собственные генераторы.

Когда range не подходит (контрпримеры)

• Нужны дробные (float) шаги или точность шага с плавающей точкой — range не поддерживает float.
• Требуется мгновенный доступ ко всем элементам в виде изменяемого списка — тогда используйте list(range(…)).
• Нужна бесконечная последовательность — используйте itertools.count().

Альтернативы и когда выбирать их

• list(range(…)) — когда нужен изменяемый список.
• tuple(range(…)) — когда нужна неизменяемая коллекция целых значений.
• itertools.count(start, step) — для потенциально бесконечных или ленивых генераторов.
• numpy.arange — для чисел с плавающей точкой и векторных операций (в научных задачах).

Мини‑методика: как выбрать start/stop/step

1. Определите первый элемент (start). Если нужен ноль — можно опустить.
2. Определите значение «один за последним» (stop), то есть stop не включается.
3. Выберите step: 1 для последовательностей подряд, >1 для пропусков, отрицательный для убывания.
4. Проверяйте границы: для пустых диапазонов range возвращает пустой объект.

Примеры шаблонов:

• Диапазон индексов: range(len(collection))
• Чётные в [a,b]: range(a + (a % 2), b+1, 2) или вычислить первый чётный вручную
• Массив из N нулей с индексами: [0]*N (альтернатива, если нужен список)

Тесты и критерии приёмки

Критерии приёмки:

• Для заданных start/stop/step генератор возвращает ожидаемую последовательность.
• Пограничные случаи: start == stop → пустой; step == 0 → ошибка ValueError.
• Конверсия в list/tuple даёт ожидаемые элементы и порядок.

Простейшие тесты (pytest):

def test_range_simple():
    assert list(range(5)) == [0,1,2,3,4]

def test_range_negative_step():
    assert list(range(5, 0, -1)) == [5,4,3,2,1]

import pytest

def test_zero_step_raises():
    with pytest.raises(ValueError):
        list(range(0, 5, 0))

Чек-листы по ролям

Разработчик‑новичок:

• Используйте range(n) для простых циклов.
• Предпочитайте enumerate() для обхода коллекций с индексом.

Бэкенд‑разработчик:

• Используйте ленивость range для экономии памяти при больших объёмах.
• Тщательно проверяйте граничные значения (stop не включается).

Дата‑сайентист:

• Для векторных операций используйте numpy; range хорош для индексации, но не для численных расчётов с плавающей точкой.

Совместимость и миграция

• Python 2: раньше существовал xrange(), который вел себя похоже. В Python 3 range() заменил xrange() и обладает расширенной функциональностью. Если поддерживаете старый код, при миграции на Python 3 замените xrange на range осторожно.

Подсказки и приёмы (cheat sheet)

• range(n) — 0..n-1
• range(a, b) — a..b-1
• range(a, b, s) — a..b-1 с шагом s
• list(range(…)) — получить список
• tuple(range(…)) — получить кортеж
• negative step для убывания
• step == 0 — ValueError

Итог и рекомендации

range() — это простой, но мощный инструмент для генерации целочисленных последовательностей в Python. Он экономит память за счёт ленивой семантики, поддерживает отрицательные шаги и совместим с большинством операций последовательностей. Для чисел с плавающей точкой или векторных вычислений используйте специализированные библиотеки.

Ключевое: выбирайте range, когда нужна эффективная и читабельная генерация целых последовательностей. Конвертируйте в list/tuple только при необходимости.

Важно: если вам нужна дробная арифметика или очень большие/специфичные шаги, рассмотрите numpy, itertools или генераторы.

Краткое резюме:

• range — ленивый объект-последовательность целых чисел.
• Поддерживает start, stop, step; stop не включается.
• Эффективен по памяти; легко конвертируется в list/tuple.