Метод append() в Python

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

Сегодня мы разбираем одну из связанных с ними тем: как используется функция append() для работы с одной из таких коллекций — списком.

Введение в списки в Python

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

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

Коллекции — разные варианты упорядочивания данных. Кроме списков, есть ещё словари, кортежи, множества.

Что можно сказать про списки:

В Python есть много разных методов для работы со списками. Один из них — функция append(), которую можно использовать для добавления в список новых элементов.

Что делает метод append()

Метод append() в Python добавляет один элемент в список.

Как это работает:

Синтаксис метода append() на примере выглядит так:

# создаём список
elements = [1, 2, 3]

# добавляем новый элемент
elements.append(4)

# проверяем результат
print(elements)

В консоли получаем изменённый список:

[1, 2, 3, 4]

Обратите внимание, что мы не получаем новый список, а меняем уже существующий. Возвращаемое значение метода append() равно None.

Почему метод .append() возвращает None и как это выглядит

Сначала нужно понять, что в программировании означает «возвращать».

Общий смысл в том, что каждое действие подразумевает возвращение какого-то результата: иногда это создание нового объекта, а иногда — результат вычислений. Например, функция может принимать аргументы, что-то делать с ними и возвращать то, что получилось.

Теперь вернёмся к ситуации, когда метод append() возвращает значение None. Так как метод направлен на изменение списков, то None в качестве результата говорит о том, что всё в порядке. Это значит, что метод просто добавил новый элемент, он уже в массиве и больше ничего никому не нужно возвращать. А раз нечего возвращать — получается None.

Например, значение None можно увидеть, если попытаться использовать append() для создания нового списка:

# создаём список
element = [1, 2, 3]

# добавляем новый элемент и создаём новую переменную
insert = element.append(4)

# проверяем результаты
print(insert)
print(element)

Мы создали переменную insert, которой попытались присвоить изменённый список element. Проверяем, что хранится в обеих переменных:

None
[1, 2, 3, 4]

Видно, что мы не получили новый объект — только изменили существующий.

Примеры использования метода append()

Вот несколько самых популярных примеров использования этой функции-метода.

Добавление новых элементов в список

Append() добавляет в список один элемент в конец. Если мы попробуем добавить в список несколько элементов, то получим ошибку.

Такой код

# создаём список
item = [1, 2, 3]

# добавляем новый элемент
item = item.append(4, 5, 6)

# проверяем результат
print(item)

приведёт к ошибке:

TypeError: list.append() takes exactly one argument (3 given)

Можно положить несколько элементов в отдельный список и добавить его в существующий:

# создаём список
item = [1, 2, 3]

# создаём ещё один список
end = (4, 5, 6)

# добавляем новый список в первый
item.append(end)

# проверяем результат
print(item)

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

[1, 2, 3, (4, 5, 6)]

Добавлять несколько элементов в список всё-таки можно — для этого используют метод extend(). О нём тоже расскажем, но чуть ниже.

Создание списка через цикл с использованием метода append()

Это удобный способ автоматизации создания списка. Ещё получение списка через цикл позволяет создавать его динамически, когда мы заранее не знаем, сколько элементов потребуется. 

Вот пример с автоматическим наполнением изначально пустого списка квадратов чисел:

# создаём пустой список
squares = []

# создаём цикл для заполнения списка
for i in range(1, 6):
   # добавляем в список квадраты от 1 до 6
   squares.append(i ** 2)

# проверяем результат
print(squares)

В консоли получаем список квадратов чисел от 1 до 6:

[1, 4, 9, 16, 25]

Добавление вложенных списков

Иногда может быть полезно сохранять элементы по группам. Тогда можно использовать вложенные списки. Например, нам нужно сохранить список имён сотрудников компании по группам, и все эти группы будут храниться в одном общем списке.

Так это будет выглядеть в коде, если добавить в первый список второй:

# создаём первый список
nested_list = [1, 2]

# добавляем в первый список второй список
nested_list.append([3, 4])

# проверяем результат
print(nested_list)

Получился вложенный список с группой из чисел 3 и 4:

[1, 2, [3, 4]]

Добавление элемента только при выполнении условия

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

Простой пример подобной логики — когда мы добавляем в список только чётные числа:

# создаём пустой список
filtered_list = []

# создаём цикл и проверяем числа от 0 до 9
for num in range(10):
   # если число чётное...
   if num % 2 == 0:
       # добавляем его в список
       filtered_list.append(num)

# проверяем результат
print(filtered_list)

Получаем:

[0, 2, 4, 6, 8]

Конкатенация списков с использованием метода append()

Конкатенация — это по-программистски «объединение». Если при работе у вас получается несколько списков, их можно сохранить в одном объекте несколькими способами. Если все элементы нужно объединить как единый список, все элементы одного списка можно добавить в другой через цикл:

# создаём первый список
list1 = [1, 2]
# создаём второй список
list2 = [3, 4]

# создаём цикл
for item in list2:
   # добавляем второй список в первый поэлементно
   list1.append(item)

# проверяем результат
print(list1)

Получаем один упорядоченный список:

[1, 2, 3, 4]

Второй вариант — добавить список целиком, чтобы он сохранился отдельной группой, то есть как вложенный:

# создаём первый список
list1 = [1, 2]
# создаём второй список
list2 = [3, 4]

# добавляем весь список как один элемент
list1.append(list2)

# проверяем результат
print(list1)

Второй список добавился как отдельный:

[1, 2, [3, 4]]

Отличие метода append() от других методов

Append() не единственный способ добавления элементов в список. Вот ещё два.

Разница между append() и extend()

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

# создаём первый список
list1 = [1, 2, 3]

# передаём несколько элементов в extend как один список
list1.extend([4, 5])

# проверяем результат
print(list1)

При запуске кода видно, что элементы добавились по отдельности:

[1, 2, 3, 4, 5]

Разница между append() и insert()

Append() умеет добавлять элементы только в конец списка. Insert() позволяет поставить элемент на конкретную позицию, для этого нужно указать индекс.

Добавим элемент на второе место:

# создаём список
list1 = [1, 2, 3]

# добавляем число 99 на индекс 1 — это вторая позиция в списке
list1.insert(1, 99)

# проверяем результат
print(list1)

Запускаем код:

[1, 99, 2, 3]

Срез

В Python есть метод работы со списками, который делает то же самое, что команда append(), — это срез списка.

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

Правила синтаксиса для среза такие:

list[start:stop:step]

Что есть что:

Допустим, у нас есть список:

# создаём список
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Мы хотим взять срез элементов со 2-го по 9-й. При этом мы хотим получить только чётные элементы, поэтому выставляем шаг на 2:

# берём элементы со второго по девятый с шагом 2
use = my_list[1:8:2]

Командой print() смотрим, что получилось:

# проверяем результат
print(use)

В консоли получаем срез:

[2, 4, 6, 8]

👉 Срез возвращает не None, а новый объект. Изначальный список остаётся неизменным.

Использование метода append() в других структурах данных

Метод append() встречается не только в списках, но и в других структурах данных Python, например массивах и двусторонних очередях.

Array.append() используется для массива. 

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

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

import array

При создании нового массива нужно указать тип его данных и список элементов. Например, тип 'i' означает целые числа:

arr = array.array('i', [1, 2, 3])

Добавляем новое число в конец:

arr.append(4)

Запускаем код и видим в консоли изменённый массив:

array('i', [1, 2, 3, 4])

Deque.append() и deque.appendleft() добавляют элементы в двустороннюю очередь deque. Эта коллекция может принимать и удалять элементы как с начала, так и с конца. 

Deque — часть модуля collections. Для работы с очередью её нужно импортировать:

from collections import deque

Создание очереди похоже на создание списка или массива. При объявлении переменной и сохранении в ней объекта очереди нужно использовать ключевое слово deque. Создадим двустороннюю очередь из трёх элементов:

dq = deque([1, 2, 3])

Чтобы добавить элемент в конец очереди, нужен метод append():

dq.append(4)

При выводе списка получаем:

[1, 2, 3, 4]

Добавить новый элемент в начало deque можно командой appendleft(): 

dq.appendleft(0)

Результат:

[0, 1, 2, 3, 4]

Заключение и советы по использованию метода append()

Метод append() удобен, если вам нужно добавлять в списки, массивы и очереди по одному элементу или вам подходит создание вложенных списков. Если нужно добавить сразу несколько элементов, на помощь стоит позвать другой метод — extend().

В остальном всё зависит от задач. Например, append() не будет работать при добавлении элементов в начало коллекций или для объединения нескольких больших списков, зато может использоваться для динамического создания списков в сочетании с циклами.