Что такое список и как его создать
Список (тип list) хранит упорядоченный набор элементов в квадратных скобках. Элементы могут быть любыми и даже разных типов, а сам список можно менять: добавлять, удалять, переставлять. Этим он отличается от строки и кортежа, которые изменять нельзя. Как списки соотносятся с массивами, стеками и очередями, рассказано в обзоре структур данных для начинающих.
empty = [] # пустой список
nums = [5, 2, 9, 1]
mixed = ["текст", 3.14, True, [1, 2]]
chars = list("abc") # из строки: ['a', 'b', 'c']
zeros = [0] * 3 # [0, 0, 0]
seq = list(range(0, 10, 3)) # [0, 3, 6, 9]
print(len(nums), 9 in nums, nums + [7])
Последняя строка выведет 4 True [5, 2, 9, 1, 7]: длину списка, результат проверки вхождения и новый список, склеенный из двух. Размер списка и количество элементов в нём возвращает функция len. Оператор + создаёт новый список, а исходный не меняет.
Индексы и срезы списков
Индексация такая же, как у строк: первый элемент имеет номер 0, последний доступен как -1. Срез a[начало:конец:шаг] возвращает новый список, конец в него не входит. Найти индекс элемента позволяет метод index, а пересчитать повторы - метод count.
a = [5, 2, 9, 1]
print(a[0], a[-1]) # 5 1
print(a[1:3]) # [2, 9]
print(a[::-1]) # [1, 9, 2, 5]
print(a.index(9)) # 2
print(a.count(2)) # 1
a[1:2] = [20, 21] # замена среза: [5, 20, 21, 9, 1]
del a[0] # удалить элемент по индексу
Обращение к несуществующему индексу, например [1, 2][5], вызывает ошибку IndexError: list index out of range. Срезы ошибки не вызывают: [1, 2, 3][5:] просто вернёт пустой список. Если элемента может не быть, проверяйте его оператором in или длиной списка. С такими же срезами работают строки в Python.
Методы списков: добавить, удалить, найти
Методы списков меняют сам список и обычно возвращают None. Это важная деталь: запись a = a.sort() стирает список, потому что в переменную попадёт None.
| Метод | Что делает | Пример |
|---|---|---|
| append(x) | добавляет элемент в конец | a.append(7) |
| extend(iterable) | добавляет все элементы другого набора | a.extend([3, 4]) |
| insert(i, x) | вставляет элемент на позицию i | a.insert(0, 100) |
| remove(x) | удаляет первое значение x, ошибка ValueError, если его нет | a.remove(9) |
| pop(i) | удаляет элемент по индексу и возвращает его, без аргумента - последний | a.pop() |
| clear() | очищает список | a.clear() |
| index(x) | индекс первого вхождения | a.index(9) |
| count(x) | сколько раз встречается x | a.count(2) |
| sort() | сортирует на месте | a.sort(reverse=True) |
| reverse() | переворачивает порядок на месте | a.reverse() |
| copy() | поверхностная копия | b = a.copy() |
Добавление в список и удаление из него на практике выглядят так. Каждая строка комментария показывает состояние после действия.
a = [5, 2, 9, 1]
a.append(7) # [5, 2, 9, 1, 7]
a.extend([3, 4]) # [5, 2, 9, 1, 7, 3, 4]
a.insert(0, 100) # [100, 5, 2, 9, 1, 7, 3, 4]
print(a.pop()) # 4 - убрали последний
print(a.pop(0)) # 100 - убрали первый
a.remove(9)
print(a) # [5, 2, 1, 7, 3]
Разница между append и extend: первый добавляет один объект, даже если это список, а второй добавляет его элементы по одному. Так a.append([1, 2]) добавит вложенный список, а a.extend([1, 2]) два числа.
Вставка в начало и удаление из начала сдвигают все остальные элементы, поэтому на больших списках они медленные, об этом подробнее в статье про нотацию Big O. Для очереди с частыми операциями с начала берут collections.deque.
Сортировка: sort, sorted и параметр key
Есть два способа. Метод list.sort() сортирует сам список и возвращает None. Функция sorted() принимает любой набор и возвращает новый отсортированный список, оставляя исходный нетронутым. У обоих есть параметры reverse=True для обратного порядка и key - функция, которая получает элемент и возвращает значение для сравнения.
a = [5, 2, 1, 7, 3]
b = sorted(a)
print(b, a) # [1, 2, 3, 5, 7] [5, 2, 1, 7, 3]
a.sort(reverse=True)
print(a) # [7, 5, 3, 2, 1]
w = ["пир", "яблоко", "дыня", "Арбуз"]
print(sorted(w)) # ['Арбуз', 'дыня', 'пир', 'яблоко']
print(sorted(w, key=len)) # ['пир', 'дыня', 'Арбуз', 'яблоко']
people = [{"n": "Ол", "age": 30}, {"n": "Ив", "age": 25}]
print(sorted(people, key=lambda p: p["age"]))
# [{'n': 'Ив', 'age': 25}, {'n': 'Ол', 'age': 30}]
Строки сравниваются по кодам символов, поэтому слова с заглавной буквы встают раньше строчных. Для сортировки без учёта регистра задайте key=str.lower. Список словарей, который часто приходит из JSON, сортируют по значению поля через key с lambda: выражение lambda подробно объяснено в статье про функции в Python. Сортировка стабильна: элементы с равным ключом сохраняют исходный порядок.
Генераторы списков
Генератор списка (list comprehension) собирает новый список одним выражением вместо цикла с append. Общий вид: [выражение for элемент in набор if условие]. Условие необязательное.
print([x * x for x in range(6)]) # [0, 1, 4, 9, 16, 25]
print([x for x in range(10) if x % 2 == 0]) # [0, 2, 4, 6, 8]
print(["чёт" if x % 2 == 0 else "нечёт" for x in range(3)])
# ['чёт', 'нечёт', 'чёт']
matrix = [[1, 2], [3, 4]]
flat = [i for row in matrix for i in row] # [1, 2, 3, 4]
print([[0] * 3 for _ in range(2)]) # [[0, 0, 0], [0, 0, 0]]
Если условие стоит в конце, оно отфильтровывает элементы. Если нужно выбрать между двумя значениями, if ... else ставят в начало выражения. Вложенные циклы читаются слева направо, так же как в обычном коде. Не пытайтесь уместить в одну строку сложную логику: если выражение не читается за пару секунд, вернитесь к обычному циклу for.
Если результат нужен не целиком, а по одному элементу, замените квадратные скобки на круглые и получите генераторное выражение, которое не строит весь список в памяти.
Копирование списков: поверхностное и глубокое
Присваивание b = a не копирует список, а создаёт вторую ссылку на тот же объект. Изменив b, вы изменяете и a. Чтобы получить независимый список, используйте a.copy(), срез a[:] или list(a). Но это поверхностная копия: внутренние вложенные списки остаются общими.

import copy
x = [[1, 2], [3]]
y = x.copy() # поверхностная копия
z = copy.deepcopy(x) # глубокая копия
x[0].append(99)
print(x) # [[1, 2, 99], [3]]
print(y) # [[1, 2, 99], [3]] - вложенный список общий
print(z) # [[1, 2], [3]] - не изменилась
print(x[:] is x, x[:] == x) # False True
Операция is проверяет, что это один и тот же объект, а == сравнивает содержимое. Для списков из чисел и строк достаточно copy(), а если внутри лежат списки, словари или другие изменяемые объекты, нужен copy.deepcopy. Более детально отличия изменяемых и неизменяемых типов разобраны в обзоре множеств, списков и кортежей, а кортежи отдельно в статье про кортежи в Python.
Частые ошибки со списками
Большинство ошибок новичков повторяется. Вот самые частые, с причиной и решением.
a = a.sort()илиa = a.append(1): методы возвращаютNone. Вызывайте их без присваивания.[[0] * 3] * 2: создаёт две ссылки на один внутренний список. Правильно[[0] * 3 for _ in range(2)].IndexError: индекс равен длине списка или больше. Последний индекс равенlen(a) - 1.ValueErrorуremove: значения в списке нет. Проверьтеx in aзаранее.- Удаление элементов во время обхода того же списка: итератор сбивается и часть элементов пропускается.
Последний пункт проверьте на примере. Здесь удаляются чётные числа прямо во время цикла, но не все.
nums = [2, 4, 6, 1]
for n in nums:
if n % 2 == 0:
nums.remove(n)
print(nums) # [4, 1] - четвёрка осталась
nums = [2, 4, 6, 1]
nums = [n for n in nums if n % 2 != 0]
print(nums) # [1]
Безопасный способ - собрать новый список генератором или обходить копию nums[:]. Отдельный частый приём: list(dict.fromkeys(a)) убирает дубликаты и сохраняет порядок, а list(set(a)) тоже убирает повторы, но порядок не гарантирует. Для закрепления решайте задачи на Python: списки встречаются почти в каждой.
Не называйте переменную list: так вы затираете встроенный тип, и вызов list("abc") перестанет работать. Используйте items, values, numbers.
Полезные функции для списков
Кроме методов со списками работают встроенные функции: len, sum, min, max, sorted, reversed, enumerate и zip. Например enumerate(["a", "b"], start=1) даёт пары (1, 'a') и (2, 'b'), а zip([1, 2], "ab") склеивает два набора по парам.
