Как выглядит инструкция добавления элемента b в конец списка a

#статьи

11 ноя 2022
0

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

Иллюстрация: Катя Павловская для Skillbox Media

Любитель научной фантастики и технологического прогресса. Хорошо сочетает в себе заумного технаря и утончённого гуманитария. Пишет про 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() этого сделать нельзя, потому что метод принимает только один аргумент. Если вы всё-таки попытаетесь передать несколько объектов через запятую, то интерпретатор вызовет исключение TypeError (ошибка типа):


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 в extend() и получим результат:


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(), превращаются в списки символов и добавляются посимвольно. Так, строка ‘man’ разложилась на ‘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() — поочерёдно добавляют элементы одного списка в другой.

Нейросети вам помогут.
Большой вебинар по нейросетям. 15 экспертов, 7 топ-нейросетей. Научитесь использовать ИИ в своей работе и повысьте эффективность.
Узнать больше

Источник

В этом руководстве мы изучим различные способы добавления элементов в список в Python.

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

append(): добавить объект в конец списка;
insert(): вставляет объект перед указанным индексом;
extend(): расширяет список, добавляя элементы из итерируемого;
Объединение списков: мы можем использовать оператор + для объединения нескольких списков и создания нового списка.

Содержание

Добавление элементов в список
1. append()
2. insert()
3. extend()
4. Объединение списков
Заключение

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

Мы можем добавить элемент в конец списка или по любому заданному индексу. Есть способы добавить в список элементы из итерируемого. Мы также можем использовать оператор + для объединения нескольких списков для создания нового списка.

1. append()

Эта функция добавляет элемент в конец списка.

fruits = ["Apple", "Banana"]

# 1. append()
print(f'Current Fruits List {fruits}')

f = input("Please enter a fruit name:n")
fruits.append(f)

print(f'Updated Fruits List {fruits}')

Вывод:

Current Fruits List ['Apple', 'Banana']
Please enter a fruit name:
Orange
Updated Fruits List ['Apple', 'Banana', 'Orange']

2. insert()

Эта функция добавляет элемент по указанному индексу списка. Полезно добавить элемент по указанному индексу списка.

num_list = [1, 2, 3, 4, 5]

print(f'Current Numbers List {num_list}')

num = int(input("Please enter a number to add to list:n"))

index = int(input(f'Please enter the index between 0 and {len(num_list) - 1} to add the number:n'))

num_list.insert(index, num)

print(f'Updated Numbers List {num_list}')

Вывод:

Current Numbers List [1, 2, 3, 4, 5]
Please enter a number to add to list:
20
Please enter the index between 0 and 4 to add the number:
2
Updated Numbers List [1, 2, 20, 3, 4, 5]

3. extend()

Эта функция добавляет в список повторяющиеся элементы. Полезно добавлять элементы из итерируемого объекта в конец списка.

list_num = []
list_num.extend([1, 2])  # extending list elements
print(list_num)
list_num.extend((3, 4))  # extending tuple elements
print(list_num)
list_num.extend("ABC")  # extending string elements
print(list_num)

Вывод:

[1, 2]
[1, 2, 3, 4]
[1, 2, 3, 4, 'A', 'B', 'C']

Если вам нужно объединить несколько списков, вы можете использовать оператор «+». Это создаст новый список, а исходные списки останутся без изменений.

evens = [2, 4, 6]
odds = [1, 3, 5]

nums = odds + evens
print(nums)  # [1, 3, 5, 2, 4, 6]

Новый список будет содержать элементы из списка слева направо. Это похоже на конкатенацию строк в Python.

Заключение

В программировании на Python очень легко добавлять элементы в список. Мы можем добавить элемент в конец списка, вставить элемент по заданному индексу. Мы также можем добавить список в другой список. Если вы хотите объединить несколько списков, используйте перегруженный оператор +.

( 16 оценок, среднее 4.44 из 5 )

Источник

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

Давайте начнем!

Массив в программировании — это упорядоченный набор элементов, где все элементы должны иметь один и тот же тип данных.

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

Списки, по сути, представляют собой динамические массивы и являются одной из наиболее распространенных и мощных структур данных в Python.

Можете считать их упорядоченными контейнерами. Они хранят и организуют похожие связанные данные вместе.

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

Могут быть списки целых чисел (int), списки чисел с плавающей точкой (float), списки строк (string) и списки данных любых других встроенных типов Python.

Списки более гибкие, чем традиционные массивы. Это означает, что в одном списке может быть несколько различных типов данных.

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

Значения разделяются запятой и заключаются в квадратные скобки [].

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

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

К примеру, это может выглядеть так:

# Создаем новый список имен
names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

# Выводим список в консоль
print(names)

# Результат
# ['Jimmy', 'Timmy', 'Kenny', 'Lenny']

[python_ad_block]

Как индексируются списки в Python

Списки поддерживают порядок элементов.

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

Индексы в Python (и любом другом современном языке программирования) начинаются с 0 и увеличиваются для каждого элемента в списке.

Например, список, созданный нами ранее, имел 4 значения:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

Первое значение в списке, «Jimmy», имеет индекс 0.
Второе значение в списке, «Timmy», имеет индекс 1.
Третье значение в списке, «Kenny», имеет индекс 2.
Четвертое значение в списке, «Lenny», имеет индекс 3.

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

Например, если вы хотите получить доступ к элементу с индексом 2, вы должны сделать следующее:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

print(names[2])

# Результат
# Kenny

Списки в Python изменяемы

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

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

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

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

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

Например, для добавления элементов существуют методы .append(), .insert() и .extend().

Для удаления элементов существуют такие методы, как .remove(), .pop() и .pop(index).

Про удаление элементов из списка можно подробнее почитать в статье «Как удалить элемент из списка в Python». Здесь мы сфокусируемся на методах добавления элементов.

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

Метод .append() добавляет дополнительный элемент в конец уже существующего списка.

Общий синтаксис выглядит примерно так:

list_name.append(item)

Давайте разберем это:

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

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

Если вы хотите добавить дополнительное имя в список, созданный ранее, вы должны сделать следующее:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

# Добавляем имя Dylan в конец списка
names.append("Dylan")

print(names)

# Результат
# ['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']

В чем разница между методами .append() и .insert()?

Разница между этими двумя методами заключается в том, что .append() добавляет элемент в конец списка, тогда как .insert() вставляет элемент на указанную позицию в списке.

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

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

Общий синтаксис выглядит следующим образом:

list_name.insert(position,item)

Давайте разбираться:

list_name — это имя вашего списка
.insert() — это метод для вставки элемента в список
position — первый аргумент метода. Это всегда целое число — порядковый номер позиции, на которую вы хотите поместить новый элемент
item — второй аргумент метода. Здесь вы указываете новый элемент, который хотите добавить в список.

Предположим, у вас есть следующий список языков программирования:

programming_languages = ["JavaScript", "Java", "C++"]

print(programming_languages)

# Результат
# ['JavaScript', 'Java', 'C++']

Если вы хотите вставить «Python» в начало этого списка, вы должны использовать метод .insert() и указать позицию 0 (помните, что первое значение в списке всегда имеет индекс 0).

programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(0, "Python")

print(programming_languages)

# Результат
# ['Python', 'JavaScript', 'Java', 'C++']

Если бы вы хотели оставить «JavaScript» первым элементом в списке, а затем добавить «Python», нужно было бы указать позицию 1:

programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(1,"Python")

print(programming_languages)

# Результат
# ['JavaScript', 'Python', 'Java', 'C++']

Метод .insert() дает вам немного больше гибкости по сравнению с методом .append(), который добавляет новый элемент только в конец списка.

В чем разница между методами .append() и .extend()?

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

Вы можете воспользоваться тем же методом .append().

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

programming_languages = ["JavaScript", "Java"]

print(programming_languages)

# Результат
# ['JavaScript', 'Java']

И вы хотите добавить еще два языка в конце.

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

programming_languages = ["JavaScript", "Java"]

# Добавляем два новых элемента в конец списка
programming_languages.append(["Python","C++"])

print(programming_languages)

# Результат
# ['JavaScript', 'Java', ['Python', 'C++']]

Если вы внимательно посмотрите на вывод — ['JavaScript', 'Java', ['Python', 'C++']], — вы увидите, что в конец уже существующего списка добавлен новый список.

Итак, .append() добавляет список внутрь списка. Таким образом, вы получаете вложенный список.

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

Скажем, у вас уже было два списка, например:

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

Что, если бы вы захотели объединить содержимое обоих списков в один, добавив к names содержимое more_names?

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

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

# Добавляем содержимое more_names в names
names.append(more_names)

print(names)

# Результат
# ['Jimmy', 'Timmy', ['Kenny', 'Lenny']]

Итак, .append() добавляет новые элементы в виде другого списка, добавляя объект в конец.

Особенности использования .extend()

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

Общий синтаксис выглядит следующим образом:

list_name.extend(iterable/other_list_name)

Итак, давайте разбираться:

list_name — имя одного из списков
.extend() — это метод добавления всего содержимого одного списка в другой
iterable может быть любым итерируемым объектом, таким как другой список, например, other_list_name. В данном случае other_list_name — это список, который будет объединен с list_name, а все его элементы будут добавлены один за другим в конец list_name по отдельности.

Итак, взяв код из предыдущего примера и заменив .append() на .extend(), мы получим следующее:

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

names.extend(more_names)

print(names)

# Результат
# ['Jimmy', 'Timmy', 'Kenny', 'Lenny']

Когда мы использовали .extend(), список names расширился, а его длина увеличилась на 2.

Метод .extend() принимает список (или другой итерируемый объект) в качестве аргумента, выполняет итерацию по каждому элементу, а затем добавляет каждый элемент в итерируемом объекте в список.

Еще одно различие между .append() и .extend()

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

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

# Добавляем имя Dylan в конец списка
names.append("Dylan")

print(names)

# Результат
# ['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']

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

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

Итак, тот же пример, но с методом .extend(), будет выглядеть так:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

# Передаем в .extend() строку (итерируемый объект) 
names.extend("Dylan")

print(names)

# Результат
# ['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'D', 'y', 'l', 'a', 'n']

Заключение

Подводя итог, можно сказать, что метод .append() используется для добавления элемента в конец существующего списка без создания нового списка. Для добавления элемента на любую заданную позицию в списке стоит использовать метод .insert().

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

Спасибо за чтение и успехов в написании кода!

Перевод статьи «Append in Python – How to Append to a List or an Array».

Источник

Содержание:развернуть

Что такое список
Как списки хранятся в памяти?
Базовая работа со списками
Объявление списка
Обращение к элементу списка в Python
Добавление в список
Добавление в список на указанную позицию
Изменение элементов списка
Удаление элемента из списка
Как проверить наличие элемента в списке
Объединение списков
Копирование списка Python
Цикл по списку
Методы списков
Вложенные списки
Срезы
Генераторы списков
Best Practices
Как получить список в обратном порядке
Как перевести список в другой формат?
Как узнать индекс элемента в списке?
Как посчитать количество уникальных элементов в списке?
Как проверить список на пустоту?
Как создать список числовых элементов с шагом

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

Ниже разберёмся, как устроены списки, как с ними работать и приведём 6 примеров из практики.

Что такое список

Список (list) — тип данных, предназначенный для хранения набора или последовательности разных элементов.

[1, 33, 6, 9] # литерал списка в Python

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

Как списки хранятся в памяти?

Базовая C-структура списков в Python (CPython) выглядит следующим образом:

typedef struct { PyObject_VAR_HEAD PyObject **ob_item; Py_ssize_t allocated; } PyListObject;

Когда мы создаём список, в памяти под него резервируется объект, состоящий из 3-х частей:

PyObject_VAR_HEAD — заголовок;
ob_item — массив указателей на элементы списка;
allocated — количество выделенной памяти под элементы списка.

Объект списка хранит указатели на объекты, а не на сами объекты

Python размещает элементы списка в памяти, затем размещает указатели на эти элементы. Таким образом, список в Python — это массив указателей.

Список в Python — это массив указателей на элементы, размещенные в памяти

Базовая работа со списками

Объявление списка

Объявление списка — самый первый и главный этап его создания. Для объявления списка в Python существует несколько способов.

Вариант №1: Через литерал (выражение, создающее объект):

>>> elements = [1, 3, 5, 6]


>>> type(elements)

<class 'list'>

>>> print(elements) [1, 3, 5, 6]

В данном примере мы создали список с заранее известными данными. Если нужен пустой список, в квадратных скобках ничего не указывается — elements = [].

Вариант №2: Через функцию list():

>>> elements = list()


>>> type(elements)

<class 'list'>

>>> print(elements) []

В этом примере создается пустой список.

Обращение к элементу списка в Python

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

>>> elements = [1, 2, 3, 'word']

>>> elements[3] 'word'

Индекс — это порядковый номер элемента в списке. В примере выше индексы (позиции в списке) соответственно будут: 0, 1, 2, 3.

Нумерация элементов списка в Python начинается с нуля

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

>>> elements = [1, 2, 3, 'word']


>>> elements[-4]

1

>>> elements[-1] 'word'

Отрицательные индексы работают справа налево (то есть индекс значения ‘1’ — -4, а отрицательный индекс ‘word’ — -1.

💡 Отрицательным индексом удобно пользоваться, когда необходимо обратиться к последнему элементу в списке, не высчитывая его номер. Любой конечный элемент будет с индексом, равным -1.

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

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

Для того чтобы добавить новый элемент в список, используется list.append(x), где list — список, x — нужное значение.

>>> elements = [1, 2, 3, 'word'] >>> elements.append('meow')

>>> print(elements) [1, 2, 3, 'word', 'meow']

Для простого примера, рассмотрим создание списка с нуля с помощью метода append() :

>>> elements = [] >>> elements.append(1) >>> elements.append('word') >>> elements.append('meow')

>>> print(elements) [1, 'word', 'meow']

Добавление в список на указанную позицию

Немаловажно обратить внимание на метод list.insert(i, x), где list — список, i — позиция, x — нужное значение.

>>> elements = [1, 2, 4] >>> print(elements) [1, 2, 4]

>>> elements.insert(2, 3) >>> print(elements) [1, 2, 3, 4]

Изменение элементов списка

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

>>> elements = [2, 4, 6] >>> elements[2] = 8

>>> print(elements) [2, 4, 8]

В примере выше мы заменили 6 на 8.

Не забывайте, что счёт начинается с нуля, и в данном списке цифра 6 это 2-й элемент

Удаление элемента из списка

Для удаление из списка используют инструкцию del list[i], где list — список, i — индекс (позиция) элемента в списке:

>>> elements = [1, "test", 5, 7] >>> del elements[1] >>> print(elements) [1, 5, 7]

Удалять можно как из текущего списка, так и из вложенных списков:

>>> my_list = ["hello", "world", "!"] >>> elements = [1, my_list, "ok"] >>> del elements[1][2]

>>> print(elements) [1, ['hello', 'world'], 'ok']

Можно удалять целыми диапазонами:

>>> elements = [2, 4, 6, 8, 12] >>> del elements[2:] # удаляем все элементы после 2-го элемента (включительно) >>> print(elements) [2, 4]


>>> elements = [2, 4, 6, 8, 12]

>>> del elements[:3]  # удаляем все элементы до 3-го элемента

>>> print(elements)

[8, 12]

>>> elements = [2, 4, 6, 8, 12] >>> del elements[1:3] # удаляем от 1-го элемента включительно до 3-го элемента >>> print(elements) [2, 8, 12]

Еще один способ удаления из списка — list.remove(x), где list — список, x — значение, которое нужно удалить:

>>> elements = [2, "test", 4] >>> elements.remove("test") >>> print(elements) [2, 4]

Как проверить наличие элемента в списке

Для того чтобы проверить существование какого-либо элемента в списке, нужно воспользоваться оператором in. Рассмотрим на примере:

>>> elements = ['слон', 'кот', 'лошадь', 'змея', 'рыба'] >>> if 'кот' in elements: print('meow')

meow

Объединение списков

Списки в Python можно объединять с помощью оператора + или метода extend . Выглядит это так:

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

>>> hello = ["h", "e", "l", "l", "o"] >>> world = ["w", "o", "r", "l", "d"] >>> hello.extend(world) # extends не возвращает новый список, а дополняет текущий >>> print(hello) ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

Копирование списка Python

Если вы захотите скопировать список оператором =, вы скопируете не сам список, а только его ссылку.

>>> a = [1, 2, 3] >>> b = a # переменной b присваивается не значение списка a, а его адрес


>>> print(id(a), id(b))

56466376 56466376  # a и b ссылаются на один и тот же список

>>> b.append(4) >>> print(a, b) [1, 2, 3, 4] [1, 2, 3, 4]

Для копирования списков можно использовать несколько вариантов:

elements.copy() — встроенный метод copy (доступен с Python 3.3);
list(elements) — через встроенную функцию list() ;
copy.copy(elements) — функция copy() из пакета copy;
elements[:] — через создание среза (устаревший синтаксис).

Рассмотрим на примере каждый из этих способов:

>>> a = ["кот", "слон", "змея"]


>>> b = a.copy()

>>> print(id(a), id(b), a, b)

56467336 56467016 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']
>>> d = list(a)

>>> print(id(a), id(d), a, d)

56467336 60493768 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']
>>> import copy

>>> e = copy.copy(a)  #

>>> print(id(a), id(e), a, e)

56467336 60491304 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']
>>> f = copy.deepcopy(a)

>>> print(id(a), id(f), a, f)

56467336 56467400 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

>>> c = a[:] # устаревший синтаксис >>> print(id(a), id(c), a, c) 56467336 60458408 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

Важно: copy.copy(a) делает поверхностное копирование. Объекты внутри списка будут скопированы как ссылки на них (как в случае с оператором =). Если необходимо рекурсивно копировать всех элементов в списке, используйте copy.deepcopy(a)

Скопировать часть списка можно с помощью срезов. Есть несколько вариантов использования:

>>> a = ["кот", "слон", "змея"]





  


                       
  




>>> b = a[2:]  # с 2-го элемента (включительно) до конца списка

>>> print(b)

['змея']
>>> c = a[:2]  #  с начала списка по 2-й элемент

>>> print(c)

['кот', 'слон']
>>> d = a[1:2]  #  с 1-го элемента (включительно) по 2-й элемент

>>> print(d)

['слон']

>>> a = [1, 2, 3, 4, 5, 6, 7, 8] >>> e = a[0:8:2] # c 0-го элемента по 8-й элемент с шагом 2 >>> print(e) [1, 3, 5, 7]

Цикл по списку

Для перебора списков в Python есть два цикла: for и while.

elements = [1, 2, 3, "meow"] for el in elements: print(el)

Результат выполнения:

1 2 3 meow

Попробуем построить цикл while. Он выполняется, когда есть какое-либо определённое условие:

elements = [1, 2, 3, "meow"] elements_len = len(elements) i = 0 while i < elements_len: print(elements[i]) i += 1

Результат выполнения:

1 2 3 meow

Из примеров выше можем сделать вывод, что конструкция for выглядит заметно компактнее, чем while.

Методы списков

list.append(x) — позволяет добавлять элемент в конец списка;
list1.extend(list2) — предназначен для сложения списков;
list.insert(i, x) — служит для добавления элемента на указанную позицию(i — позиция, x — элемент);
list.remove(x) — удаляет элемент из списка (только первое вхождение);
list.clear() — предназначен для удаления всех элементов (после этой операции список становится пустым []);
list.copy() — служит для копирования списков.
list.count(x) — посчитает количество элементов x в списке;
list.index(x) — вернет позицию первого найденного элемента x в списке;
list.pop(i) — удалит элемент из позиции i ;
list.reverse() — меняет порядок элементов в списке на противоположный;
list.sort() — сортирует список.

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

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


# extend

>>> elements = [1, 2, 3, "meow"]

>>> elements.extend([4, 5, "gaf"])

>>> print(elements)

[1, 2, 3, 'meow', 4, 5, 'gaf']
# insert

>>> a = [1, 3, 4]

>>> a.insert(1, 2)  # insert добавит на позицию 1 цифру 2

>>> print(a)

[1, 2, 3, 4]
# remove

>>> elements = [1, "meow", 3, "meow"]

>>> elements.remove("meow")  # remove удалит только первое вхождение

>>> print(elements)

[1, 3, 'meow']
# clear

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

>>> a.clear()

>>> print(a)

[]



  


                       
  




# copy

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

>>> b = a.copy()

>>> print(id(a), id(b), a, b)

60458408 60491880 [1, 2, 3] [1, 2, 3]
# count

>>> elements = ["one", "two", "three", "one", "two", "one"]

>>> print(elements.count("one"))

3
# index

>>> elements = ["one", "two", "three", "one", "two", "three"]

>>> print(elements.index("three"))  # index вернет первый найденный индекс

2
# pop (положительный индекс)

>>> elements = [1, "meow", 3, "wow"]

>>> elements.pop(1)  # удаляет элемент с индексом 1

'meow'  # pop возвращает удаленный элемент списка

>>> print(elements)

[1, 3, 'wow']
# pop (отрицательный индекс) [удаление с конца списка, начиная с -1]

elements = ["hello", "world", "!"]

elements.pop(-2)

'world'

>>> print(elements)

['hello', '!']
# pop (без индекса) [удалит из списка последний элемент]

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

>>> elements.pop()  # по умолчанию, в методе pop индекс равен -1

3

>>> print(elements)

[1, 2]
# reverse

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

>>> a.reverse()

>>> print(a)

[3, 2, 1]
# sort (по возрастанию)

>>> elements = [3, 19, 0, 3, 102, 3, 1]

>>> elements.sort()

>>> print(elements)

[0, 1, 3, 3, 3, 19, 102]

# sort (по убыванию) >>> elements = [3, 19, 0, 3, 102, 3, 1] >>> elements.sort(reverse = True) >>> print(elements) [102, 19, 3, 3, 3, 1, 0]

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

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

>>> elements = [1, 2, [0.1, 0.2, 0.3]]

Для обращения к элементу вложенного списка нужно использовать два индекса: первый указывает на индекс главного списка, второй — индекс элемента во вложенном списке. Вот пример:

>>> elements = [["яблоки", 50], ["апельсины", 190], ["груши", 100]]


>>> print(elements[0])

['яблоки', 50]

>>> print(elements[1][0]) апельсины

Срезы

Срезы (slices) — это подмножества элементов списка. Срезу нужны, когда необходимо извлечь часть списка из полного списка.

У них есть свой собственный синтаксис. Записывается срез так же, как обращение к элементу, используя индекс. Пример:

elements[START:STOP:STEP]

В этом случае берётся срез от номера start (включительно) до stop (не включая его), а step — это шаг. По умолчанию start и stop равны 0, step равен 1.

>>> elements = [0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4] >>> int_elements = elements[2:6] # с 2-го элемента включительно по 6-й элемент


>>> print(id(elements), id(int_elements))  # elements и int_elements - 2 разных списка

53219112 53183848
>>> print(elements)

[0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4]  # срез не модифицирует исходный список

>>> print(int_elements) [1, 2, 3, 4]

Генераторы списков

Генератором списка называется способ построения списка с применением выражения к каждому элементу, входящему в последовательность. Есть схожесть генератора списка и цикла for. На этом примере мы рассмотрим простейший генератор списков:

>>> c = [c * 3 for c in 'list']

>>> print(c) ['lll', 'iii', 'sss', 'ttt']

Таким образом мы получили отдельно взятые утроенные буквы слова, введённого в кавычки. Есть множество вариантов применения генератора списков.

Пример генератора списка:

>>> nums = [i for i in range(1, 15)] >>> print(nums) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Пример посложнее:

>>> c = [c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a'] >>> print(c) ['ls', 'lp', 'lm', 'ss', 'sp', 'sm', 'ts', 'tp', 'tm']

Это усложнённая конструкция генератора списков, в которой мы сделали все возможные наборы сочетаний букв из введённых слов. Буквы-исключения видны по циклу, где стоит знак != для одной переменной и другой.

Best Practices

Последние абзацы статьи будут посвящены лучшим решениям практических задач, с которыми так или иначе сталкивается Python-разработчик.

Как получить список в обратном порядке

Изменить порядок размещения элементов в списке помогает функция list.reverse():

>>> elements = [1, 2, 3, 4, 5, 6] >>> elements.reverse()

>>> print(elements) [6, 5, 4, 3, 2, 1]

Как перевести список в другой формат?

Иногда требуется перевести список в строку, в словарь или в JSON. Для этого нужно будет вывести список без скобок.

Перевод списка в строку осуществляется с помощью функции join(). На примере это выглядит так:

>>> fruits = ["яблоко", "груша", "ананас"]

>>> print(', '.join(fruits)) яблоко, груша, ананас

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

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

>>> elements = [['1', 'a'],['2', 'b'],['3', 'c']] >>> my_dict = dict(elements)

>>> print(my_dict) {'1': 'a', '2': 'b', '3': 'c'}

JSON — это JavaScript Object Notation. В Python находится встроенный модуль json для кодирования и декодирования данных JSON. С применением метода json.dumps(x) можно запросто преобразовать список в строку JSON.

>>> import json >>> json.dumps(['word', 'eye', 'ear']) '["word", "eye", "ear"]'

Как узнать индекс элемента в списке?

Узнать позицию элемента в последовательности списка бывает необходимым, когда элементов много, вручную их не сосчитать, и нужно обращение по индексу. Для того чтобы узнать индекс элемента, используют функцию list.index(x).

>>> elements = [1, 3, 6, 9, 55]

>>> print(elements.index(9)) 3

В качестве аргумента передаем значение, а на выходе получаем его индекс.

Как посчитать количество уникальных элементов в списке?

Самый простой способ — приведение списка к set (множеству). После этого останутся только уникальные элементы, которые мы посчитаем функцией len():

>>> words = ["one", "two", "one", "three", "one"] >>> len(set(words)) 3

Как проверить список на пустоту?

>>> a = [] >>> if not a: print("список пуст!")

список пуст!

Как создать список числовых элементов с шагом

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

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

>>> elements = [1, 2, 3, 4, 5, 8, 9, 10, 11, 14, 20] >>> print(elements[0:11:2]) [1, 3, 5, 9, 11, 20]

Еще один вариант — воспользоваться генератором списков:

>>> elements = [c for c in range(0, 10, 2)] # от 0 (включительно) до 10 с шагом 2

>>> print(elements) [0, 2, 4, 6, 8]

При разработке на языке Python, списки встречаются довольно часто. Знание основ работы со списками поможет быстро и качественно писать программный код 😉.

Источник

Не путайте в Python списки и массивы: в первых можно хранить разнородные объекты. Здесь кратко описаны все основные методы списков Python 3.x.

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

В Python списки создаются двумя способами:

С помощью квадратных скобок []
С помощью функции list()

Элементы списка можно сразу поместить внутрь скобок. По умолчанию создается пустой list.

>>> # Рассмотрим создание списка на примере дел
... # Второй будем использовать для хранения абстрактной информации
... 
>>> todo_list = []
>>> general_info = list()
>>> type(todo_list), type(general_info)
(<class 'list'>, <class 'list'>)

Итак, мы создали два пустых списка. Заполним их данными.

Как добавить данные в список?

В языке программирования Python это изменяемые объекты. Можно добавлять, заменять или удалять конкретные элементы, не следя за остальными. Добавить элементы в список можно двумя методами:

append()
insert()

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

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

>>> todo_list.append('Завтрак, зарядка, душ')
>>> todo_list.append('Чтение статей на proglib')
>>> todo_list.append('Дорога до работы')
>>> todo_list
['Завтрак, зарядка, душ', 'Чтение статей на proglib', 'Дорога до работы']

Добавление элемента методом insert()

insert() принимает два аргумента – индекс позиции и вставляемый элемент:

>>> general_info.insert(0, 'Важные математические константы')
>>> general_info.insert(1, 1j)
>>> general_info.insert(2, 3.1415926)
>>> general_info.insert(3, False)
>>> general_info.insert(4, 1)
>>> general_info
['Важные математические константы', 1j, 3.1415926, False, 1]

Как обратиться к элементам списка Python?

Есть три способа:

Оператор индекса
Оператор среза
Итерирование

Оператор индекса

Индекс используется для доступа к отдельному элементу.

>>> todo_list[2]
'Дорога до работы'
>>> general_info[1]
1j

Оператор среза

Срез применяется для обращения к нескольким элементам списка. Синтаксис: list_name[start:stop:step], где

start – индекс, с которого начинается срез (по умолчанию начало списка)
stop – индекс, до которого осуществляется срез (по умолчанию конец списка)
step – шаг приращения, по умолчанию равно 1

>>> general_info[:2]      # срез с начала до 2 индекса, не включая
['Важные математические константы', 1j]
>>> general_info[2:4]     # срез с индекса 2 по 3
[3.1415926, False]
>>> general_info[::2]     # чётные индексы
['Важные математические константы', 3.1415926, 1]

Обратите внимание: если указан индекс stop, то срез осуществляется вплоть до него, но исключая сам элемент.

Итерирование

Списки Python – итерируемые объекты. Для перебора элементов списка не нужен счетчик:

>>> for item in todo_list:
...     print(item)
... 
Завтрак, зарядка, душ
Чтение статей на proglib
Дорога до работы

Как удалить элемент из списка?

Всего два метода:

remove()
pop()

Удаление элемента методом remove()

remove() находит и удаляет элемент из списка:

>>> general_info.remove(False)
>>> general_info
['Важные математические константы', 1j, 3.1415926, 1]

Удаление элемента методом pop()

pop() удаляет и возвращает элемент, по умолчанию последний:

>>> general_info.pop()
1
>>> general_info.pop()
3.1415926
>>> general_info
['Важные математические константы', 1j]

О методах поподробнее

Посмотреть аттрибуты и функции объекта списка, как и других объектов Python, можно передав список функции dir(). Вот сокращенный вид выводимого функцией списка:

>>> dir(todo_list)
[...  'append', 'clear', 'copy', 'count', 'extend', 'index',
'insert', 'pop', 'remove', 'reverse', 'sort']

Ничего сложного, правда?

Обобщим и дополним примеры использования методов списков:

a.append(e) – добавляет переданную переменную e в конец списка a
a.clear() – удаляет все элементы из списка a
a.copy() – возвращает копию списка a
a.count(e) – возвращает число столько раз, сколько элемент e встречается в списке a
a.extend(b) – добавляет все элементы списка b в конец списка a
a.index(e) – находит и возвращает индекс первого элемента списка a, равного e
a.insert(i, e) – вставляет элемент e на позицию с индексом i
a.pop(i) – возвращает и удаляет элемент с индексом i (по умолчанию последний)
a.remove(e) – удаляет элемент e из списка a
a.reverse() – разворачивает в обратном порядке элементы списка a
a.sort() – сортирует элементы списка a в восходящем порядке

Когда использовать списки Python?

Используйте списки Python, если от структуры данных нужно следующее:

Хранить объекты данных нескольких типов.
Сохранять очередность элементов и порядок вставки.
Хранить повторяющиеся значения.
Изменять элементы.

Источник

Вам также могут быть интересны

Инструменты Python: лучшая шпаргалка для начинающих
13 лучших книг по Python для начинающих и продолжающих
Крутые модули Python, которые вы не используете, а надо бы

Источник