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

Редактор кода с блоками кода, показывающий использование метода append в Python

Что делает .append() в двух словах

.append(item) — добавляет ровно один объект “item” в конец списка. Если в качестве item передать другой список, кортеж или множество, они будут добавлены как единый элемент (вложенный объект), а не распакованы.

Важно: .append() изменяет существующий список на месте и возвращает None.

Как добавить больше значений в список с помощью append

Ниже показан минимальный пример использования .append():

FirstList = [1, 2, 'MUO']
Item = "Orange"
FirstList.append(Item)
print(FirstList)
# Вывод: [1, 2, 'MUO', 'Orange']

Если добавить сам список как элемент, получится вложенный список:

FirstList = [1, 2, 'MUO']
Item = ["Orange"]
FirstList.append(Item)
print(FirstList)
# Вывод: [1, 2, 'MUO', ['Orange']]

Ещё пример с несколькими элементами в добавляемом списке:

FirstList = [1, 2, 5, 8]
Item = ["Orange", "Shoes", 5, 6]
FirstList.append(Item)
print(FirstList)
# Вывод: [1, 2, 5, 8, ['Orange', 'Shoes', 5, 6]]

И пример с разными типами внутри добавляемого списка:

FirstList = [1, (3, 7)]
Item = [5, {"2", 5}, {"Name":"Idowu"}, "Last item"]
FirstList.append(Item)
print(FirstList)
# Вывод: [1, (3, 7), [5, {'2', 5}, {'Name': 'Idowu'}, 'Last item']]

Можно начать с пустого списка и последовательно наполнять его:

Empty_list = []
New_list = [1, 4, 8, 6]
Empty_list.append(New_list)
print(Empty_list)
# Вывод: [[1, 4, 8, 6]]

Использование append с циклом for

Если нужно добавить по одному элементу из другого итерируемого объекта, используйте цикл for и .append(). Это имитирует поведение .extend(), но позволяет вставлять элементы условно или после преобразования.

Empty_list = []
New_list = [1, 4, 8, 6]
for item in New_list:
    Empty_list.append(item)
print(Empty_list)
# Вывод: [1, 4, 8, 6]

То же самое можно получить через .extend():

Empty_list = []
New_list = [1, 4, 8, 6]
Empty_list.extend(New_list)
print(Empty_list)
# Вывод: [1, 4, 8, 6]

Однако .extend() нельзя использовать, когда вам нужно применять фильтр или вычисление для каждого элемента перед добавлением. Пример: добавить только чётные числа из диапазона:

My_list = [2, 4]
List_to_append = range(6, 20)
for new in List_to_append:
    if new % 2 == 0:
        My_list.append(new)
print(My_list)
# Вывод: [2, 4, 6, 8, 10, 12, 14, 16, 18]

Если попытаться заменить эту логику на .extend(), придётся предварительно собрать результат (например, через генератор), так как .extend() сама по себе не выполняет фильтрацию.

Ещё пример: умножение элементов перед добавлением:

Empty_list = []
List_to_append = range(1, 5)
for new in List_to_append:
    new = new * 3
    Empty_list.append(new)
print(Empty_list)
# Вывод: [3, 6, 9, 12]

Применение append внутри функции

.append() часто используют для аккумулирования результатов внутри функций:

def mat(data):
    lits = [1, 2]
    for datas in data:
        if datas % 2 == 0:
            lits.append(datas)
    return lits

print(mat(range(1, 20)))
# Вывод: [1, 2, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Обратите внимание: исходная функция оставляет начальные элементы [1, 2] и затем добавляет чётные числа из переданного диапазона.

Когда append полезнее extend

Нужна условная фильтрация или преобразование перед добавлением.
Нужно сохранять вложенную структуру (например, список списков).
Требуется добавить объект как единое значение (например, JSON-структуру или кортеж), а не распаковывать его.
Желаемая семантика — “один логический элемент” в списке.

Альтернативы, которые стоит рассмотреть:

.extend(iterable) — распаковывает iterable и добавляет его элементы.
concat = a + b или a += b — создаёт или расширяет списки, но имеет нюансы с производительностью.
list comprehensions — более идиоматично для фильтрации и преобразования: [f(x) for x in source if cond(x)].

Шаблоны и приёмы (playbook)

Построение списка по шагам (аккумулятор): создайте пустой список и append в цикле или функции.
Сбор результатов с фильтрацией: используйте for + if + append.
Сохранение вложенных результатов (например, построчная агрегация): append списков или словарей.
Если нужно распаковать другой список — используйте extend или распаковку: my_list += other_list.

Мини-методология выбора:

Нужен одиночный элемент или логический блок → append.
Нужно добавить много отдельных элементов без обработки → extend.
Нужно получить новый список, избегая мутаций исходного → comprehension или операторы +.

Типичные ошибки и ловушки

Ожидание, что append вернёт новый список: он возвращает None и изменяет список на месте.
Случайное создание вложенных списков при append(list_like).
Использование append внутри глубоко вложенных циклов без оценки сложности O(n) — может быть дорого при больших объёмах.

Важно: если вы хотите избежать побочных эффектов, не модифицируйте список, переданный в функцию — создавайте копию или возвращайте новый список.

Производительность и масштабирование

.append() выполняется за амортизированное O(1) на каждый вызов — в сумме O(n) для n добавлений.
Конкатенация списков через + создаёт новый список и стоит дороже по памяти и времени при большом объёме.
Для очень больших объёмов данных рассматривайте генераторы, массивы numpy или структуры из коллекций(deque) для специфичных операций.

Проверки и тесты (test cases)

При добавлении одиночного элемента длина списка увеличивается на 1.
При append списка результирующий список содержит вложенный список как элемент.
При цикле с фильтром в список попадают только элементы, соответствующие условию.
Проверить, что append возвращает None: assert mylist.append(1) is None.

Чек-листы по ролям

Для джуниор-разработчика:

Проверь, не добавляешь ли ты список как вложенный элемент по ошибке.
Используй list comprehension для простых фильтраций.

Для бэкенд-разработчика:

Оцени масштабы: при миллионах элементов подумай о памяти и скорости.
Если список передаётся между потоками, обеспечь синхронизацию.

Для дата-сайентиста:

Для численных массивов предпочти numpy массивы.
Используй append в pre-processing для гибкости, но заменяй на векторные операции для скорости.

Краткая справочная таблица

Синтаксис: list.append(x)
Возвращаемое значение: None
Модифицирует: исходный список
Поведение при передачи итерируемого: добавляет сам объект как единый элемент

1-line glossary:

append — добавить единичный элемент в конец списка.

Примеры отказов и альтернативы

Когда append “не подойдёт”:

Нужно быстро объединить большие списки — используйте extend или оператор +=.
Требуется избежать мутации исходного списка — используйте выражения и возвращайте новый список.

Примеры альтернатив:

# extend
a = [1]
b = [2, 3]
a.extend(b)  # [1, 2, 3]

# list comprehension
result = [x*3 for x in range(1, 5)]  # [3, 6, 9, 12]

FAQ

В: Чем append отличается от extend? О: append добавляет один объект как элемент; extend распаковывает итерируемый объект и добавляет его элементы по отдельности.

В: Можно ли ускорить множественные добавления? О: Да. Для предварительного размера используйте списковые включения или собирайте элементы в массивы/буферы, затем объединяйте.

Итоги

.append() прост и предсказуем: добавляет ровно один элемент.
Используйте цикл for + append, когда нужно фильтровать или преобразовывать элементы перед добавлением.
Для распаковки коллекций применяйте extend или list comprehension.

Краткое резюме: