Списки в Python (list): методы, срезы, сортировка, append, кортежи и множества

Список в Python (list) — это упорядоченный набор любых значений в квадратных скобках, который можно менять: добавлять элементы в конец, вставлять в середину, удалять, сортировать. Это самая ходовая коллекция языка: строки файла, траты за месяц, ответы API — почти всё начинается со списка. Разберём python list целиком: создание, методы, срезы, сортировку, генераторы списков, копирование, а в конце — кортежи и множества.

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

Список хранит элементы в том порядке, в котором вы их задали, и обращается к ним по индексу с нуля. В одном списке могут лежать значения разных типов, хотя на практике обычно хранят однородные данные.

amounts = [250, 1200, 99]
print(amounts[0])     # 250 — первый элемент
print(amounts[-1])    # 99 — последний
amounts[1] = 1300     # список изменяемый
print(len(amounts))   # 3 — длина списка

Размер списка возвращает функция len(). Обращение к несуществующему индексу даст IndexError: list index out of range.

Создание списка

empty = []                       # пустой список
also_empty = list()              # то же через функцию list
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]

Функция list() превращает в список любой итерируемый объект: строку, range, множество, ключи словаря.

append и другие методы списков

Метод append добавляет один элемент в конец списка — это самый частый метод в Python. Он меняет список на месте и возвращает None.

amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # удалить первое значение 1200
last = amounts.pop()         # 20 — удалить и вернуть последний

Частая ошибка: a.append([10, 20]) добавит один элемент — вложенный список, а не два числа. Для нескольких элементов нужен extend.

Удалить элемент по индексу или целый диапазон можно и оператором del: del a[0], del a[1:3]. Полезные встроенные функции для списков: len, sum, min, max, sorted, reversed, enumerate, zip.

Срезы в Python

Срез берёт часть списка по схеме a[start:stop:step]: от start включительно до stop не включительно с шагом step. Любую часть можно опустить. Срез всегда возвращает новый список.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — первые два
print(a[-2:])     # [4, 5] — последние два
print(a[::2])     # [0, 2, 4] — каждый второй
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — развёрнутый
print(a[:])       # копия всего списка

В отличие от индекса, срез за пределами списка не вызывает ошибку: a[10:20] просто вернёт []. Срезу можно присвоить значение и заменить кусок списка: a[1:3] = ["x", "y", "z"].

Срез строки

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

s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP

Строку срезом изменить нельзя — строки неизменяемы, срез создаёт новую строку.

Сортировка списка: sort и sorted

Это место, где новички путаются чаще всего. Метод sort переставляет элементы в самом списке и возвращает None. Функция sorted не трогает исходный список и возвращает новый отсортированный.

amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — новая копия
print(amounts)             # [250, 1200, 99, 450] — исходный цел

result = amounts.sort()    # сортирует на месте
print(result, amounts)     # None [99, 250, 450, 1200]

Отсюда классическая ошибка «почему у меня None»: a = a.sort() затирает список значением None. Пишите либо a.sort(), либо a = sorted(a).

Ключ и обратный порядок

Оба варианта принимают параметры key и reverse. key — функция, по результату которой сравниваются элементы.

words = ["кофе", "Такси", "абонемент"]
print(sorted(words, key=len))               # ['кофе', 'Такси', 'абонемент']
print(sorted(words, key=str.lower))         # без учёта регистра
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Еда", 650), ("Кино", 120), ("Такси", 300)]
expenses.sort(key=lambda e: e[1])           # по сумме

Сортировка в Python стабильна: элементы с одинаковым ключом сохраняют исходный порядок. Отличие ещё и в применимости: sorted принимает любую последовательность (строку, словарь, множество), а sort есть только у списков.

Перевернуть список

Три способа с разным поведением:

• a.reverse() — разворачивает на месте, возвращает None;
• a[::-1] — новый развёрнутый список;
• reversed(a) — ленивый итератор, удобен в цикле: for x in reversed(a):.

Перебор списка

items = ["кофе", "метро", "кино"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 кофе, 2 метро, 3 кино

print("кино" in items)      # True — проверка вхождения

Не удаляйте элементы из списка, по которому идёт цикл, — часть элементов будет пропущена. Соберите новый список генератором или перебирайте копию a[:].

Генератор списков (list comprehension)

Генератор списков строит новый список одной строкой: выражение, цикл и необязательное условие.

squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" анна ", "олег"]]

Генераторы списков обычно быстрее и читаемее цикла с append. Но если логика не помещается в одну понятную строку, честный цикл лучше.

Объединение, сложение и вычитание списков

a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — новый список
a += b             # как a.extend(b)
print([*a, *b])    # распаковка в новый список

Вычитания списков оператором - нет. Чтобы убрать из одного списка элементы другого, используйте генератор: [x for x in a if x not in set(b)]. Пересечение списков удобнее всего найти через множества: set(a) & set(b) (порядок и дубликаты при этом теряются).

Вложенные и двумерные списки

Список списков — простой способ хранить таблицу или матрицу:

matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # правильно
bad = [[0] * 3] * 2                  # ловушка: две ссылки на один список
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]

Распаковка списка

first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — print списка без скобок

Если число переменных не совпадает с длиной списка, будет ValueError — выручает звёздочка.

Копирование списка

b = a не копирует список, а вешает второй ярлык на тот же объект: изменения через b видны в a. Независимую копию делают явно: a.copy(), list(a) или a[:]. Для вложенных данных этого мало — внутренние списки останутся общими, нужен copy.deepcopy(a).

import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — вложенный список общий
c = copy.deepcopy(a)     # полностью независимая копия

Кортежи: неизменяемый список

Кортеж (tuple) похож на список, но после создания его нельзя изменить. Это честный сигнал читателю: перед вами одна запись из фиксированных полей, а не растущий набор. Кортежи легко распаковываются, и именно ими функции возвращают несколько значений.

expense = (250, "Кофе")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment

Кортеж из неизменяемых значений хешируем, поэтому годится ключом словаря. Кортеж из одного элемента пишется с запятой: (5,).

Множества: только уникальное

Множество (set) хранит только уникальные значения и не помнит порядок. Это самый быстрый способ убрать дубликаты и проверить «есть ли такой элемент», а ещё оно умеет пересечение, объединение и разность.

jan = {"Еда", "Такси", "Кино"}
feb = {"Еда", "Подписки"}
print(jan & feb)    # {'Еда'}
print(feb - jan)    # {'Подписки'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — без дублей, порядок сохранён
empty = set()       # {} — это пустой dict!

Какую коллекцию выбрать

Проверка x in list перебирает элементы по очереди, а x in set работает почти мгновенно. Если в цикле много раз проверяете вхождение в большой список, превратите его во множество.

Итог

Python list — упорядоченная изменяемая коллекция: append и extend добавляют, pop и remove удаляют, срезы a[start:stop:step] берут части, sort сортирует на месте и возвращает None, а sorted отдаёт новый список. Копию делайте явно, для фиксированных записей берите кортеж, для уникальных значений — множество. Списки, кортежи, словари и множества разобраны на практике в курсе «Python 3.15: от новичка до профи».