Срезы с шагом и вычисляемые индексы в 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]

При отрицательном шаге удобно сначала определить:

  1. где начинается движение;
  2. куда оно направлено;
  3. перед каким индексом нужно остановиться.

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