Добавить в список Python

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

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

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

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

1. list Добавляйте элементы в список, используя методы Python
2. Добавление элементов в список с помощью объединения списков в Python
3. Добавляйте элементы в список, используя нотацию среза в Python
4. Добавьте элементы Python в список с помощью List Comprehension

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

В Python классlist служит основой для всех операций со списками. Класс определяет ряд методов для объектов списка. К ним относятся три метода, которые полезны для добавления элементов в список:

list-Метод	Аргумент	Объяснение
append()	element	Добавить один элемент в конец списка
extend()	[elements]	Добавить несколько элементов в конец списка
insert()	index, element	Добавьте один элемент перед данным индексом

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

# List of prime numbers
primes = [2, 3, 5, 7]
# Append additional prime number, saving returned result
should_be_none = primes.append(11)
# Show that the prime was added
assert primes == [2, 3, 5, 7, 11]
# Show that `None` was returned
assert should_be_none is None

Добавьте один элемент в конец списка с помощью метода Append()

Метод Pythonappend() можно использовать для добавления одного элемента в конец существующего списка. Проиллюстрируем поведение на примере:

# List containing single prime number
primes = [2]
# Add an element to the end of the list
primes.append(3)
# Show that the element was added
assert primes == [2, 3]

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

# List with two prime numbers
primes = [2, 3]
# Try to appends multiple numbers at once
primes.append([5, 7])
# Accidentally created a nested list
assert primes == [2, 3, [5, 7]]

Наша попытка создать список не удалась. Чтобы добавить несколько элементов, лучше использовать метод.[2, 3, 5, 7]extend()

Используйте метод расширения() для добавления элементов в конец списка

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

# List containing single prime number
primes = [2]
# Extend list by two elements
primes.extend([3, 5])
# Show that both element were added
assert primes == [2, 3, 5]

Будьте осторожны — метод ожидает в качестве аргумента итерацию и распаковывает ее элементы. Это приводит к удивительному поведению при вызове со строкой:extend()

# List of friends
friends = ['Mary', 'Jim']
# Try to extend by additional friend
friends.extend('Jack')
# String is unpacked into individual letters
assert friends == ['Mary', 'Jim', 'J', 'a', 'c', 'k']

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

# List of friends
friends = ['Mary', 'Jim']
# Extend by additional friend inside list
friends.extend(['Jack'])
# Show that it worked
assert friends == ['Mary', 'Jim', 'Jack']

Используйте Insert(), чтобы добавить один элемент перед указанным индексом

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

# List of friends
friends = ['Mary', 'Jim', 'Jack']
# Insert additional friend `"Molly"` before index `2`
friends.insert(2, 'Molly')
# Show that "Molly" was added
assert friends == ['Mary', 'Jim', 'Molly', 'Jack']

Будьте осторожны при попытке добавить несколько элементов — поскольку вставляется ровно один элемент, мы непреднамеренно создаём вложенный список :insert()insert()

# List of friends
friends = ['Mary', 'Jim']
# Try to insert multiple friends at once
friends.insert(1, ['Molly', 'Lucy'])
# Accidentally created a nested list
assert friends == ['Mary', ['Molly', 'Lucy'], 'Jim']

Чтобы правильно вставить несколько элементов в список, мы используем forцикл. Мы также используем функцию для сохранения порядка вставленных элементов:reversed()

# List of friends
friends = ['Mary', 'Jim']
# Using `reversed()` keeps order of inserted elements
for friend in reversed(['Molly', 'Lucy']):
  friends.insert(1, friend)

# Show that it worked
assert friends == ['Mary', 'Molly', 'Lucy', 'Jim']

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

listПомимо представленных методов, конкатенация списков — это еще один способ добавления элементов в список Python. +Для этого используется оператор Python. Объединение списков примерно эквивалентно использованию. Однако при конкатенации создается новый список, а не работает на месте.extend()

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

# List of guys
guys = ['Jim', 'Jack']
# List of gals
gals = ['Molly', 'Mary']
# Concatenate both lists
folks = guys + gals
# Show that it worked
assert folks == ['Jim', 'Jack', 'Molly', 'Mary']

Под капотом оператор конкатенации вызывает метод__add__(). Таким образом, выражения и эквивалентны:guys + galsguys.__add__(gals)

# Show that both expressions return the same result
assert guys + gals == guys.__add__(gals)

Если вы знакомы с операторами Python, возможно, вы уже догадались. Объединение списков также поддерживает расширенное присвоение. Он +=использует оператор для добавления элементов в список на месте:

# Shopping list
groceries = ['Milk', 'Bread', 'Eggs']
# Add butter
groceries += ['Butter']
# Show that it worked
assert groceries == ['Milk', 'Bread', 'Eggs', 'Butter']

Оператор +=вызывает метод, где «i» означает «на месте». Аналогично методу, получатель метода модифицируется напрямую. Таким образом, следующие строки эквивалентны:__iadd__()extend()

• groceries = groceries + [’Butter’]
• groceries += [’Butter’]
• groceries.__iadd__([’Butter’])
• groceries.extend([’Butter’])

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

# List of cities
cities = ['London', 'Paris']
# Attempt to add city; likely not what you intended
cities += 'Rome'
# String is unpacked into individual letters
assert cities = ['London', 'Paris', 'R', 'o', 'm', 'e']

Использование списка из одного элемента приводит к, вероятно, желаемому эффекту добавления в список еще одного города:

# List of cities
cities = ['London', 'Paris']
# Create a single-element list
cities += ['Rome']
# Now the entire string is added
assert cities = ['London', 'Paris', 'Rome']

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

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

# The `slice()` function constructs a new `slice` object
slice(start, stop, step=1)

Существует также «сокращенная» запись для создания объектов среза в сочетании с оператором индекса :[]

# Select items of list
lst[start:stop:step]

Объект Slice можно использовать вместо числового индекса для выбора нескольких элементов в последовательности:

people = ['Jim', 'John', 'Mary', 'Jack']
# Select elements between index `1` (inclusive) and `3` (exclusive)
assert people[1:3] == ['John', 'Mary']
# Select every other element
assert people[::2] == ['Jim', 'Mary']

В сочетании с присваиваниями срезы можно использовать как альтернативу listметодам, и :append()extend()insert()

list-Метод	Соответствующее назначение фрагмента	Объяснение
lst.append(element)	lst[len(lst)+1:] = [element]	Добавить элемент в конец списка
lst.extend([elements])	lst[len(lst)+1:] = [elements]	Добавить несколько элементов в конец списка
lst.insert(index, element)	lst[index:index] = [element]	Добавить элемент перед данным индексом

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

# List of groceries
groceries = ['Milk', 'Bread', 'Eggs']
# Overwrite element at index `1`
groceries[1] = 'Fruit'
# Show that it worked
assert groceries == ['Milk', 'Fruit', 'Eggs']

А что, если мы хотим вставить элемент путем присвоения индекса ? Мы используем срез, содержащий желаемый индекс как startи stopзначения. Чтобы назначение среза работало, справа от знака равенства должен быть список:

# List of groceries
groceries = ['Milk', 'Bread', 'Eggs']
# Insert element before index `1`
groceries[1:1] = ['Fruit']
# Show that it worked
assert groceries == ['Milk', 'Fruit', 'Bread', 'Eggs']

Этот трюк можно использовать даже для вставки сразу нескольких элементов в список Python — метод этого сделать не может:insert()

# List of groceries
groceries = ['Milk', 'Bread', 'Eggs']
# Insert elements before index `1`
groceries[1:1] = ['Fruit', 'Butter']
# Show that it worked
assert groceries == ['Milk', 'Fruit', 'Butter', 'Bread', 'Eggs']

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

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

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

1. Создать пустой список
2. Создание элементов в цикле
3. Развернуть список по созданному элементу

В качестве примера рассмотрим создание списка из первых десяти квадратных чисел :

# Empty list to be filled
squares = []
# Successively create numbers 0..9
for n in range(10):
  # Compute squared number
  squared = n * n
  # Append squared number to list
  squares.append(squared)

# Show that it worked
assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Однако в Python есть лучший подход. Мы используем так называемое понимание списка и используем его для создания списка без forцикла и пустых переменных списка:

# Create first ten square numbers
squares = [n ** 2 for n in range(10)]
# Show that it worked
assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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