Индексы и срезы в 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 — и разберём движение по последовательности с разным шагом и направлением.