Функция append в питоне: что делают и как работать со списками с помощью функций / Skillbox Media

что делают и как работать со списками с помощью функций / Skillbox Media

#статьи

• 11 ноя 2022
• 0

Учимся работать со списками с помощью встроенных функций языка.

Дмитрий Зверев

Любитель научной фантастики и технологического прогресса. Хорошо сочетает в себе заумного технаря и утончённого гуманитария. Пишет про IT и радуется этому.

Методы append() и extend() позволяют добавить новый элемент в уже существующий список или объединить несколько list-объектов в один. В этой статье мы расскажем и покажем на примерах, как ими пользоваться. А в конце — поделимся менее очевидными способами расширения списков.

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

list.append(item)

append() принимает один аргумент item и добавляет его в конец list. Тип параметра может быть любым: числа, строки, словари и так далее. Метод возвращает объект None — то есть ничего.

Допустим, у нас есть список a, который заполнен строками:

a = ['car', 'top', 'lot']

Если мы захотим добавить в него новую строку ‘row’, то передадим её в качестве аргумента в append(). Так как метод принадлежит типу list, то вызывать его нужно для объекта a через точку:

a.append('row')
print(a)
['car', 'top', 'lot', 'row']

Строка добавилась в конец нашего списка. Всё работает.

b = ['moon', 'sun']
a.append(b)
print(a)
['car', 'top', 'lot', 'row', ['moon', 'sun']]

Как мы видим, в a добавился список b с вложенными в него элементами. А если мы захотим, чтобы элементы из b добавились отдельно? Вот так:

['car', 'top', 'lot', 'row', 'moon', 'sun']

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

a = [1, 2, 3]
a. append(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list.append() takes exactly one argument (3 given)

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

extend() принимает в качестве параметра итерируемый объект и объединяет его со списком.

list.extend(iterable)

extend() добавляет новые элементы в конец списка, но, в отличие от append(), принимает в качестве параметров итерируемые объекты: списки, кортежи и строки. При этом объединяемые списки могут содержать элементы любых типов: например, вы можете объединить строки с числами или числа с кортежами.

Как и append(), метод возвращает объект None.

Вернёмся к нашему списку a:

 a = ['car', 'top', 'lot']

b = ['dog', 'cat']
a.extend(b)
print(a)
['car', 'top', 'lot', 'dog', 'cat']

Как видите, каждый элемент из b по отдельности добавился в a.

Мы можем сделать то же самое и с другим итерируемыми объектами — например, кортежами или строками:

c = ('like', 'mode')
a.extend(c)
print(a)
['car', 'top', 'lot', 'dog', 'cat', 'like', 'mode']
d = 'man'
a.extend(d)
print(a)
['car', 'top', 'lot', 'dog', 'cat', 'like', 'mode', 'm', 'a', 'n']

Обратите внимание:

Если передать в extend() не итерируемый объект, например число, Python генерирует TypeError:

a = [1, 2, 3]
a.extend(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

В сообщении нам вежливо объясняют, что число — это не итерируемый объект.

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

Оператор +. Он напоминает обычный математический оператор, но со списками действует как функция extend():

a = [2, 3]
b = [1, 4]
a += b
print(a)
[2, 3, 1, 4]

Все элементы одного списка добавились в конец другого.

Срезы. Ещё один способ добавить элементы в список — нестандартно использовать индексацию.

a = [2, 3]
b = [1, 4]
a[len(a):] = b
print(a)
[2, 3, 1, 4]

Выглядит немного странно, но это действительно работает. Когда мы пытаемся обратиться к несуществующим элементам a, язык добавляет новые элементы из списка b, ссылку на который мы передали справа от оператора присваивания.

• Функция append() позволяет добавлять в список один новый элемент — например, число, строку или другой список.
• Функция extend() работает как append(), но в качестве параметра принимает итерируемый объект: список, кортеж или строку. Содержимое этого объекта поэлементно добавляется в другой список.
• Кроме методов append() и extend() добавить элементы в список можно с помощью оператора + и срезов.
  Оба способа действуют как extend() — поочерёдно добавляют элементы одного списка в другой.

Больше интересного про код в нашем телеграм-канале.  Подписывайтесь!

Читайте также:

Учёные разработали ионную кожу, которая даст роботам тактильные ощущения 28 апр 2023

Windows 11 теперь принимает звонки, сообщения и уведомления с iPhone 27 апр 2023

«Сбер» представил конкурента ChatGPT под названием GigaChat 24 апр 2023

Понравилась статья?

Да

что делают и в чем разница

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

Синтаксис метода:

list.append(item)

Параметры

Метод принимает единственный аргумент:

• item – элемент, который нужно добавить в конец списка.

Элементом могут быть числа, строки, словари, другой список и т.д.

Возвращаемое значение

Метод не возвращает никакого значения (возвращает None).

Пример 1: Добавление элемента в список

# animals list
animals = ['cat', 'dog', 'rabbit']

# 'guinea pig' is appended to the animals list
animals.append('guinea pig')

# Updated animals list
print('Updated animals list: ', animals)

Выход

Updated animals list:  ['cat', 'dog', 'rabbit', 'guinea pig']

Пример 2: Добавление списка в список

# animals list
animals = ['cat', 'dog', 'rabbit']

# list of wild animals
wild_animals = ['tiger', 'fox']

# appending wild_animals list to the animals list
animals. append(wild_animals)

print('Updated animals list: ', animals)

Выход

Updated animals list:  ['cat', 'dog', 'rabbit', ['tiger', 'fox']]

Важно отметить, что в список животных в приведенной выше программе добавляется один элемент (список wild_animals).

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

Синтаксис метода:

list1.extend(iterable)

При этом все элементы Iterable добавляются в конец list1.

Параметры

Как уже упоминалось, метод принимает итерацию, такую как список, кортеж, строка и т.д.

Возвращаемое значение

Метод изменяет исходный список, он не возвращает никакого значения.

Пример 1: Использование метода

# language list
language = ['French', 'English']

# another list of language
language1 = ['Spanish', 'Portuguese']

# appending language1 elements to language
language. extend(language1)

print('Language List:', language)

Выход

Language List: ['French', 'English', 'Spanish', 'Portuguese']

Пример 2: Добавить элементы кортежа и установить их в список

# language list
language = ['French']

# language tuple
language_tuple = ('Spanish', 'Portuguese')

# language set
language_set = {'Chinese', 'Japanese'}

# appending language_tuple elements to language
language.extend(language_tuple)

print('New Language List:', language)

# appending language_set elements to language
language.extend(language_set)

print('Newer Language List:', language)

Выход

New Language List: ['French', 'Spanish', 'Portuguese']
Newer Language List: ['French', 'Spanish', 'Portuguese', 'Japanese', 'Chinese']

Другие способы расширения списка

Вы также можете добавить в список все элементы итерации, используя:

1. Оператор +.

a = [1, 2]
b = [3, 4]

a += b    # a = a + b

# Output: [1, 2, 3, 4]
print('a =', a)

a = [1, 2, 3, 4]

2. Синтаксис нарезки списка.

a = [1, 2]
b = [3, 4]

a[len(a):] = b

# Output: [1, 2, 3, 4]
print('a =', a)

a = [1, 2, 3, 4]

3284012cookie-checkМетод append() и extend() в Pythonyes

Python List Метод append() с примерами

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

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

Если вы готовитесь к собеседованию по техническим вопросам, ознакомьтесь с нашим контрольным списком собеседования по техническим вопросам, страницей вопросов для собеседования и электронной книгой по переговорам о заработной плате по номеру . Будьте готовы к собеседованию! Кроме того, прочтите метод Python String join(), команды Python Exit и Type and Isinstance In Python для получения дополнительной информации о подготовке к собеседованию по программированию на Python .

Обучив более 10 000 инженеров-программистов, мы знаем, что нужно для прохождения самых сложных технических собеседований. Наши выпускники постоянно получают предложения от компаний FAANG+. Самое высокое предложение, когда-либо полученное выпускником IK, составляет колоссальные 1,267 миллиона долларов!

В IK вы получаете уникальную возможность учиться у опытных инструкторов, которые являются менеджерами по найму и техническими руководителями в Google, Facebook, Apple и других ведущих технологических компаниях Силиконовой долины.

Хотите пройти следующее техническое собеседование? Подпишитесь на наш БЕСПЛАТНЫЙ вебинар.

В этой статье мы рассмотрим:

• Что такое функция append() в Python и что она делает?
• Функция append() в Python: синтаксис
• Функция append() в Python: пример
• Часто задаваемые вопросы о функции append() в Python

Что такое функция append() в Python и что она делает?

Функция append() в Python принимает один элемент в качестве входного параметра и добавляет его в конец заданного списка. В Python append() не возвращает новый список элементов; на самом деле он вообще не возвращает никакого значения. Он просто изменяет исходный список, добавляя элемент в конец списка.

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

Функция append() в Python: синтаксис

list.append(элемент)
 

list.append(item)

• Параметры: элемент — единственный параметр, который принимает функция append(), и он добавляется в конец списка.

• Возвращает: append() не возвращает никакого значения. Он просто добавляет элемент в конец списка.

Функция append() в Python: пример

Здесь мы рассмотрим, как использовать функцию append() в Python в следующий раз, когда она вам понадобится:

Как использовать функцию append() в Python

# Добавить строковый элемент в список строк:
stringList = ['пн', 'вт', 'ср', 'чт']
печать (список строк)
stringList. append('пт')
печать (список строк)
# Добавляем элемент int в список строк:
stringList.append(8)
печать (список строк)
# Добавляем элемент int в список int:
intList = [0, 2, 4, 6]
печать (целый список)
intList.append(8)
печать (целый список)
# Добавляем строковый элемент в список int:
intList.append('пт')
печать (целый список)
 

Примечание: Код предназначен для Python 3.x, но тот же код будет работать и в Python 2.x, только синтаксис печати изменен на print listName вместо print(listName).

['пн', 'вт', 'ср', 'чт']
['пн', 'вт', 'ср', 'чт', 'пт']
['пн', 'вт', 'ср', 'чт', 'пт', 8]
[0, 2, 4, 6]
[0, 2, 4, 6, 8]
[0, 2, 4, 6, 8, 'пт']
 

‍

# Добавляем список как элемент к исходному списку
stringList = ['пн', 'вт', 'ср', 'чт', 'пт']
печать (список строк)
listToAppend = ['сб', 'вс']
печать (список для добавления)
# Добавление listToAppend к stringList
stringList. append(listToAppend)
печать (список строк)
# Мы можем получить доступ к элементам из добавленного списка так же, как мы получаем доступ к элементам из 2-D Matrix.
печать (строковый список [5] [0])
печать (строковый список [5] [1])
 

['пн', 'вт', 'ср', 'чт', 'пт']
['сб', 'солнце']
['пн', 'вт', 'ср', 'чт', 'пт', ['сб', 'вс']]
Суббота
солнце
 

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

Часто задаваемые вопросы о функции append() в Python

Q1. Как мы можем добавить к списку в Python?

Вы можете использовать extend(), append() и itertools.chain() в зависимости от ваших потребностей в добавлении к списку в Python.

Q2. В чем разница между функциями insert() и append() в Python?

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

Q3. В чем разница между функциями extend() и append() в Python?

В отличие от append() в Python, которая добавляет один элемент в конец списка, функция extend() перебирает свой параметр, добавляет каждый элемент в список и расширяет список.

Q4. Делает ли функция append() в Python копию списка?

Нет. append() изменяет исходный список. Он не создает копию списка.

Q5. Какие параметры принимает функция append() в Python и что она возвращает?

Функция append() в Python принимает единственный параметр — добавляемый элемент. Он не возвращает значения или списка, поскольку изменяет исходный список, добавляя элемент в конец списка.

Готовы пройти следующее собеседование по программированию?

Независимо от того, являетесь ли вы инженером-программистом, стремящимся стать разработчиком программного обеспечения или инженером-программистом, техническим руководителем, или вы нацелены на руководящие должности в ведущих компаниях, IK предлагает курсы, специально разработанные для ваших нужд, чтобы помочь вам в подготовке к техническому собеседованию. !

Если вам нужны рекомендации и помощь в начале работы, подпишитесь на наш БЕСПЛАТНЫЙ вебинар. Являясь пионерами в области подготовки к техническим собеседованиям, мы обучили тысячи инженеров-программистов проходить самые сложные собеседования по программированию и получать работу в компаниях своей мечты, таких как Google, Facebook, Apple, Netflix, Amazon и других!

Добавление элементов в свои списки на месте — Real Python

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

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

В этом руководстве вы узнаете, как:

• Работать с .append()
• Заполнить списки с помощью .append() и цикла for
• Заменить .append() на понимания списка
• Работа с .append() в array.array() и collections.deque()

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

Добавление элементов в список с помощью Python

.append()

Python . append() принимает объект в качестве аргумента и добавляет его в конец существующего списка, сразу после его последнего элемента:

>>>

 >>> числа = [1, 2, 3]
>>> числа.добавление(4)
>>> числа
[1, 2, 3, 4]
 

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

Списки Python оставляют дополнительное место для новых элементов в конце списка. Вызов .append() поместит новые элементы в доступное пространство.

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

>>>

 >>> смешанный = [1, 2]
>>> смешанный .append(3)
>>> смешанный
[1, 2, 3]
>>> смешанный.append("четыре")
>>> смешанный
[1, 2, 3, 'четыре']
>>> смешанный .append(5.0)
>>> смешанный
[1, 2, 3, «четыре», 5,0]
 

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

Использование .append() эквивалентно следующей операции:

>>>

 >>> числа = [1, 2, 3]
>>> # Эквивалентно числам.append(4)
>>> числа[len(числа):] = [4]
>>> числа
[1, 2, 3, 4]
 

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

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

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

>>>

 >>> числа = [1, 2, 3]
>>> числа[len(числа):] = [4, 5, 6]
>>> числа
[1, 2, 3, 4, 5, 6]
 

В этом примере выделенная строка берет фрагмент с конца номеров , распаковывает элементы в списке справа и добавляет их в фрагмент как отдельные элементы.

Удалить рекламу

.append() Добавляет один элемент

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

>>>

 >>> х = [1, 2, 3, 4]
>>> у = (5, 6)
>>> х. присоединить(у)
>>> х
[1, 2, 3, 4, (5, 6)]
 

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

>>>

 >>> х = [1, 2, 3, 4]
>>> у = (5, 6, 7)
>>> х.продлить(у)
>>> х
[1, 2, 3, 4, 5, 6, 7]
>>> х = [1, 2, 3, 4]
>>> у = (5, 6, 7)
>>> # Эквивалентно x.extend(y)
>>> х[лен(х):] = у
>>> х
[1, 2, 3, 4, 5, 6, 7]
 

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

.append() Возвращает Нет

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

>>>

 >>> х = [1, 2, 3, 4]
>>> y = x.append(5)
>>> y Нет
Истинный
>>> х
[1, 2, 3, 4, 5]
 

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

Заполнение списка с нуля

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

1. Используйте . append() и для цикла
2. Использовать понимание списка

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

Использование

.append()

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

.

>>>

 >>> импорт математики
>>> определение квадратного корня (числа):
... результат = []
... для числа в цифрах:
... результат.добавление(math.sqrt(число))
... вернуть результат
...
>>> числа = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> Square_root(числа)
[1,0, 2,0, 3,0, 4,0, 5,0, 6,0, 7,0, 8,0, 9. 0]
 

Здесь вы определяете Square_root() , который принимает список из чисел в качестве аргумента. Внутри square_root() вы создаете пустой список с именем result и запускаете цикл for , который перебирает элементы в числах . В каждой итерации вы используете math.sqrt() для вычисления квадратного корня из текущего числа, а затем используете .append() для добавления результата к результату . После завершения цикла вы возвращаете результирующий список.

Примечание: В приведенном выше примере вы используете sqrt() из math . Модуль Python math поставляется в стандартной библиотеке и предоставляет функции, связанные с математикой. Если вы хотите глубже погрузиться в математику , ознакомьтесь с математическим модулем Python: все, что вам нужно знать.

Этот способ заполнения списков довольно распространен в Python. Тем не менее, язык предоставляет некоторые удобные конструкции, которые могут сделать процесс намного более эффективным и Pythonic. Одной из таких конструкций является понимание списка, которое вы увидите в действии в следующем разделе.

Удаление рекламы

Использование понимания списка

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

>>>

 >>> импорт математики
>>> определение квадратного корня (числа):
... вернуть [math.sqrt(число) для числа в цифрах]
...
>>> числа = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> Square_root(числа)
[1,0, 2,0, 3,0, 4,0, 5,0, 6,0, 7,0, 8,0, 9,0]
 

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

Чтобы превратить .append() в понимание списка, вам просто нужно поместить его аргумент, за которым следует заголовок цикла (без двоеточия) внутри пары квадратных скобок.

Возврат к

.append()

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

Предположим, вам нужно Square_root() , чтобы предоставить вашим пользователям подробную информацию о ходе вычисления квадратного корня из входного списка чисел. Чтобы сообщить о ходе операции, вы можете использовать print() :

>>>

 >>> импорт математики
>>> определение квадратного корня (числа):
. .. результат = []
... n = len (числа)
... для i, число в перечислении (числа):
... print(f"Номер обработки: {число}")
... результат.добавление(math.sqrt(число))
... print(f"Завершено: {int((i + 1) / n * 100)}%")
... вернуть результат
...
>>> числа = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> Square_root(числа)
Номер обработки: 1
Завершено: 11%
...
Номер обработки: 81
Завершено: 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() .

Реализация стека

Стек — это структура данных, в которой элементы хранятся друг над другом. Элементы входят в стек и удаляются из него по принципу «последним пришел — первым ушел» (LIFO). Обычно стек реализует две основные операции:

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

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

.

>>>

 >>> числа = [1, 2, 3]
>>> числа.pop(1)
2
>>> числа
[1, 3]
>>> числа.pop()
3
>>> числа
[1]
>>> числа.pop()
1
>>> числа
[]
>>> числа.pop()
Traceback (последний последний вызов):
  Файл "", строка 1, в 
    числа.поп()
IndexError: вытолкнуть из пустого списка
 

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

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

Стек класса

:
    защита __init__(сам):
        self._items = []
    def push(я, предмет):
        self._items.append(элемент)
    деф поп(сам):
        пытаться:
            вернуть self._items.pop()
        кроме IndexError:
            print("Пустой стек")
    защита __len__(я):
        вернуть len(self._items)
    защита __repr__(сам):
        вернуть f"Стек({self._items})"
 

В Stack вы сначала инициализируете атрибут экземпляра ._items . Этот атрибут содержит пустой список, который вы будете использовать для хранения элементов в стеке. Затем вы кодируете .push() , который реализует операцию push с использованием .append() на ._items .

Вы также реализуете операцию pop , вызывая .pop() в базовом списке, . _items . В этом случае вы используете попробуйте и , кроме блока , чтобы обработать IndexError , возникающую при вызове .pop() в пустом списке.

Примечание: В Python использование исключений для управления потоком программы является распространенным шаблоном. Разработчики Python отдают предпочтение этому стилю кодирования, известному как EAFP (Легче попросить прощения, чем разрешения), а не стилю кодирования, известному как LBYL (Посмотри, прежде чем прыгнуть). Чтобы узнать больше об этих двух стилях кодирования, ознакомьтесь с LBYL и EAFP: предотвращение или обработка ошибок в Python.

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

Специальный метод .__len__() обеспечивает необходимую функциональность для получения длины внутреннего списка ._items . Специальный метод .__repr__() позволяет предоставить удобное для пользователя строковое представление стека при выводе структуры данных на экран.

Вот несколько примеров того, как вы можете использовать Stack на практике:

>>>

 >>> стек = стек()
>>> # Помещаем элементы на вершину стека
>>> stack.push(1)
>>> stack.push(2)
>>> # Удобный формат печати
>>> стек
Стек ([1, 2])
>>> печать (стек)
Стек ([1, 2])
>>> # Получить длину стека
>>> len(стек)
2
>>> # Извлекаем элементы из вершины стека
>>> стек.pop()
2
>>> стек.pop()
1
>>> стек.pop()
Пустой стек
>>> стек
Куча([])
 

Вот оно! Вы закодировали структуру данных стека, которая реализует операции push и pop . Он также предоставляет функциональные возможности для получения длины базового списка и печати всего стека в удобной для пользователя форме.

Удаление рекламы

Реализация очереди

Очереди

— это структуры данных, которые обычно управляют своими элементами по принципу «первым пришел — первым обслужен» (FIFO). Очереди работают как труба, в которую вы вставляете новые элементы с одного конца, а старые элементы выскакивают с другого конца.

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

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

 класс Очередь:
    защита __init__(сам):
        self._items = []
    def enqueue(self, item):
        self._items.append(элемент)
    деф очередь (я):
        пытаться:
            вернуть self. _items.pop(0)
        кроме IndexError:
            print("Пустая очередь")
    защита __len__(я):
        вернуть len(self._items)
    защита __repr__(сам):
        вернуть f "Очередь ({self._items})"
 

Этот класс очень похож на ваш стек . Основное отличие в том, что .pop() принимает 0 в качестве аргумента для возврата и удаляет первый элемент в базовом списке, ._items , а не последний.

Примечание: Использование .pop(0) в списке Python — не самый эффективный способ использования элементов списка. К счастью, модуль Python collections предоставляет структуру данных deque() , которая реализует .popleft() как эффективный способ потребления элементов с начала года.0155 deque() .

Вы узнаете больше об использовании двойных очередей чуть позже в этом руководстве.

Остальная часть реализации почти идентична, но использует соответствующие имена, такие как . enqueue() для добавления элементов и .dequeue() для их удаления. Вы можете использовать Queue так же, как вы использовали Stack в предыдущем разделе: просто вызовите .enqueue() для добавления элементов и .dequeue() для их извлечения и удаления.

Использование

.append() в других структурах данных

Другие структуры данных Python также реализуют .append() . Принцип работы такой же, как у традиционного .append() в списке. Метод добавляет один элемент в конец базовой структуры данных. Тем не менее, есть некоторые тонкие различия.

В следующих двух разделах вы узнаете, как .append() работает в других структурах данных, таких как array.array() и collections.deque() .

массив.добавление()

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

array.array() принимает следующие два аргумента:

Аргумент	Содержание	Обязательно
код типа	Односимвольный код, определяющий тип данных, которые может хранить массив	Да
инициализатор	Список, байтовый объект или итерируемый объект, который служит инициализатором	№

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

>>>

 >>> из массива импортировать массив
>>> # Массив целых чисел
>>> int_array = массив ("i", [1, 2, 3])
>>> int_array
массив('i', [1, 2, 3])
>>> int_array[0]
1
>>> int_array[:2]
массив('i', [1, 2])
>>> int_array[2] = 4
>>> int_array
массив('i', [1, 2, 4])
 

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

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

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

>>>

 >>> из массива импортировать массив
>>> а = массив ("i", [1, 2, 3])
>>> а
массив('i', [1, 2, 3])
>>> # Добавляем число с плавающей запятой
>>> a.append(1.5)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
    а.  добавить (1.5)
TypeError: ожидается целочисленный аргумент, получено число с плавающей запятой
 

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

Напротив, если у вас есть массив с числами с плавающей запятой и вы пытаетесь добавить в него целые числа, ваша операция завершится успешно:

>>>

 >>> из массива импортировать массив
>>> float_array = массив ("f", [1.0, 2.0, 3.0])
>>> float_массив
массив('f', [1.0, 2.0, 3.0])
>>> # Добавить и целое число
>>> float_array.append(4)
>>> float_массив
массив('f', [1.0, 2.0, 3.0, 4.0])
 

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

Удалить рекламу

deque.append() и deque.appendleft()

collections.deque() — еще одна структура данных, реализующая вариант .append() . Двухсторонняя очередь является обобщением стека и очереди, специально разработанной для поддержки быстрых и эффективных с точки зрения памяти операций append и pop на обеих сторонах. Поэтому, если вам нужно создать структуру данных с этими функциями, рассмотрите возможность использования очереди вместо списка.

Примечание: Название deque произносится как «колода» и означает d ouble- e nded que ue.

collections.deque() принимает следующие два необязательных аргумента:

Аргумент	Содержание
повторяемый	Итерируемый объект, который служит инициализатором
макслен	Целое число, указывающее максимальную длину очереди

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

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

>>>

 >>> из очереди импорта коллекций
>>> d = deque([1, "a", 3.0])
>>> д
двойная очередь ([1, 'а', 3.0])
>>> d.append("b")
>>> д
двойная очередь ([1, 'а', 3.0, 'б'])
 

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

Помимо .append() , очереди также предоставляют .appendleft() , который добавляет один элемент в начало или левую часть очереди. Точно так же очереди предоставляют .pop() и .popleft() для удаления элементов с правой и левой стороны очереди соответственно:

>>>

 >>> из очереди импорта коллекций
>>> d = deque([1, "a", 3.0])
>>> d.appendleft(-1.0)
>>> д
deque([-1.0, 1, 'а', 3.0])
>>> д.поп()
3.0
>>> d.popleft()
-1,0
>>> д
двойная очередь ([1, 'а'])
 

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

Заключение

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

В этом уроке вы узнали:

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

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

No related posts.