Срезы с шагом и вычисляемые индексы в Python
Обновлено:
1. Полная форма среза
Полный синтаксис среза:
sequence[start:stop:step]
Где:
start → откуда начинаем
stop → где заканчиваем, не включая этот индекс
step → с каким шагом двигаемся
step
2. Шаг по умолчанию
Если step не указан:
numbers[1:5]
Python использует шаг:
1
Поэтому записи:
numbers[1:5]
и:
numbers[1:5:1]
дают одинаковый результат.
Явно писать step=1 обычно нет необходимости.
3. Шаг 2
numbers = [10, 20, 30, 40, 50, 60, 70]
print(numbers[::2])
Результат:
[10, 30, 50, 70]
Python берёт:
индекс 0
индекс 2
индекс 4
индекс 6
То есть элементы с чётными индексами.
4. Элементы с нечётными индексами
Чтобы начать с индекса 1:
print(numbers[1::2])
Результат:
[20, 40, 60]
Получаем индексы:
1
3
5
5. Другой шаг
Шаг может быть любым целым числом, кроме нуля.
print(numbers[::3])
Результат:
[10, 40, 70]
Python начинает с первого элемента и каждый раз увеличивает индекс на 3.
Отрицательный step
6. Движение справа налево
step может быть отрицательным:
numbers = [10, 20, 30, 40, 50]
print(numbers[::-1])
Результат:
[50, 40, 30, 20, 10]
При отрицательном шаге Python движется справа налево.
Запись:
sequence[::-1]
часто используется для получения элементов в обратном порядке.
7. Шаг -2
print(numbers[::-2])
Результат:
[50, 30, 10]
Начинаем с конца и двигаемся через один элемент.
start и stop при отрицательном шаге
8. Значение start не меняется
Даже при отрицательном step:
start → место, где начинаем
stop → граница, перед которой останавливаемся
Меняется только направление движения.
Например:
numbers = [10, 20, 30, 40, 50, 60]
print(numbers[-2:0:-1])
Начинаем с:
index -2 → 50
и двигаемся справа налево:
50
40
30
20
Индекс 0 не включается, потому что stop всегда является невключительной границей.
Результат:
[50, 40, 30, 20]
9. Ещё один пример
print(numbers[-1:1:-2])
Начинаем с последнего элемента:
60
Двигаемся с шагом:
-2
и останавливаемся перед индексом 1.
Результат:
[60, 40]
При отрицательном шаге удобно сначала определить:
- где начинается движение;
- куда оно направлено;
- перед каким индексом нужно остановиться.
10. step не может быть равен нулю
numbers[::0]
приведёт к:
ValueError
Нельзя двигаться по последовательности с шагом 0.
Вложенные объекты
11. Несколько индексов подряд
Элемент списка сам может оказаться другой последовательностью.
Например, представим небольшой фрагмент данных, полученных от внешнего сервиса:
weather_data = [
'Tbilisi',
(
'today',
[18.5, 24.0, 20.3],
),
]
Получим второй элемент:
print(weather_data[1])
Результат:
('today', [18.5, 24.0, 20.3])
Из него получим список температур:
print(weather_data[1][1])
Результат:
[18.5, 24.0, 20.3]
Теперь конкретную температуру:
print(weather_data[1][1][0])
Результат:
18.5
Каждые следующие квадратные скобки работают уже с объектом, который был получен предыдущей операцией.
12. Можно дойти даже до символа строки
data = [
('Python', ['backend', 'automation']),
]
Выражение:
data[0]
возвращает кортеж.
Дальше:
data[0][1]
возвращает список:
['backend', 'automation']
Затем:
data[0][1][0]
возвращает строку:
backend
И наконец:
data[0][1][0][0]
возвращает первый символ:
b
Вычисления внутри квадратных скобок
13. Индекс может быть результатом выражения
Необязательно записывать индекс готовым числом:
numbers = [10, 20, 30, 40, 50, 60, 70]
Можно написать:
print(numbers[len(numbers) // 2])
Длина списка:
7
Вычисляем:
7 // 2 = 3
Получаем:
numbers[3]
Результат:
40
Для списка с нечётным количеством элементов это позволяет получить центральный элемент.
Деление списка пополам
14. Первая половина
numbers = [10, 20, 30, 40, 50, 60]
middle_index = len(numbers) // 2
first_half = numbers[:middle_index]
print(first_half)
Результат:
[10, 20, 30]
15. Вторая половина
second_half = numbers[middle_index:]
print(second_half)
Результат:
[40, 50, 60]
Один вычисленный индекс можно использовать сразу в нескольких срезах:
middle_index = len(numbers) // 2
first_half = numbers[:middle_index]
second_half = numbers[middle_index:]
16. Внутри индекса может находиться выражение
Все эти варианты допустимы:
numbers[2]
numbers[len(numbers) // 2]
numbers[middle_index]
И со срезами:
numbers[:len(numbers) // 2]
numbers[:middle_index]
numbers[middle_index:]
Квадратные скобки принимают результат вычисленного индекса или границы среза.
Номер дня недели и индекс
17. Проблема нумерации
Создадим кортеж:
weekdays = (
'monday',
'tuesday',
'wednesday',
'thursday',
'friday',
'saturday',
'sunday',
)
Для человека дни удобно нумеровать:
1 → monday
2 → tuesday
...
7 → sunday
Но индексы Python:
0 → monday
1 → tuesday
...
6 → sunday
Поэтому нужно сместить значение на единицу.
18. Первый способ
day = 1
weekday = weekdays[day - 1]
print(weekday)
Результат:
monday
Для:
day = 7
получим:
sunday
19. Второй способ — специальный элемент под индексом 0
Можно построить данные так:
weekdays = (
None,
'monday',
'tuesday',
'wednesday',
'thursday',
'friday',
'saturday',
'sunday',
)
Теперь:
day = 1
print(weekdays[day])
Результат:
monday
А:
day = 7
вернёт:
sunday
Индекс 0 в этой структуре специально не используется для дня недели.
Циклические значения
20. Что делать с большим номером
Предположим, нужно определить день не только текущей недели.
Например:
day = 15
Если просто написать:
weekdays[day - 1]
получим несуществующий индекс и IndexError.
Но недели повторяются каждые семь дней:
monday
tuesday
wednesday
thursday
friday
saturday
sunday
monday
...
Для таких циклических данных удобно использовать %.
21. Остаток от деления
weekdays = (
'monday',
'tuesday',
'wednesday',
'thursday',
'friday',
'saturday',
'sunday',
)
day = 15
index = (day - 1) % 7
print(index)
print(weekdays[index])
Результат:
0
monday
Почему?
day = 15
15 - 1 = 14
14 % 7 = 0
Получаем нулевой индекс — понедельник.
22. Другие значения
day = 16
index = (day - 1) % 7
Получим:
1
То есть:
tuesday
Для:
day = 21
получаем:
sunday
Для:
day = 22
снова:
monday
Так остаток от деления позволяет преобразовать любое положительное количество дней в диапазон индексов:
0–6
Где ещё используется циклический индекс
23. Повторяющиеся состояния
Тот же принцип подходит не только для дней недели.
Например, приложение циклически распределяет задачи между тремя серверами:
servers = (
'server_1',
'server_2',
'server_3',
)
request_number = 8
server_index = (request_number - 1) % len(servers)
print(servers[server_index])
Результат:
server_2
После третьего сервера программа снова начинает с первого.
Такой принцип часто применяется для повторяющихся последовательностей.
None внутри среза
24. None можно использовать как границу среза
При обычном обращении по индексу:
numbers[None]
возникнет TypeError.
Но внутри среза None имеет специальный смысл:
numbers[None:None]
Python воспринимает отсутствующие границы как значения по умолчанию.
Например:
numbers = [10, 20, 30, 40, 50]
print(numbers[None:None])
Результат:
[10, 20, 30, 40, 50]
По смыслу это соответствует:
numbers[:]
25. None можно использовать и для step
print(numbers[None:None:None])
Результат:
[10, 20, 30, 40, 50]
То есть:
numbers[None:None:None]
по смыслу работает как:
numbers[::]
Шаг None означает использование стандартного шага.
None особенно полезен в функциях
26. Необязательные границы
Напишем функцию:
def get_slice(
sequence,
start=None,
stop=None,
step=None,
):
return sequence[start:stop:step]
Теперь можно вызвать её вообще без границ:
numbers = [10, 20, 30, 40, 50]
print(get_slice(numbers))
Результат:
[10, 20, 30, 40, 50]
Передадим только start:
print(
get_slice(
numbers,
start=2,
)
)
Результат:
[30, 40, 50]
Передадим start и stop:
print(
get_slice(
numbers,
start=1,
stop=4,
)
)
Результат:
[20, 30, 40]
Или обратное направление:
print(
get_slice(
numbers,
step=-1,
)
)
Результат:
[50, 40, 30, 20, 10]
Так None позволяет сделать параметры среза действительно необязательными.
Главное по второй части
Полный синтаксис среза:
sequence[start:stop:step]
Шаг по умолчанию:
1
Элементы с чётными индексами:
sequence[::2]
С нечётными:
sequence[1::2]
Обратный порядок:
sequence[::-1]
При отрицательном step движение идёт справа налево, но смысл start и stop остаётся тем же:
start → где начинаем
stop → перед какой границей останавливаемся
Можно последовательно обращаться к вложенным объектам:
data[0][1][2]
Индекс или граница среза могут быть результатом выражения:
numbers[len(numbers) // 2]
или заранее вычисленной переменной:
middle_index = len(numbers) // 2
numbers[:middle_index]
numbers[middle_index:]
Для циклических последовательностей удобно использовать остаток от деления:
index = (day - 1) % 7
А в срезах разрешено использовать:
None
например:
sequence[None:None:None]
Это особенно удобно при написании функций с необязательными:
start
stop
step