Индексы и срезы в Python: start и stop

Обновлено:

1. Индексы

У элементов некоторых объектов Python есть порядковые номера — индексы.

Начнём со списка:

products = [
    'Laptop',
    'Mouse',
    'Keyboard',
    'Monitor',
    'Headphones',
]

Индексация начинается с нуля:

индекс:       0          1          2          3           4
элемент:   Laptop      Mouse     Keyboard    Monitor    Headphones

Получить отдельный элемент можно с помощью квадратных скобок:

print(products[0])
print(products[1])
print(products[2])

Результат:

Laptop
Mouse
Keyboard

То есть:

products[0]

возвращает первый элемент списка, хотя его индекс равен 0.


Отрицательные индексы

2. Обращение с конца

Python поддерживает отрицательные индексы.

print(products[-1])

Результат:

Headphones

Индекс:

-1

всегда обозначает последний элемент.

print(products[-2])

Результат:

Monitor

-2 — предпоследний элемент.

Можно представить индексы так:

положительные:     0        1          2          3           4
                 Laptop    Mouse     Keyboard    Monitor    Headphones
отрицательные:    -5       -4         -3         -2          -1

Таким образом, один элемент можно получить двумя способами:

print(products[0])
print(products[-5])

В обоих случаях:

Laptop

3. Зачем нужны отрицательные индексы

Предположим, список постоянно меняется:

orders = [
    'order_101',
    'order_102',
    'order_103',
]

Нам нужен последний заказ.

Можно вычислить его положительный индекс:

last_order = orders[len(orders) - 1]

Но Python позволяет написать значительно проще:

last_order = orders[-1]

Если в список добавятся новые элементы, код менять не нужно:

orders = [
    'order_101',
    'order_102',
    'order_103',
    'order_104',
    'order_105',
]

Выражение:

orders[-1]

по-прежнему вернёт последний элемент:

order_105

Поэтому отрицательные индексы особенно удобны для работы с концом последовательности, когда её длина заранее неизвестна.


Индексация других объектов

4. Строки

Строка тоже поддерживает индексы:

language = 'Python'

print(language[0])
print(language[1])
print(language[-1])

Результат:

P
y
n

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

print(type(language[0]))

Результат:

<class 'str'>

5. Кортежи

Кортежи работают аналогично:

coordinates = (10, 25, 40, 55)

print(coordinates[0])
print(coordinates[-1])

Результат:

10
55

На текущем этапе мы используем индексацию прежде всего с:

list
tuple
str

Позже познакомимся и с другими объектами Python, которые поддерживают обращение по индексу.


IndexError

6. Несуществующий индекс

Предположим, в списке пять элементов:

products = [
    'Laptop',
    'Mouse',
    'Keyboard',
    'Monitor',
    'Headphones',
]

Допустимые положительные индексы:

0–4

Допустимые отрицательные:

-1–-5

Если обратиться к:

products[20]

возникнет:

IndexError: list index out of range

То же самое:

products[-20]

также приводит к IndexError.


7. Что означает IndexError

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

Например:

numbers = [10, 20, 30]

print(numbers[3])

Индексы этого списка:

0
1
2

Индекса:

3

нет, поэтому возникает IndexError.

Это ещё один встроенный класс исключения Python, с которым мы познакомились.


Срезы

8. Получение части последовательности

Кроме одного элемента, из последовательности можно получить сразу несколько элементов.

Для этого используются срезы:

slice

Самый простой синтаксис:

sequence[:]

Например:

numbers = [10, 20, 30, 40]

result = numbers[:]

print(result)

Результат:

[10, 20, 30, 40]

Мы получили все элементы списка.


9. [:] создаёт новый список

numbers = [10, 20, 30, 40]
numbers_copy = numbers[:]

print(numbers)
print(numbers_copy)

print(id(numbers))
print(id(numbers_copy))

Значения списков одинаковые:

print(numbers == numbers_copy)

Результат:

True

Но это разные объекты:

print(numbers is numbers_copy)

Результат:

False

То есть:

numbers[:]

создаёт новый список, содержащий те же элементы.

Позже мы познакомимся с методом:

copy()

который позволяет ещё более явно показать намерение создать копию списка.


10. Полный срез строки

Срезы работают и со строками:

language = 'Python'

result = language[:]

print(result)

Результат:

Python

Строки являются неизменяемыми объектами, поэтому Python может повторно использовать уже существующий объект строки.

Из-за этого для полного среза строки:

language[:]

не следует рассчитывать на создание отдельного объекта с новым id.

Практического смысла получать полный срез строки обычно нет:

language[:]

и:

language

представляют одно и то же строковое значение.


Синтаксис среза

11. start

Срез можно записать так:

sequence[start:]

start указывает индекс, с которого начинается срез.

Возьмём список:

numbers = [10, 20, 30, 40, 50, 60]

Срез:

numbers[1:]

Результат:

[20, 30, 40, 50, 60]

Элемент с индексом 0 пропущен.


12. Другие значения start

print(numbers[2:])

Результат:

[30, 40, 50, 60]

Мы начинаем с индекса 2, поэтому первые два элемента пропускаются.

print(numbers[4:])

Результат:

[50, 60]

Срез начинается с элемента под индексом 4.


Отрицательный start

13. Последние элементы

В start можно использовать отрицательный индекс:

numbers = [10, 20, 30, 40, 50, 60]

print(numbers[-2:])

Результат:

[50, 60]

Срез начинается с предпоследнего элемента.

Поэтому конструкция:

sequence[-2:]

удобна для получения последних двух элементов.

А:

sequence[-10:]

— последних десяти элементов.


14. Практический пример

Предположим, программа хранит последние уведомления пользователя:

notifications = [
    'New message',
    'Payment received',
    'Order created',
    'Order shipped',
    'New comment',
    'Password changed',
    'New login',
]

Интерфейс должен показать максимум последние пять уведомлений:

recent_notifications = notifications[-5:]

print(recent_notifications)

Получим последние пять элементов.

Если уведомлений будет всего три:

notifications = [
    'New message',
    'Payment received',
    'Order created',
]

то тот же код:

notifications[-5:]

просто вернёт все три элемента.

Нам не нужно отдельно проверять длину списка.


Несуществующие индексы в срезах

15. Срез не вызывает IndexError

Это важное отличие между обычным индексом и срезом.

Обычное обращение:

numbers[100]

приведёт к:

IndexError

Но:

numbers[100:]

не вызовет ошибку.

Получим:

[]

16. Слишком большой отрицательный индекс

numbers = [10, 20, 30, 40, 50]

print(numbers[-100:])

Результат:

[10, 20, 30, 40, 50]

Python автоматически ограничивает границы среза существующей последовательностью.

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


stop

17. Правая граница среза

Можно указать только конец:

sequence[:stop]

Например:

numbers = [10, 20, 30, 40, 50]

print(numbers[:2])

Результат:

[10, 20]

Мы получили элементы с индексами:

0
1

Элемент с индексом:

2

не вошёл.


18. stop не включается в срез

Это одно из главных правил:

start включается, stop не включается.

Например:

numbers[1:4]

берёт индексы:

1
2
3

но не берёт:

4

Отрицательный stop

19. Исключаем элементы с конца

numbers = [10, 20, 30, 40, 50, 60]

print(numbers[:-2])

Результат:

[10, 20, 30, 40]

Запись:

numbers[:-2]

означает:

Взять всё до предпоследнего индекса, не включая его.

Практически мы получили:

Все элементы, кроме двух последних.


20. Все элементы кроме последнего

Очень распространённая форма:

numbers[:-1]

Например:

numbers = [10, 20, 30, 40]

print(numbers[:-1])

Результат:

[10, 20, 30]

То есть:

[:-1]

означает:

Взять всё, кроме последнего элемента.


start и stop вместе

21. Полный синтаксис первой части

sequence[start:stop]

Например:

numbers = [10, 20, 30, 40, 50, 60]

print(numbers[1:4])

Результат:

[20, 30, 40]

Начинаем с:

индекса 1

и заканчиваем перед:

индексом 4

22. Пропустить начало и конец

numbers = [10, 20, 30, 40, 50, 60]

print(numbers[2:-2])

Результат:

[30, 40]

Мы:

пропустили первые два элемента
и
не взяли последние два

23. Все элементы кроме первого и последнего

print(numbers[1:-1])

Результат:

[20, 30, 40, 50]

Выражение:

sequence[1:-1]

часто удобно читать как:

Все элементы последовательности, кроме первого и последнего.


Индекс и срез — разные операции

24. Результаты имеют разный смысл

Обычный индекс:

numbers = [10, 20, 30, 40]

result = numbers[1]

print(result)

Результат:

20

Мы получили один элемент списка.

Срез:

result = numbers[1:2]

print(result)

Результат:

[20]

Теперь мы получили новый список, содержащий один элемент.

Поэтому:

numbers[1]

и:

numbers[1:2]

— разные операции.


Главное по первой части

Индексы начинаются с нуля:

0, 1, 2, 3...

Отрицательные индексы идут с конца:

... -3, -2, -1

Последний элемент:

sequence[-1]

Предпоследний:

sequence[-2]

Если обычного индекса не существует:

sequence[100]

возникает:

IndexError

Срез записывается:

sequence[start:stop]

start включается в результат:

sequence[2:]

stop не включается:

sequence[:2]

Можно использовать отрицательные границы:

sequence[-5:]
sequence[:-2]
sequence[1:-1]

В отличие от обычной индексации, выход границ среза за пределы последовательности не приводит к IndexError:

sequence[100:]

вернёт пустую последовательность соответствующего типа.

Полный срез списка:

numbers[:]

создаёт новый список.

Все правила срезов, которые мы рассмотрели на списках, аналогично применяются к уже знакомым строкам и кортежам.

В следующей части добавим третью составляющую среза — step — и разберём движение по последовательности с разным шагом и направлением.