Разбираемся с массивами в Python: списки

Python — мощный и гибкий язык, в котором есть несколько видов встроенных структур для хранения и обработки данных. Один из них — список. Сегодня разберём свойства и функции списков, узнаем, какие над ними можно совершать операции и какие у них методы. Предупреждаем: мы постарались описать всё подробно, поэтому материал получился очень большой.

Что такое список

Список list — это универсальная упорядоченная и изменяемая коллекция элементов, которые могут иметь любой тип данных. В Python список и массив — практически идентичные понятия. Если точнее, списки — это массивы ссылок на объекты в памяти компьютера. Если памяти достаточно, в список можно добавить сколько угодно объектов. Запасные ячейки предусмотрены заранее, чтобы не перезаписывать массив в памяти.

Для создания списка достаточно использовать простой синтаксис: элементы заключаются в квадратные скобки и разделяются запятыми. Например, мы хотим создать список с числами от 0 до 9:

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Ещё один способ сделать такой же список — использовать встроенный метод list и функцию range, которая создаёт последовательность чисел:

my_list = list(range(10))

Основные свойства списков определяют возможности их использования:

Операции над списками

В Python есть несколько операций, которые можно выполнять над списками. Создадим список из шести животных и рассмотрим такие операции на его примере:

my_pets = ['капибара', 'собака', 'ёж', 'кот', 'сурок', 'попугай']

Получение длины. С помощью функции len() можно узнать, сколько в списке содержится элементов:

# присваиваем переменной значение количества элементов в списке
length = len(my_pets)
# выводим результат
print(f'''my_pets = {my_pets}
Количество животных в списке: {length}''')

Доступ по индексу. Благодаря упорядоченности списков к элементам можно обращаться по индексу. Индексация в Python ведётся с нуля, поэтому номер последнего элемента всегда будет на единицу меньше длины списка. Индексы могут быть и отрицательными, в этом случае обращение к элементам будет производиться с конца списка.

Например, мы можем вывести третий, предпоследний и последний элементы из нашего списка:

print(f'''my_pets = {my_pets}
Избранные животные: {my_pets[2]}, {my_pets[-2]}, {my_pets[length - 1]}''')

По индексу также можно присвоить элементы списка другим переменным для дальнейшей работы с ними:

# присваиваем переменной элемент списка с индексом 2
my_pet1 = my_pets[2]
# присваиваем переменной элемент списка с индексом −2 (предпоследний)
my_pet2 = my_pets[-2]
# присваиваем переменной последний элемент списка
last_pet = my_pets[length - 1]
# выводим результаты
print(f'''my_pets = {my_pets}
my_pet1 = {my_pet1}
my_pet2 = {my_pet2}
last_pet = {last_pet}''')

Срезы. С помощью срезов можно выбрать из списка подраздел, указав начальный и конечный индексы элементов. При этом элемент с последним указанным индексом не будет включён в срез.

# выбираем часть списка с первого по четвёртый элементы
my_pets_part1 = my_pets[0:5]
# выбираем элементы с четвёртого и до конца
my_pets_part2 = my_pets[3:]
# выбираем элементы с третьего по пятый
my_pets_part3 = my_pets[2:6]
# выбираем элементы с первого по третий
my_pets_part4 = my_pets[0:4]
# выбираем элементы с первого по третий
my_pets_part4 = my_pets[:-3]
# выбираем элементы с предпоследнего и до конца
my_pets_part5 = my_pets[-2:]
# выбираем элементы с начала, шагая через 2
my_pets_part6 = my_pets[::2]
# выбираем в обратном порядке, шагая через 1
my_pets_reversed = my_pets[::-1]
# выводим результаты
print(f'''my_pets = {my_pets}
my_pets_part1 = {my_pets_part1}
my_pets_part2 = {my_pets_part2}
my_pets_part3 = {my_pets_part3}
my_pets_part4 = {my_pets_part4}
my_pets_part5 = {my_pets_part5}
my_pets_part6 = {my_pets_part6}
my_pets_reversed = {my_pets_reversed}''')

Конкатенация. Списки можно складывать между собой:

# объединяем два списка в один
my_pets = my_pets + ['шиншилла']
# выводим результат
print(f'Список животных после добавления шиншиллы: {my_pets}')

Удаление элемента или всего списка. Можно выборочно удалять элемент, срез или целый список:

# удаляем ранее добавленный элемент списка
del my_pets[6]
# выводим результат
print(f'Список животных после удаления элемента “шиншилла”: {my_pets}')
# удаляем из перевёрнутого списка все элементы, кроме первого
del my_pets_reversed[1:]
# выводим результат
print(f'Список my_pets_reversed после удаления всех элементов, кроме первого = {my_pets_reversed}')

Если удалить список целиком, при выводе результата мы получим ошибку.

del my_pets_part1
print(f'my_pets_part1 = {my_pets_part1}')

Умножение на целое число. Умножив список на N, мы присоединим к нему N−1 таких же списков:

my_pets = my_pets * 2
print(f'Список животных после дублирования: {my_pets}')

Проверка наличия элемента. Оператор in проверяет наличие элемента в списке, not in — отсутствие:

# проверяем наличие в списке элемента “шиншилла”
flag = 'chinchilla' in my_pets
print(f'flag = {flag}')

# проверяем отсутствие в списке элемента “шиншилла”
flag = 'chinchilla' not in my_pets
print(f'flag = {flag}')

Минимум и максимум. С помощью функций min() и max() можно определять минимальное и максимальное значения. Числовые значения сравниваются по величине, строки — по их числовым значениям в таблице символов Unicode.

# элемент с минимальным значением
my_pets_min = min(my_pets)
# выводим результат
print(f'my_pets_min = {my_pets_min}')
# элемент с максимальным значением
my_pets_max = max(my_pets)
# выводим результат
print(f'my_pets_max = {my_pets_max}')

В нашем примере буква «ё» имеет более высокое числовое значение, чем остальные символы в списке, поэтому слово «ёж» имеет максимальное значение в строке.

Сортировка без изменения. Функция sorted() вернёт отсортированный список без изменения самого списка: 

# сортируем список
my_pets_sorted = sorted(my_pets)
print(f'''Список животных: {my_pets}
Отсортированный список животных: {my_pets_sorted}''')

Сравнение списков. Списки сравниваются поэлементно, пока не найдётся больший из них. Подсписок всегда меньше списка.

# новый список для сравнения 
my_pets_new1 = ['капибара', 'собака']
# выводим результат проверки, что новый список меньше первого
print(my_pets_new1 < my_pets)

Поскольку новый список — подсписок первого, проверка того, что новый список меньше, даёт результат true:

Но если мы возьмём не подсписок, а другую строку, сравниваться будут элементы с равными индексами. Критерий сравнения — порядковый номер в алфавите, а точнее в кодировке ASCII.

# новый список для сравнения
my_pets_new2 = ['мышь']
# выводим результат проверки, что новый список больше первого
print(my_pets_new2 > my_pets)

Поскольку по кодировке ASCII «м» больше «к», получается, что «мышь» больше «капибары», а значит, новый список больше:

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

# новый список для сравнения
my_pets_new2 = ['капи']
# выводим результат проверки, что новый список больше первого
print(my_pets_new2 > my_pets)

Поскольку «капи» — подстрока строки «капибара», получается, что новый список меньше первого, поэтому получаем результат false:

Сумма элементов. С помощью функции sum() можно посчитать сумму элементов в списке:

# список с числами от 1 до 5
my_list = list(range(6))
# считаем сумму всех элементов списка
my_list_sum = sum(my_list)
# выводим результат
print(f'Сумма элементов списка my_list = {my_list_sum}')

Методы списков

Как и у других коллекций, у списков есть свои методы. Чтобы посмотреть все методы списков в Python, можно использовать команду print(dir(list)). Это универсальная команда — вместо list может быть tuple, dict, set и так далее.

Метод .append добавляет один элемент в конец списка. Добавление элементов по одному может быть удобным, если список нужно расширять по мере выполнения программы.

# новый список
my_pets = ['капибара', 'собака']
# выводим результат
print(f'Список животных до изменений: {my_pets}')
# добавляем элемент
my_pets.append('шиншилла')
# выводим результат
print(f'Список животных после добавления элемента “шиншилла”: {my_pets}')

Метод .extend добавляет группу элементов в конец списка:

my_pets.extend(['ёж', 'кот', 'сурок', 'попугай'])
print(f'Список животных после добавления группы элементов: {my_pets}')

Метод .remove удаляет элемент там, где он встречается впервые:

my_pets.remove('собака')
print(f'Список животных после удаления элемента "собака": {my_pets}')

Метод .pop удаляет элемент по индексу и возвращает его значение:

lost_pet = my_pets.pop(0)
print(f'Элемент, удалённый с помощью .pop: {lost_pet}
Список животных после удаления элемента: {my_pets}')

Метод .index возвращает индекс элемента:

index_of_cat = my_pets.index('кот')
print(f'Индекс элемента "кот" в списке: {index_of_cat}')

Метод .count возвращает число вхождений элемента в список: 

frequency_of_dog = my_pets.count('собака')
print(f'Количество вхождений элемента "собака" в список животных: {frequency_of_dog}')

Метод .sort сортирует список, меняя порядок его элементов: 

# сортируем список по возрастанию
my_pets.sort()
# выводим результат
print(f'Список животных после сортировки по возрастанию: {my_pets}')
# сортируем список по убыванию
my_pets.sort(reverse = True)
# выводим результат
print(f'Список животных после сортировки по убыванию: {my_pets}')

Метод .reverse переворачивает список, меняя порядок элементов:

my_pets.reverse()
print(f'Список животных, но перевёрнутый: {my_pets}')

Метод .copy создаёт копию списка аналогично срезам с [::]:

# новый список
my_pets1 = my_pets
# новый список, который копирует список животных
my_pets2 = my_pets.copy()
# меняем элемент с индексом 0 на “собака”
my_pets[0] = 'собака'
# выводим результат
print(f'''Список my_pets1 после изменения элемента с индексом 0 в списке my_pets: {my_pets1}
Список my_pets2 после изменения элемента с индексом 0 в списке my_pets2: {my_pets2}''')

Cписок my_pets1 изменился вслед за my_pets, а список my_pets2 остался прежним. Всё оттого, что списки my_pets1 и my_pets ссылаются на один и тот же объект в памяти, а список my_pets2 — на копию списка my_pets. 

Метод .clear очищает список от всех элементов:

my_pets.clear()
print(f'Список животных после очистки от всех элементов: {my_pets1}')

Метод .insert вставляет элемент на заданную позицию:

my_pets.insert(0, 'собака')
print(f'Список s после вставки элемента "собака" на нулевую позицию: {my_pets}')

Как лучше всего работать со списками

Приведём несколько полезных советов по работе со списками в Python:

Что дальше

В следующий раз мы рассмотрим другой вид массивов — кортеж — и сравним его со списком. Подпишитесь, чтобы не пропустить :-)