Python's .append(): Добавляйте элементы в свои списки на месте

>>> numbers = [1, 2, 3]
>>> numbers.append(4)
>>> numbers
[1, 2, 3, 4]


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

 Списки Python резервируют дополнительное пространство для новых элементов в конце списка. Вызов .append() приведет к размещению новых элементов в доступном пространстве.
На практике вы можете использовать .append() для добавления любого объекта в заданный список:

>>> mixed = [1, 2]

>>> mixed.append(3)
>>> mixed
[1, 2, 3]

>>> mixed.append("four")
>>> mixed
[1, 2, 3, 'four']

>>> mixed.append(5.0)
>>> mixed
[1, 2, 3, 'four', 5.0]


Списки - это последовательности, которые могут содержать различные типы данных и объекты Python, поэтому вы можете использовать .append() для добавления любого объекта в данный список. В этом примере сначала добавляется целое число, затем строка и, наконец, число с плавающей запятой. Однако вы также можете добавить другой список, словарь , кортеж,     пользовательский объект и так далее.
Использование .append() эквивалентно следующей операции:

>>> numbers = [1, 2, 3]

>>> # Equivalent to numbers.append(4)
>>> numbers[len(numbers):] = [4]
>>> numbers
[1, 2, 3, 4]


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

Вы берете фрагмент из numbers, используя выражение numbers[len(numbers):].
, и присваиваете этому фрагменту повторяемость.

Операция нарезки занимает пробел после последнего элемента в numbers. Тем временем операция присваивания  распаковывает элементы в списке справа от  оператора присваивания и добавляет их в numbers. Однако есть важное различие между использованием такого рода заданий и использованием .append(). С помощью этого задания вы можете добавить в конец своего списка сразу несколько элементов:

>>> numbers = [1, 2, 3]

>>> numbers[len(numbers):] = [4, 5, 6]
>>> numbers
[1, 2, 3, 4, 5, 6]


В этом примере выделенная строка берет фрагмент из конца numbers, распаковывает элементы в списке справа и добавляет их в фрагмент как отдельные элементы.
.append() Добавляет один элемент
 С помощью .append() вы можете добавить число, список, кортеж, словарь, пользовательский объект или любой другой объект в существующий список. Однако вам нужно иметь в виду, что .append() одновременно добавляет только один элемент или объект:

>>> x = [1, 2, 3, 4]
>>> y = (5, 6)

>>> x.append(y)
>>> x
[1, 2, 3, 4, (5, 6)]


Здесь происходит следующее: .append() добавляет объект кортежа y в конец вашего целевого списка, x. Что, если вы хотите добавить каждый элемент из y в конец x как отдельный элемент и получить [1, 2, 3, 4, 5, 6]? В этом случае вы можете использовать .extend():

>>> x = [1, 2, 3, 4]
>>> y = (5, 6, 7)
>>> x.extend(y)
>>> x
[1, 2, 3, 4, 5, 6, 7]

>>> x = [1, 2, 3, 4]
>>> y = (5, 6, 7)
>>> # Equivalent to x.extend(y)
>>> x[len(x):] = y
>>> x
[1, 2, 3, 4, 5, 6, 7]


.extend() принимает iterable в качестве аргумента, распаковывает его элементы и добавляет их в конец вашего целевого списка. Эта операция эквивалентна x[len(x):] = y, которая представляет собой ту же технику, которую вы видели в предыдущем разделе.
.append() Возвращает None
На практике .append() выполняет свою работу на месте, изменяя и расширяя базовый список. Это означает, что .append() не возвращает  новый список с дополнительным новым элементом в конце. Он возвращается None:

>>> x = [1, 2, 3, 4]
>>> y = x.append(5)
>>> y is None
True
>>> x
[1, 2, 3, 4, 5]


Как и в случае с несколькими аналогичными методами, .append() изменяет базовый список на месте. Попытка использовать возвращаемое значение .append() является распространенной ошибкой, когда речь заходит о изучении того, как работают изменяемые типы последовательностей. Если вы будете помнить об этом поведении .append(), это поможет вам предотвратить ошибки в вашем коде.
Заполнение списка с нуля
Распространенная проблема, с которой вы можете столкнуться при работе со списками в Python, заключается в том, как заполнить их несколькими элементами для дальнейшей обработки. Для этого есть два способа:

Используйте .append() и for цикл
Используйте понимание списка

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

>>> import math

>>> def square_root(numbers):
...     result = []
...     for number in numbers:
...         result.append(math.sqrt(number))
...     return result
...

>>> numbers = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> square_root(numbers)
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]


Здесь вы определяете square_root(), который принимает список numbers в качестве аргумента. Внутри square_root() вы создаете пустой список с именем result и запускаете цикл for, который повторяет элементы в numbers. На каждой итерации вы используете math.sqrt() для вычисления квадратного корня из текущего числа, а затем используете .append(), чтобы добавить результат к result. Как только цикл завершится, вы вернете результирующий список.
 Примечание: В приведенном выше примере вы используете sqrt() из math. Модуль Python math поставляется в стандартной библиотеке  и предоставляет   функции, связанные с математикой. Если вы хотите глубже погрузиться в math, ознакомьтесь с Математическим модулем Python: все, что вам нужно знать.
Этот способ заполнения списков довольно распространен в Python. Однако язык предоставляет несколько удобных конструкций, которые могут сделать этот процесс намного более эффективным и питоническим. Одной из таких конструкций является понимание списка, которое вы увидите в действии в следующем разделе.
Использование понимания списка
На практике при создании списка с нуля и его заполнении вы часто заменяете .append() на  понимание списка. Разобравшись со списком, вы можете переопределить square_root() следующим образом:

>>> import math

>>> def square_root(numbers):
...     return [math.sqrt(number) for number in numbers]
...

>>> numbers = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> square_root(numbers)
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]


При составлении списка внутри square_root() создается список, содержащий квадратный корень из number для каждого number в numbers. Это читается почти как обычный английский. Кроме того, эта новая реализация будет более эффективной с точки зрения времени обработки, чем реализация, использующая .append() вместе с for циклом.
 Примечание: Python также предлагает другие виды выражений, такие как  выражения для набора,  словарные выражения и выражения-генераторы.
Чтобы превратить .append() в понятный список, вам просто нужно поместить его аргумент, за которым следует заголовок цикла (без двоеточия), в пару квадратных скобок.
Переключение обратно в режим .append()
Несмотря на то, что использование списков может быть более удобным и эффективным, чем .append() для заполнения списков, могут возникнуть ситуации, когда .append() является лучшим выбором.
Предположим, вам нужно square_root() предоставить вашим пользователям подробную информацию о ходе вычисления квадратного корня из введенного списка чисел. Чтобы сообщить о ходе выполнения операции, вы можете использовать print():

>>> import math

>>> def square_root(numbers):
...     result = []
...     n = len(numbers)
...     for i, number in enumerate(numbers):
...         print(f"Processing number: {number}")
...         result.append(math.sqrt(number))
...         print(f"Completed: {int((i + 1) / n * 100)}%")
...     return result
...

>>> numbers = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> square_root(numbers)
Processing number: 1
Completed: 11%
...
Processing number: 81
Completed: 100%
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]


Теперь подумайте, как вы можете преобразовать текст square_root() в понятный список. Использование print() внутри понятного списка не кажется логичным или даже возможным, если вы не заключите часть кода во вспомогательную функцию. Итак, в этом примере использование .append() является правильным выбором.
Мораль приведенного выше примера заключается в том, что в некоторых ситуациях вы не можете заменить .append() на понимание списка или на любую другую конструкцию.
Создание стеков и очередей с помощью Python .append()
Итак, вы узнали, как использовать .append() для добавления отдельного элемента в список или для заполнения списков с нуля. Теперь пришло время для другого, более конкретного примера. В этом разделе вы узнаете, как использовать список Python для создания стековых и очередных структур данных с минимально необходимой функциональностью, используя .append() и .pop().
Реализация стека
Стек - это структура данных, в которой элементы хранятся друг над другом. Элементы поступают в стопку и извлекаются из нее в порядке Последний вход /Первый выход. ( ЛИФО) мода. Как правило, стек реализует две основные операции:

push добавляет элемент в начало или конец стека.
pop удаляет и возвращает элемент, находящийся в верхней части стека.

В списке .append() эквивалентно операции push, поэтому вы можете использовать ее для перемещения элементов в стек. Списки также содержат .pop(), который необязательно принимает в качестве аргумента целочисленный индекс. Он возвращает элемент с таким индексом в базовом списке, а также удаляет элемент:

>>> numbers = [1, 2, 3]
>>> numbers.pop(1)
2
>>> numbers
[1, 3]

>>> numbers.pop()
3
>>> numbers
[1]

>>> numbers.pop()
1
>>> numbers
[]

>>> numbers.pop()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    numbers.pop()
IndexError: pop from empty list


Если вы укажете целочисленный индекс в качестве аргумента для .pop(), то метод вернет и удалит элемент с этим индексом в списке. Вызов .pop() без аргумента возвращает последний элемент в списке. Обратите внимание, что .pop() также удаляет элемент из основного списка. Наконец, если вы вызовете .pop() в пустом списке, то получите IndexError.
Обладая этими знаниями, вы готовы реализовать стек, используя .append() и .pop(). Вот класс, который определяет стек. Класс предоставляет .push() и .pop() операции:

class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        try:
            return self._items.pop()
        except IndexError:
            print("Empty stack")

    def __len__(self):
        return len(self._items)

    def __repr__(self):
        return f"Stack({self._items})"


В Stack сначала вы инициализируете атрибут экземпляра  ._items. Этот атрибут содержит пустой список, который вы будете использовать для хранения элементов в стеке. Затем вы создаете код .push(), который реализует операцию push, используя .append() на ._items.
Вы также реализуете операцию pop, вызывая .pop() в базовом списке, ._items. В этом случае вы используете try и except блок для обработки IndexError, который возникает при вызове .pop() в пустом списке.
 Примечание: В Python использование исключений для управления потоком выполнения программы является распространенным шаблоном. Разработчики Python предпочитают этот стиль программирования, известный как EAFP (Легче попросить прощения, чем разрешения), стилю программирования, известному как LBYL (Посмотри, прежде чем прыгать). Чтобы узнать больше об этих двух стилях программирования, ознакомьтесь с LBYL vs EAFP: Предотвращение или обработка ошибок в Python.
EAFP может помочь вам предотвратить сбои в работе, повысить общую производительность программы или фрагмента кода и предотвратить передачу ошибок без предупреждения.
Здесь вы можете воспользоваться несколькими специальными методами. Специальный метод .__len__() предоставляет необходимую функциональность для получения длины внутреннего списка ._items. Специальный метод .__repr__() позволяет обеспечить удобное для пользователя строковое представление стека при выводе структуры данных на экран.
Вот несколько примеров того, как вы можете использовать Stack на практике:

>>> stack = Stack()

>>> # Push items onto the top of the stack
>>> stack.push(1)
>>> stack.push(2)

>>> # User-friendly printing format
>>> stack
Stack([1, 2])
>>> print(stack)
Stack([1, 2])

>>> # Retrieve the length of the stack
>>> len(stack)
2

>>> # Pop items from the top of the stack
>>> stack.pop()
2
>>> stack.pop()
1
>>> stack.pop()
Empty stack
>>> stack
Stack([])


Вот и все! Вы закодировали структуру стековых данных, которая реализует операции push и pop. Он также предоставляет функциональные возможности для получения длины базового списка и удобной для пользователя печати всей стопки.
Реализация очереди
 Очереди - это структуры данных, которые обычно управляют своими элементами по принципу Первый вход/первый выход (FIFO). Очереди работают как труба, в которую вы вставляете новые элементы с одного конца, а старые элементы выскакивают с другого конца.
Добавление элемента в конец очереди называется операцией enqueue, а удаление элемента из начала очереди называется операцией a dequeue.
Вы можете помещать элементы в очередь, используя .append(), и выводить их из очереди, используя .pop(). На этот раз вам нужно указать 0 в качестве аргумента для .pop() просто для того, чтобы он извлекал первый элемент в списке вместо последнего элемента. Вот класс, который реализует структуру данных очереди, используя список для хранения своих элементов:

class Queue:
    def __init__(self):
        self._items = []

    def enqueue(self, item):
        self._items.append(item)

    def dequeue(self):
        try:
            return self._items.pop(0)
        except IndexError:
            print("Empty queue")

    def __len__(self):
        return len(self._items)

    def __repr__(self):
        return f"Queue({self._items})"


Этот класс очень похож на ваш Stack. Основное отличие заключается в том, что .pop() принимает 0 в качестве аргумента для возврата и удаляет  первый элемент в базовом списке, ._items, а не предыдущий. последний.
 Примечание: Использование .pop(0) в списке Python - не самый эффективный способ использования элементов списка. К счастью, модуль Python collections предоставляет структуру данных под названием deque(),, которая реализует .popleft() как эффективный способ использования элементов с самого начала процесса. deque().
Вы узнаете больше об использовании deques чуть позже в этом руководстве.
Остальная часть реализации практически идентична, но использует соответствующие имена, такие как .enqueue() для добавления элементов и .dequeue() для их удаления. Вы можете использовать Queue так же, как вы использовали Stack в предыдущем разделе: просто вызовите .enqueue() для добавления элементов и .dequeue() для их извлечения и удаления.
Использование .append() в других структурах данных
Другие структуры данных Python также реализуют .append(). Принцип работы такой же, как и у традиционного .append() в виде списка. Метод добавляет один элемент в конец базовой структуры данных. Однако есть некоторые тонкие различия.
В следующих двух разделах вы узнаете, как .append() работает в других структурах данных, таких как array.array() и collections.deque().
array.append()
Python array.array() предоставляет структуру данных, подобную последовательности, которая может компактно представлять массив значений. Эти значения должны быть одного и того же типа данных , который ограничен типами данных в стиле C, такими как символы, целые числа и числа с плавающей запятой.
array.array() принимает следующие два аргумента:



Argument
Content
Required




typecode
A single-character code that identifies the data type that the array can store
Yes


initializer
A list, bytes-like object, or iterable that serves as an initializer
No



Документация по  array содержит полную информацию обо всех допустимых кодах типов, которые вы можете использовать при создании массивов. В следующем примере используется код типа "i" для создания массива целых чисел:

>>> from array import array

>>> # Array of integer numbers
>>> int_array = array("i", [1, 2, 3])
>>> int_array
array('i', [1, 2, 3])
>>> int_array[0]
1
>>> int_array[:2]
array('i', [1, 2])
>>> int_array[2] = 4
>>> int_array
array('i', [1, 2, 4])


Чтобы создать массив, вам необходимо ввести односимвольный код для определения типа данных значений в массиве. Вы также можете указать необязательный список значений с соответствующим типом для инициализации массива.
Массивы поддерживают большинство операций со списками, таких как нарезка и индексация. Как и lists, array.array() также предоставляет метод с именем .append(). Этот метод работает аналогично своему аналогу list, добавляя единственное значение в конец базового массива. Однако значение должно иметь тип данных, совместимый с существующими значениями в массиве. В противном случае вы получите TypeError.
Например, если у вас есть массив с целыми числами, то вы не можете использовать .append() для добавления к этому массиву числа с плавающей запятой:

>>> from array import array

>>> a = array("i", [1, 2, 3])
>>> a
array('i', [1, 2, 3])

>>> # Add a floating-point number
>>> a.append(1.5)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    a.append(1.5)
TypeError: integer argument expected, got float


Если вы попытаетесь добавить число с плавающей запятой к a, то .append() завершится ошибкой с TypeError. Это связано с тем, что Python не может автоматически преобразовать число с плавающей запятой в целое число без потери информации.
Напротив, если у вас есть массив с числами с плавающей запятой и вы попытаетесь добавить к нему целые числа, то ваша операция завершится успешно:

>>> from array import array

>>> float_array = array("f", [1.0, 2.0, 3.0])
>>> float_array
array('f', [1.0, 2.0, 3.0])

>>> # Add and integer number
>>> float_array.append(4)
>>> float_array
array('f', [1.0, 2.0, 3.0, 4.0])


Здесь вы используете .append() для добавления целого числа к массиву чисел с плавающей запятой. Это возможно, потому что Python может автоматически преобразовывать целые числа в числа с плавающей запятой без потери информации в процессе.
deque.append() и deque.appendleft()
collections.deque() это еще одна структура данных, которая реализует вариацию .append(). A deque представляет собой обобщение стека и очереди, специально разработанных для поддержки быстрых и экономичных с точки зрения памяти операций append и pop с обеих сторон. Поэтому, если вам нужно создать структуру данных с этими функциями, рассмотрите возможность использования deque вместо списка.
 Примечание: Название deque произносится как “палуба” и расшифровывается как dрезультат-енайдено чтои т.д.
collections.deque() принимает следующие два необязательных аргумента:



Argument
Content




iterable
An iterable that serves as an initializer


maxlen
An integer number that specifies the maximum length of the deque



Если вы укажете значение maxlen, то в вашем deque будет храниться только maxlen элементов. Как только список будет заполнен, добавление нового товара автоматически приведет к тому, что товар, находящийся на противоположном конце списка, будет отброшен. С другой стороны, если вы не укажете значение maxlen, то список может увеличиться до произвольного количества элементов.
В deques .append() также добавляет один элемент в конец или правую часть базовой структуры данных:

>>> from collections import deque

>>> d = deque([1, "a", 3.0])
>>> d
deque([1, 'a', 3.0])

>>> d.append("b")
>>> d
deque([1, 'a', 3.0, 'b'])


Как и списки, в deque могут содержаться элементы разных типов, поэтому .append() добавляет произвольные элементы в конец deque. Другими словами, с помощью .append() вы можете добавить в deque любой объект.
Помимо .append(), в deques также есть .appendleft(),, который добавляет один элемент в начало или левую часть deques. Аналогично, в разделах deque предусмотрены .pop() и .popleft() для удаления элементов с правой и левой сторон раздела deque, соответственно:

>>> from collections import deque

>>> d = deque([1, "a", 3.0])
>>> d.appendleft(-1.0)
>>> d
deque([-1.0, 1, 'a', 3.0])

>>> d.pop()
3.0

>>> d.popleft()
-1.0

>>> d
deque([1, 'a'])


Вызов .appendleft() добавляет -1.0 к левой части d. С другой стороны, .pop() возвращает и удаляет последний элемент в d, а .popleft() возвращает и удаляет первый элемент. В качестве упражнения вы можете попробовать реализовать свой собственный стек или очередь, используя deque вместо списка. Чтобы сделать это, вы можете воспользоваться примерами, которые вы видели в разделе Создание стеков и очередей с помощью Python .append().
Заключение
Python предоставляет метод с именем .append(), который вы можете использовать для добавления элементов в конец заданного списка. Этот метод широко используется либо для добавления отдельного элемента в конец списка, либо для заполнения списка с помощью цикла for. Изучение того, как использовать .append(), поможет вам обрабатывать списки в ваших программах.
 В этом уроке вы узнали:

Как .append() работает
Как заполнять списки, используя .append() вместе с for циклом
Когда следует заменить .append() на понимание списка
Как .append() работает в array.array() и collections.deque()

Кроме того, вы написали несколько примеров того, как использовать .append() для создания структур данных, таких как стеки и очереди. Эти знания позволят вам использовать .append() для эффективного расширения ваших списков.
<завершенный статус статьи-slug=" python-append "класс=" btn-group mb-0" data-api-article-bookmark-url= "/ api / v1/статьи / python-append/bookmark/ " data-api-article-завершение-статус-url="/api / v1/статьи / python-добавление/завершение_статус/ " >



<кнопка поделиться bluesky-text="Интересная статья на #Python от @realpython.com :" email-body="Ознакомьтесь с этой статьей о Python:%0A%0apython's .append(): Добавляйте элементы в свои списки на месте" email-subject="Статья о Python для вас" twitter-текст="Интересная статья на #Python от @realpython:" url="https://realpython.com/python-append/" url-title="Python's .append(): Добавляйте элементы в свои списки на месте">

 Смотрите сейчас, к этому уроку прилагается соответствующий видеокурс, созданный командой Real Python. Просмотрите его вместе с письменным руководством, чтобы углубить свое понимание:  Создание списков с помощью Python .append()

                







                 Back to Top