Кортеж (англ. tuple) — встроенный тип данных в Python. Кортежи используются для хранения нескольких элементов в одной переменной.
Оглавление
- Особенности кортежей
- Создание кортежа
- Доступ к элементам кортежа
- Обновление кортежей
- Удаление значений в кортеже
- Удаление кортежа
- Встроенные функции кортежей
Особенности кортежей
Элементы, хранящиеся в кортеже, могут быть любого типа. Они упорядочены и неизменяемы после создания.
Синтаксис кортежей напоминает синтаксис списков. Кортежи обычно заключаются в круглые скобки, хотя это не обязательно. А списки заключаются в квадратные скобки.
От редакции Pythonist: о списках читайте в статье «Списки в Python: полное руководство для начинающих», а о разнице между кортежами и списками — в статье «Чем отличается кортеж от списка в Python».
Кортежи в Python быстрее, чем другие коллекции данных, но сохранять в них лучше всего данные, которые не понадобится изменять в дальнейшем.
Урок 10 Строки: индексы и срезы Python
Как создать кортеж в Python
Создать кортеж в Python очень просто, но есть несколько моментов, о которых вам нужно знать.
Кортежи обычно заключаются в круглые скобки, но это не обязательно. Кроме того, если в кортеже только одно значение, после него должна стоять запятая.
Ниже приведен пример создания кортежа, содержащего три элемента.
exampletuple = («house», «unit», «apartment»)
Использовав print для вывода этого кортежа, вы получите примерно следующее:
(‘house’, ‘unit’, ‘apartment’)
Кортеж с одним элементом
Если вы хотите создать кортеж, содержащий только один элемент, обязательно добавьте запятую после элемента. Без этого Python не распознает его как кортеж.
Правильное создание кортежа в Python: exampletuple = («house»,) .
Неправильное создание кортежа: exampletuple = («house») .
Использование конструктора tuple()
Для корректного создания кортежа также можно использовать конструктор.
exampletuple = tuple((«house», «unit», «apartment»)) print(exampletuple) # Вывод: # (‘house’, ‘unit’, ‘apartment’)
Как видите, выводится то же значение, что и при создании кортежа без конструктора.
Доступ к элементам кортежа
Доступ к значениям внутри кортежа мало чем отличается от доступа к элементам в списке. В этом разделе мы рассмотрим несколько различных техник, позволяющих получить доступ к нужному вам значению.
Индексация кортежей в Python начинается с 0, поэтому для ссылки на первый элемент используется индексное значение 0. Вы можете получить доступ к элементам кортежа, используя квадратные скобки [] и индексы элементов.
Кортеж можно перебрать в цикле for или обращаться к данным напрямую, по индексу.
От редакции Pythonist: рекомендуем почитать «Цикл for в Python: тонкости написания».
Индексы элементов кортежа
В нашем примере мы создаем кортеж с 5 элементами. Это означает, что первый элемент будет иметь индекс 0, а последний — 4. Попытка получить доступ к элементу кортежа по индексу вне этого диапазона приведет к ошибке.
34 Кортежи (tuple) в Python. Операции и методы кортежей
После создания кортежа мы выводим значения элементов под индексами 0 и 3.
exampletuple = («house», «unit», «apartment», «villa», «acreage») print(exampletuple[0]) print(exampletuple[3]) # Вывод: # house # villa
Как видите, значение элемента с индексом 0 — это первая строка, house . А под индексом 3 хранится четвертая строка, villa .
Отрицательный индекс
В коллекции данных кортежа можно использовать отрицательный индекс. Использование отрицательных чисел означает, что отсчет идет в обратном направлении. Так, индекс -1 относится к последнему элементу кортежа.
В следующем примере мы создаем кортеж с 5 элементами. Мы будем обращаться к этим элементам, используя отрицательный индекс вместо положительного.
exampletuple = («house», «unit», «apartment», «villa», «acreage») print(exampletuple[-1]) print(exampletuple[-3]) # Вывод: # acreage # apartment
Как видите, мы вывели последний и третий элемент нашего кортежа.
Срезы кортежей
Чтобы получить доступ к диапазону значений из кортежа, вы можете использовать оператор среза — : . Чтобы задать диапазон, вы указываете его начало и конец, разделяя их двоеточием. Например, [0:4] выберет все значения с индексами от 0 до 4.
Указывать начало и конец диапазона не обязательно. Но важно, какое именно значение вы опустите. Так, например, срез [:3] выберет все элементы от начала кортежа, т. е. от элемента с индексом 0, до элемента с индексом 3. А срез [1:] — элементы от индекса 1 до конца кортежа.
В нашем примере ниже мы хотим получить все, что находится между индексами 1 и 3.
exampletuple = («house», «unit», «apartment», «villa», «acreage») print(exampletuple[1:3]) # Вывод: # (‘unit’, ‘apartment’)
Обратите внимание, что при взятии среза элемент, указанный как конец диапазона, в срез не входит. Здесь мы вывели срез [1:3] и получили в выводе элементы с индексами 1 и 2.
Обновление кортежей
Кортежи в Python относятся к неизменяемым типам данных, поэтому вы не можете изменить кортеж после его создания. Однако вы можете создать новый кортеж из частей существующего.
exampletuple = («house», «unit», «apartment», «villa», «acreage») newtuple = exampletuple[0:3] print(newtuple) # Вывод: # (‘house’, ‘unit’, ‘apartment’)
Наш новый кортеж содержит только часть старого. Можно пойти еще дальше и объединить два кортежа в новый кортеж (мы рассмотрим это в следующем разделе).
От редакции Pythonist: на тему изменяемости объектов рекомендуем очень хорошую и подробную статью — «Python 3: изменяемый, неизменяемый…».
Конкатенация нескольких кортежей
Вам может понадобиться объединить несколько кортежей. Например, присоединить часть одного кортежа к другому.
В следующем примере мы берем часть исходного кортежа и объединяем ее с новым кортежем. Этот объединенный кортеж хранится в новой переменной.
exampletuple = («house», «unit», «apartment», «villa», «acreage») newtuple = exampletuple[0:3] + («ranch», «farm») print(newtuple) # Вывод: # (‘house’, ‘unit’, ‘apartment’, ‘ranch’, ‘farm’)
Итак, мы успешно объединили два кортежа. Конечно, это всего лишь пример, и вы можете проделать это более чем с двумя кортежами.
Удаление значений в кортеже
Как мы уже говорили, кортежи в Python неизменяемы, но значения из них все же можно удалять. Правда, как и при конкатенации, для этого создается новый кортеж.
В приведенном ниже примере мы удаляем элемент apartment , разрезая кортеж и не включая этот конкретный элемент в newtuple .
exampletuple = («house», «unit», «apartment», «villa», «acreage») newtuple = exampletuple[:2] + exampletuple[3:] print(newtuple) # Вывод: # (‘house’, ‘unit’, ‘villa’, ‘acreage’)
Элемент apartment был успешно удален, но для этого пришлось создать новый кортеж.
Удаление кортежа
Удаление целого кортежа в Python довольно простое и может быть выполнено с помощью оператора del . После удаления любое обращение к этому кортежу приведет к ошибке, если только вы не создадите его заново.
Ниже мы создаем кортеж, выводим его, удаляем и пытаемся вывести снова.
exampletuple = («house», «unit», «apartment») print(exampletuple) del exampletuple print(exampletuple)
(‘house’, ‘unit’, ‘apartment’) Traceback (most recent call last): File «D:Pythontuple.py», line 7, in print(exampletuple) NameError: name ‘exampletuple’ is not defined
Вывод показывает, что Python успешно удалил кортеж, поскольку при попытке вывести его во второй раз возникла ошибка.
Встроенные функции кортежей
Кортежи в Python 3
Кортеж – это неизменяемый тип данных, который представляет собой упорядоченную последовательность элементов.
Кортежи позволяют группировать данные. Значения в кортеже называются элементами.
Все элементы кортежа берутся в круглые скобки () и разделяются запятыми. Пустой кортеж имеет такой вид:
Даже если в кортеже всего одно значение, нужно поставить запятую:
coral = (‘blue coral’,)
Если отобразить приведённый выше пример кортежа с помощью print(), на экране появится:
print(coral)
(‘blue coral’, ‘staghorn coral’, ‘pillar coral’, ‘elkhorn coral’)
Чтобы лучше представить себе кортеж Python (или другой коллекционный тип данных), полезно вспомнить те коллекции и совокупности данных, что есть на вашем компьютере: файлы, плейлисты, закладки браузера, переписку и т.п.
Кортежи похожи на списки, но, в отличие от последних, они неизменяемы, то есть их нельзя редактировать.
Используя кортеж в коде программы, вы можете сообщить о том, что та или иная последовательность данных не должна изменяться. Кортежи позволяют оптимизировать код, поскольку в Python они обрабатываются немного быстрее, чем списки.
Индексация кортежей
Каждый элемент в кортеже, как и в любой другой упорядоченной последовательности, можно вызвать по его индексу.
Каждому элементу присваивается уникальный индекс (целое число). Индексация начинается с 0.
Вернёмся к кортежу coral и посмотрим, как проиндексированы его элементы:
| ‘blue coral’ | ‘staghorn coral’ | ‘pillar coral’ | ‘elkhorn coral’ |
| 1 | 2 | 3 |
Первый элемент (‘blue coral’) идёт под индексом 0, а последний (‘elkhorn coral’) – под индексом 3.
При помощи индекса можно вызвать каждый отдельный элемент кортежа. Например:
print(coral[2])
pillar coral
Диапазон индексов данного кортежа – 0-3. Таким образом, чтобы вызвать любой из элементов в отдельности, можно сослаться на индекс.
coral[0] = ‘blue coral’
coral[1] = ‘staghorn coral’
coral[2] = ‘pillar coral’
coral[3] = ‘elkhorn coral’
Если вызвать индекс вне диапазона данного кортежа (в данном случае это индекс больше 3), Python выдаст ошибку:
print(coral[22])
IndexError: tuple index out of range
Также в кортежах можно использовать отрицательные индексы; для этого подсчёт ведётся в обратном направлении с конца кортежа, начиная с -1. Отрицательная индексация особенно полезна, если вы хотите определить последний элемент в конце длинного кортежа.
Кортеж coral будет иметь такие отрицательные индексы:
| ‘blue coral’ | ‘staghorn coral’ | ‘pillar coral’ | ‘elkhorn coral’ |
| -4 | -3 | -2 | -1 |
Чтобы запросить первый элемент, ‘blue coral’, по отрицательному индексу, нужно ввести:
print(coral[-4])
blue coral
Элементы кортежа можно склеивать со строками при помощи оператора +:
print(‘This reef is made up of ‘ + coral[1])
This reef is made up of staghorn coral
Также оператор + позволяет склеить два кортежа (больше информации об этом – дальше в статье).
Срез кортежа
Срез позволяет вызывать несколько значений кортежа в диапазоне [start:stop] (start – включительно, stop – исключительно).
К примеру, чтобы вызвать элементы кортежа с индексом 1 и 2, нужно ввести:
print(coral[1:3])
(‘staghorn coral’, ‘pillar coral’)
Как видите, первый элемент (1) включается в диапазон, а последний (3) исключается из него. Потому на экране появляются элементы 1 и 2.
Чтобы включить в срез начало или конец кортежа, можно опустить индекс первого или последнего её символа соответственно. К примеру, чтобы вывести только первые три элемента, можно ввести:
print(coral[:3])
(‘blue coral’, ‘staghorn coral’, ‘pillar coral’)
Чтобы вывести последние три элемента кортежа coral, нужно ввести:
print(coral[1:])
(‘staghorn coral’, ‘pillar coral’, ‘elkhorn coral’)
В срезах можно использовать отрицательные индексы.
print(coral[-3:-1])
print(coral[-2:])
(‘staghorn coral’, ‘pillar coral’)
(‘pillar coral’, ‘elkhorn coral’)
Третий параметр среза – это шаг:
Этот параметр указывает, на сколько элементов нужно продвинуться после взятия первого элемента. По умолчанию шаг в Python равен 1, то есть, Python будет извлекать элементы по порядку.
Попробуйте создать большой кортеж и создать срез с шагом:
numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
print(numbers[1:11:2])
(1, 3, 5, 7, 9)
Конструкция numbers[1:11:2] выводит каждый второй элемент кортежа, начиная с индекса 1 (включительно) и заканчивая индексом 11 (исключительно).
0, 1 , 2, 3 , 4, 5 , 6, 7 , 8, 9 , 10, 11 , 12
Можно пропустить первые два параметра и использовать только шаг:
print(numbers[::3])
(0, 3, 6, 9, 12)
Теперь в срез войдёт каждый третий элемент кортежа, начиная с первого элемента:
0 , 1, 2, 3 , 4, 5, 6 , 7, 8, 9 , 10, 11, 12
Конкатенация и умножение кортежей
Выполнить конкатенацию или умножение кортежа можно с помощью различных операторов. Для конкатенации используется оператор +, а для умножения – оператор *.
Посмотрим, как работает оператор +, который позволяет склеить два или больше кортежей в новый кортеж.
coral = (‘blue coral’, ‘staghorn coral’, ‘pillar coral’, ‘elkhorn coral’)
kelp = (‘wakame’, ‘alaria’, ‘deep-sea tangle’, ‘macrocystis’)
coral_kelp = (coral + kelp)
print(coral_kelp)
(‘blue coral’, ‘staghorn coral’, ‘pillar coral’, ‘elkhorn coral’, ‘wakame’, ‘alaria’, ‘deep-sea tangle’, ‘macrocystis’)
Оператор + объединяет кортежи и таким образом создаёт новый кортеж, однако он не может изменять существующие кортежи.
Оператор * позволяет умножать кортежи. Умножение используется, если, к примеру, вам нужно скопировать файлы в другой каталог или поделиться плейлистом с друзьями.
Попробуйте умножить кортеж coral на 2, а kelp – на 3. Присвойте полученный результат новым кортежам.
multiplied_coral = coral * 2
multiplied_kelp = kelp * 3
print(multiplied_coral)
print(multiplied_kelp)
(‘blue coral’, ‘staghorn coral’, ‘pillar coral’, ‘elkhorn coral’, ‘blue coral’, ‘staghorn coral’, ‘pillar coral’, ‘elkhorn coral’)
(‘wakame’, ‘alaria’, ‘deep-sea tangle’, ‘macrocystis’, ‘wakame’, ‘alaria’, ‘deep-sea tangle’, ‘macrocystis’, ‘wakame’, ‘alaria’, ‘deep-sea tangle’, ‘macrocystis’)
Оператор * позволяет реплицировать кортеж указанное количество раз и создавать новые кортежи на основе исходных данных.
Функции кортежей
Python предоставляет несколько встроенных функций для работы с кортежами.
Функция len()
Функция len() позволяет вычислить длину кортежа (как и в случае со строками и списками).
Эта функция помогает обеспечить соблюдение минимальной или максимальной длины кортежа. Также она позволяет сравнивать последовательные данные.
Попробуйте вывести длину кортежей kelp и numbers:
print(len(kelp))
print(len(numbers))
4
13
В кортеже kelp 4 элемента:
kelp = (‘wakame’, ‘alaria’, ‘deep-sea tangle’, ‘macrocystis’)
А в numbers их 13.
numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
Функция len() очень полезна при работе с большими кортежами.
Функции max() и min()
При работе с кортежами, состоящими из числовых элементов (как целых, так и с плавающей точкой), функции max() и min() помогают найти самое высокое и самое низкое значение кортежа.
Эти функции полезны при работе с количественными данными (такими как результаты тестов, температура, цены и т.д.).
Рассмотрим кортеж из чисел с плавающей точкой:
more_numbers = (11.13, 34.87, 95.59, 82.49, 42.73, 11.12, 95.57)
Чтобы вывести на экран максимальное значение, нужно передать кортеж функции max(), а затем объединить её с print():
Аналогичным образом работает функция min():
Как и len(), функции max() и min() будут очень полезными при работе с большим количеством данных.
Чем кортежи отличаются от списков?
Первое отличие между кортежами и списками состоит в том, что кортежи являются неизменяемым типом данных. это значит, что в кортежах нельзя добавлять, изменять или удалять элементы, а в списках – можно.
Однако вы можете объединить два или больше кортежа в новый кортеж
Рассмотрим кортеж coral:
coral = (‘blue coral’, ‘staghorn coral’, ‘pillar coral’, ‘elkhorn coral’)
К примеру, вы хотите заменить элемент ‘blue coral’ новым элементом, ‘black coral’. Попробуйте изменить его так, как вы сделали бы это со списком:
coral[0] = ‘black coral’
Вы получите ошибку:
TypeError: ‘tuple’ object does not support item assignment
Если же вы создали кортеж и поняли, что на самом деле вам нужен список, вы можете преобразовать кортеж в список с помощью функции list():
Теперь coral – список, а не кортеж:
coral = [‘blue coral’, ‘staghorn coral’, ‘pillar coral’]
Обратите внимание на скобки: теперь они квадратные, а не круглые, а это значит, что кортеж преобразовался в список.
Чтобы преобразовать список в кортеж, используйте функцию tuple().
Заключение
Кортежи – это неизменяемый последовательный тип данных, с помощью которого можно оптимизировать код программы. При помощи кортежа также можно сообщить другим разработчикам команды, что тот или иной блок данных изменять не следует.
Теперь вы знакомы с основными функциями кортежей и умеете выполнять базовые операции с ними (например, конкатенацию, умножение, срезы и т.п.).
Источник: www.8host.com
Python: коллекции, часть 2/4: индексирование, срезы, сортировка
В данной статье мы продолжим изучать общие принципы работы со стандартными коллекциями (модуль collections в ней не рассматривается) Python.
Для кого: для изучающих Python и уже имеющих начальное представление о коллекциях и работе с ними, желающих систематизировать и углубить свои знания, сложить их в целостную картину.
ОГЛАВЛЕНИЕ:
1. Индексирование
1.1 Индексированные коллекции
Рассмотрим индексированные коллекции (их еще называют последовательности — sequences) — список (list), кортеж (tuple), строку (string).
Под индексированностью имеется ввиду, что элементы коллекции располагаются в определённом порядке, каждый элемент имеет свой индекс от 0 (то есть первый по счёту элемент имеет индекс не 1, а 0) до индекса на единицу меньшего длины коллекции (т.е. len(mycollection)-1).
1.2 Получение значения по индексу
Для всех индексированных коллекций можно получить значение элемента по его индексу в квадратных скобках. Причем, можно задавать отрицательный индекс, это значит, что будем находить элемент с конца считая обратном порядке.
При задании отрицательного индекса, последний элемент имеет индекс -1, предпоследний -2 и так далее до первого элемента индекс которого равен значению длины коллекции с отрицательным знаком, то есть (-len(mycollection).
my_str = «abcde» print(my_str[0]) # a — первый элемент print(my_str[-1]) # e — последний элемент print(my_str[len(my_str)-1]) # e — так тоже можно взять последний элемент print(my_str[-2]) # d — предпоследний элемент
Наши коллекции могут иметь несколько уровней вложенности, как список списков в примере ниже. Для перехода на уровень глубже ставится вторая пара квадратных скобок и так далее.
my_2lvl_list = [[1, 2, 3], [‘a’, ‘b’, ‘c’]] print(my_2lvl_list[0]) # [1, 2, 3] — первый элемент — первый вложенный список print(my_2lvl_list[0][0]) # 1 — первый элемент первого вложенного списка print(my_2lvl_list[1][-1]) # с — последний элемент второго вложенного списка
1.3 Изменение элемента списка по индексу
Поскольку кортежи и строки у нас неизменяемые коллекции, то по индексу мы можем только брать элементы, но не менять их:
my_tuple = (1, 2, 3, 4, 5) print(my_tuple[0]) # 1 my_tuple[0] = 100 # TypeError: ‘tuple’ object does not support item assignment
А вот для списка, если взятие элемента по индексу располагается в левой части выражения, а далее идёт оператор присваивания =, то мы задаём новое значение элементу с этим индексом.
my_list = [1, 2, 3, [4, 5]] my_list[0] = 10 my_list[-1][0] = 40 print(my_list) # [10, 2, 3, [40, 5]]
UPD: Примечание: Для такого присвоения, элемент уже должен существовать в списке, нельзя таким образом добавить элемент на несуществующий индекс.
my_list = [1, 2, 3, 4, 5] my_list[5] = 6 # IndexError: list assignment index out of range
2 Срезы
2.1 Синтаксис среза
Очень часто, надо получить не один какой-то элемент, а некоторый их набор ограниченный определенными простыми правилами — например первые 5 или последние три, или каждый второй элемент — в таких задачах, вместо перебора в цикле намного удобнее использовать так называемый срез (slice, slicing).
Следует помнить, что взяв элемент по индексу или срезом (slice) мы не как не меняем исходную коллекцию, мы просто скопировали ее часть для дальнейшего использования (например добавления в другую коллекцию, вывода на печать, каких-то вычислений). Поскольку сама коллекция не меняется — это применимо как к изменяемым (список) так и к неизменяемым (строка, кортеж) последовательностям.
Синтаксис среза похож на таковой для индексации, но в квадратных скобках вместо одного значения указывается 2-3 через двоеточие:
my_collection[start:stop:step] # старт, стоп и шаг
Особенности среза:
- Отрицательные значения старта и стопа означают, что считать надо не с начала, а с конца коллекции.
- Отрицательное значение шага — перебор ведём в обратном порядке справа налево.
- Если не указан старт [:stop:step]— начинаем с самого края коллекции, то есть с первого элемента (включая его), если шаг положительный или с последнего (включая его), если шаг отрицательный (и соответственно перебор идет от конца к началу).
- Если не указан стоп [start:: step] — идем до самого края коллекции, то есть до последнего элемента (включая его), если шаг положительный или до первого элемента (включая его), если шаг отрицательный (и соответственно перебор идет от конца к началу).
- step = 1, то есть последовательный перебор слева направо указывать не обязательно — это значение шага по умолчанию. В таком случае достаточно указать [start:stop]
- Можно сделать даже так [:] — это значит взять коллекцию целиком
- ВАЖНО: При срезе, первый индекс входит в выборку, а второй нет!
То есть от старта включительно, до стопа, где стоп не включается в результат. Математически это можно было бы записать как [start, stop) или пояснить вот таким правилом:
Примеры срезов в виде таблицы:
Код примеров из таблицы
col = ‘abcdefg’ print(col[:]) # abcdefg print(col[::-1]) # gfedcba print(col[::2]) # aceg print(col[1::2]) # bdf print(col[:1]) # a print(col[-1:]) # g print(col[3:4]) # d print(col[-3:]) # efg print(col[-3:1:-1]) # edc print(col[2:5]) # cde
2.2. Именованные срезы
Чтобы избавится от «магических констант», особенно в случае, когда один и тот же срез надо применять многократно, можно задать константы с именованными срезами с пользованием специальной функции slice()()
Примечание: Nonе соответствует опущенному значению по-умолчанию. То есть [:2] становится slice(None, 2), а [1::2] становится slice(1, None, 2).
person = (‘Alex’, ‘Smith’, «May», 10, 1980) NAME, BIRTHDAY = slice(None, 2), slice(2, None) # задаем константам именованные срезы # данные константы в квадратных скобках заменятся соответствующими срезами print(person[NAME]) # (‘Alex’, ‘Smith’) print(person[BIRTHDAY]) # (‘May’, 10, 1980)
my_list = [1, 2, 3, 4, 5, 6, 7] EVEN = slice(1, None, 2) print(my_list[EVEN]) # [2, 4, 6]
2.3 Изменение списка срезом
Важный момент, на котором не всегда заостряется внимание — с помощью среза можно не только получать копию коллекции, но в случае списка можно также менять значения элементов, удалять и добавлять новые.
Проиллюстрируем это на примерах ниже:
-
Даже если хотим добавить один элемент, необходимо передавать итерируемый объект, иначе будет ошибка TypeError: can only assign an iterable
my_list = [1, 2, 3, 4, 5] # my_list[1:2] = 20 # TypeError: can only assign an iterable my_list[1:2] = [20] # Вот теперь все работает print(my_list) # [1, 20, 3, 4, 5]
Срез аналоги .append() и insert()
my_list = [1, 2, 3, 4, 5] my_list[5:] = [6] # вставляем в конец — лучше использовать .append(6) print(my_list) # [1, 2, 3, 4, 5, 6] my_list[0:0] = [0] # вставляем в начало — лучше использовать .insert(0, 0) print(my_list) # [0, 1, 2, 3, 4, 5, 6] my_list[3:3] = [25] # вставляем между элементами — лучше использовать .insert(3, 25) print(my_list) # [0, 1, 2, 25, 3, 4, 5, 6]
my_list = [1, 2, 3, 4, 5] my_list[1:3] = [20, 30] print(my_list) # [1, 20, 30, 4, 5] my_list[1:3] = [0] # нет проблем заменить два элемента на один print(my_list) # [1, 0, 4, 5] my_list[2:] = [40, 50, 60] # или два элемента на три print(my_list) # [1, 0, 40, 50, 60]
my_list = [1, 2, 3, 4, 5] my_list[:2] = [] # или del my_list[:2] print(my_list) # [3, 4, 5]
2.4 Выход за границы индекса
Обращение по индексу по сути является частным случаем среза, когда мы обращаемся только к одному элементу, а не диапазону. Но есть очень важное отличие в обработке ситуации с отсутствующим элементом с искомым индексом.
Обращение к несуществующему индексу коллекции вызывает ошибку:
my_list = [1, 2, 3, 4, 5] print(my_list[-10]) # IndexError: list index out of range print(my_list[10]) # IndexError: list index out of range
А в случае выхода границ среза за границы коллекции никакой ошибки не происходит:
my_list = [1, 2, 3, 4, 5] print(my_list[0:10]) # [1, 2, 3, 4, 5] — отработали в пределах коллекции print(my_list[10:100]) # [] — таких элементов нет — вернули пустую коллекцию print(my_list[10:11]) # [] — проверяем 1 отсутствующий элемент — пустая коллекция, без ошибки
Примечание: Для тех случаев, когда функционала срезов недостаточно и требуются более сложные выборки, можно воспользоваться синтаксисом выражений-генераторов, рассмотрению которых посвещена 4 статья цикла.
3 Сортировка элементов коллекции
Сортировка элементов коллекции важная и востребованная функция, постоянно встречающаяся в обычных задачах. Тут есть несколько особенностей, на которых не всегда заостряется внимание, но которые очень важны.