Списки в Python (list): методы и примеры

Список в Python (list) — упорядоченная изменяемая коллекция любых объектов. Короткий ответ: список создаётся квадратными скобками numbers = [3, 1, 2], элемент читается по индексу numbers[0], добавляется методом numbers.append(4), а количество элементов возвращает len(numbers).

В статье — все основные операции со списками: индексы и срезы, методы добавления и удаления, сортировка, копирование, вложенные списки и вывод на экран. Отдельно разберём, чем list отличается от «массива». Примеры проверены на Python 3.12, вывод показан комментарием # →.

Списки и массивы в Python: в чём разница

В Python нет встроенного типа «массив» в том виде, как в C или Java. Когда говорят «массивы в Python», обычно имеют в виду одно из трёх:

Тип	Где взять	Особенности
list	встроенный	любые типы вперемешку, меняет размер, основной выбор почти всегда
array.array	стандартный модуль array	элементы одного базового типа (числа), компактнее в памяти
numpy.ndarray	библиотека NumPy	многомерные массивы и быстрые векторные вычисления

from array import array

nums = array("i", [1, 2, 3])  # "i" — целые числа со знаком
nums.append(4)
print(nums)  # → array('i', [1, 2, 3, 4])

NumPy нужен для математики над большими объёмами чисел: операции применяются сразу ко всему массиву, без цикла.

import numpy as np

a = np.array([1, 2, 3])
print(a * 2)       # → [2 4 6]
print([1, 2, 3] * 2)  # → [1, 2, 3, 1, 2, 3]

Умножение списка на число повторяет список, элементы при этом не умножаются. NumPy ставится отдельно (pip install numpy) — о других библиотеках читайте в обзоре библиотек Python. Дальше речь только о встроенном list.

Как создать список

empty = []
numbers = [1, 2, 3, 4, 5]
mixed = [1, "два", 3.0, True, None]   # разные типы — допустимо
letters = list("abc")
print(letters)              # → ['a', 'b', 'c']
print(list(range(1, 6)))    # → [1, 2, 3, 4, 5]
print([0] * 3)              # → [0, 0, 0]

Список чисел из строки

Частая задача — получить список чисел из введённой строки. Строку делят методом split, а каждую часть превращают в число через map:

line = "10 20 30"
numbers = list(map(int, line.split()))
print(numbers)  # → [10, 20, 30]
print(sum(numbers), min(numbers), max(numbers))  # → 60 10 30
print(sum(numbers) / len(numbers))  # → 20.0

Индексы и срезы

Индексы начинаются с нуля; отрицательные индексы считают с конца.

langs = ["Python", "Go", "Rust", "Java", "C"]
print(langs[0])     # → Python
print(langs[-1])    # → C
print(langs[1:3])   # → ['Go', 'Rust']
print(langs[:2])    # → ['Python', 'Go']
print(langs[2:])    # → ['Rust', 'Java', 'C']
print(langs[::2])   # → ['Python', 'Rust', 'C']
print(langs[::-1])  # → ['C', 'Java', 'Rust', 'Go', 'Python']

Срез [start:stop:step] не включает stop и всегда возвращает новый список. Обращение к несуществующему индексу вызывает ошибку, а срез за границами — нет:

langs = ["Python", "Go"]
print(langs[1:10])  # → ['Go']
langs[5]  # → IndexError: list index out of range

Элемент меняют присваиванием по индексу: langs[0] = "Python 3".

Добавление элементов: append, insert, extend

items = [1, 2]
items.append(3)          # в конец один элемент
items.insert(0, 0)       # по индексу
items.extend([4, 5])     # все элементы другого списка
print(items)  # → [0, 1, 2, 3, 4, 5]

items.append([6, 7])     # append добавит список целиком
print(items)  # → [0, 1, 2, 3, 4, 5, [6, 7]]

append добавляет один объект, extend — каждый элемент итерируемого объекта. Склеить два списка в новый можно и оператором +: [1, 2] + [3].

Удаление: remove, pop, del, clear

items = ["a", "b", "c", "d", "b"]
items.remove("b")     # первое вхождение по значению
print(items)  # → ['a', 'c', 'd', 'b']
last = items.pop()    # удалить и вернуть последний
first = items.pop(0)  # удалить и вернуть по индексу
print(last, first, items)  # → b a ['c', 'd']
del items[0]          # удалить по индексу (или срез: del items[1:3])
print(items)  # → ['d']
items.clear()
print(items)  # → []

remove() вызывает ValueError, если значения нет в списке, а pop() у пустого списка — IndexError.

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

Метод sort() сортирует список на месте и возвращает None. Функция sorted() не трогает исходный список и возвращает новый:

nums = [5, 2, 9, 1]
print(sorted(nums))  # → [1, 2, 5, 9]
print(nums)          # → [5, 2, 9, 1]

nums.sort(reverse=True)
print(nums)          # → [9, 5, 2, 1]

words = ["banana", "kiwi", "Apple"]
print(sorted(words))                 # → ['Apple', 'banana', 'kiwi']
print(sorted(words, key=len))        # → ['kiwi', 'Apple', 'banana']
print(sorted(words, key=str.lower, reverse=True))  # → ['kiwi', 'banana', 'Apple']

Параметр key принимает функцию, по результату которой сравниваются элементы. Заглавные буквы по умолчанию идут раньше строчных, поэтому для сортировки без учёта регистра передают key=str.lower. Так же сортируют список словарей по нужному полю.

Разворот списка

items.reverse() разворачивает список на месте, items[::-1] возвращает развёрнутую копию, а reversed(items) — итератор для цикла.

Поиск и подсчёт: in, len, count, index

colors = ["red", "green", "blue", "green"]
print(len(colors))            # → 4
print("blue" in colors)       # → True
print(colors.count("green"))  # → 2
print(colors.index("green"))  # → 1

index() возвращает позицию первого вхождения и бросает ValueError, если элемента нет. Поэтому сначала проверяйте in.

Методы списка Python: шпаргалка

Метод / функция	Что делает	Возвращает
a.append(x)	добавляет x в конец	None
a.insert(i, x)	вставляет x перед индексом i	None
a.extend(iterable)	добавляет все элементы	None
a.remove(x)	удаляет первое вхождение x	None
a.pop(i)	удаляет элемент (по умолчанию последний)	элемент
a.clear()	очищает список	None
a.index(x)	индекс первого вхождения	int
a.count(x)	число вхождений	int
a.sort(key=..., reverse=...)	сортирует на месте	None
a.reverse()	разворачивает на месте	None
a.copy()	поверхностная копия	новый список
len(a), sum(a), min(a), max(a)	длина, сумма, минимум, максимум	число / элемент
sorted(a)	отсортированная копия	новый список

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

Новый список из существующего удобно собирать одной строкой:

nums = [1, 2, 3, 4, 5, 6]
squares = [n * n for n in nums]
evens = [n for n in nums if n % 2 == 0]
labels = ["чёт" if n % 2 == 0 else "нечет" for n in nums[:3]]
print(squares)  # → [1, 4, 9, 16, 25, 36]
print(evens)    # → [2, 4, 6]
print(labels)   # → ['нечет', 'чёт', 'нечет']

Это короче и обычно быстрее, чем цикл с append. Если выражение не помещается в строку, лучше вернуться к обычному циклу.

Копирование и ловушка ссылок

Присваивание не копирует список — обе переменные указывают на один объект:

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # → [1, 2, 3, 4]

c = a.copy()   # или a[:] или list(a)
c.append(5)
print(a)  # → [1, 2, 3, 4]
print(c)  # → [1, 2, 3, 4, 5]

copy() делает поверхностную копию: вложенные списки остаются общими. Для полной копии используйте copy.deepcopy():

import copy

matrix = [[1, 2], [3, 4]]
shallow = matrix.copy()
deep = copy.deepcopy(matrix)
matrix[0][0] = 99
print(shallow[0][0], deep[0][0])  # → 99 1

Вложенные списки

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

matrix = [
    [1, 2, 3],
    [4, 5, 6],
]
print(matrix[1][2])  # → 6
print([row[0] for row in matrix])  # → [1, 4]
print([x for row in matrix for x in row])  # → [1, 2, 3, 4, 5, 6]

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

bad = [[0] * 3] * 2           # две ссылки на ОДИН внутренний список
bad[0][0] = 1
print(bad)  # → [[1, 0, 0], [1, 0, 0]]

good = [[0] * 3 for _ in range(2)]
good[0][0] = 1
print(good)  # → [[1, 0, 0], [0, 0, 0]]

Как вывести список

fruits = ["яблоко", "груша", "слива"]
print(fruits)              # → ['яблоко', 'груша', 'слива']
print(*fruits)             # → яблоко груша слива
print(*fruits, sep=", ")   # → яблоко, груша, слива
print(", ".join(fruits))   # → яблоко, груша, слива
print(" ".join(map(str, [1, 2, 3])))  # → 1 2 3

print(*fruits) распаковывает список в отдельные аргументы. Метод join работает только со строками — числа сначала превращают в строки, подробности в статье про join. Вывести элементы с номерами помогает enumerate:

fruits = ["яблоко", "груша", "слива"]
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

1. яблоко
2. груша
3. слива

Список файлов в папке

Ещё одна частая задача — получить список файлов. Это делает модуль pathlib:

from pathlib import Path

files = [p.name for p in Path(".").iterdir() if p.is_file()]
py_files = sorted(p.name for p in Path(".").glob("*.py"))

iterdir() перебирает содержимое папки, glob("*.py") — файлы по шаблону (rglob ищет и во вложенных папках). Старый вариант — os.listdir("."), он возвращает имена и файлов, и папок.

Частые ошибки

sort() вернул None

nums = [3, 1, 2]
result = nums.sort()
print(result)  # → None

sort() меняет сам список. Нужна отсортированная копия — используйте sorted(nums).

Удаление элементов во время обхода

nums = [1, 2, 2, 3]
for n in nums:
    if n == 2:
        nums.remove(n)
print(nums)  # → [1, 2, 3]

Одна двойка осталась: после удаления элементы сдвигаются, и цикл пропускает следующий. Собирайте новый список: nums = [n for n in nums if n != 2].

extend со строкой

tags = ["python"]
tags.extend("django")
print(tags)  # → ['python', 'd', 'j', 'a', 'n', 'g', 'o']

Строка итерируется по символам. Для одной строки нужен append("django").

IndexError: list index out of range

Индекс вышел за пределы списка: у списка из трёх элементов последний индекс — 2, а не 3. Для последнего элемента используйте a[-1], а перебирайте элементы циклом for x in a, а не по range(len(a) + 1). Как читать такие сообщения, разобрано в статье об ошибках и traceback.

Частые вопросы

Как проверить, что список пустой?

Пустой список в условии считается ложным, поэтому достаточно if not items:. Проверка len(items) == 0 работает так же, но длиннее.

items = []
if not items:
    print("список пуст")  # → список пуст

Как удалить дубликаты и сохранить порядок элементов?

Словарь хранит ключи в порядке добавления, поэтому dict.fromkeys() убирает повторы без перемешивания. Вариант list(set(items)) тоже удаляет дубликаты, но порядок не гарантирует — подробнее в статье про множества.

tags = ["python", "django", "python", "api", "django"]
print(list(dict.fromkeys(tags)))  # → ['python', 'django', 'api']

Как найти индекс максимального элемента?

Сначала найдите максимум, затем его позицию: nums.index(max(nums)). При повторах вернётся индекс первого вхождения.

nums = [4, 9, 2, 9]
print(nums.index(max(nums)))  # → 1

Как сравнить два списка без учёта порядка?

Оператор == сравнивает списки поэлементно с учётом порядка. Если порядок не важен, сравнивают отсортированные копии; set() подходит, только когда повторы не имеют значения.

a, b = [1, 2, 2], [2, 1, 2]
print(a == b)                  # → False
print(sorted(a) == sorted(b))  # → True

Как выбрать случайный элемент или перемешать список?

random.choice(items) возвращает случайный элемент, random.shuffle(items) перемешивает список на месте и возвращает None. Другие функции модуля разобраны в статье про random.

Чем список отличается от кортежа?

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

Итог

Список — основная коллекция Python: добавляйте элементы через append/extend, сортируйте sorted() или sort(), копируйте через copy() и помните, что присваивание копию не создаёт. Для пар «ключ — значение» берите словари, а общую картину языка смотрите в шпаргалке по синтаксису Python.