Как выглядит инструкция добавления элемента 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() — поочерёдно добавляют элементы одного списка в другой.

Научитесь: Профессия Python-разработчик
Узнать больше

Источник

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

Что такое список
Как списки хранятся в памяти?
Базовая работа со списками
Объявление списка
Обращение к элементу списка в 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"] >>> print(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. Вы узнаете о методе .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.

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

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 очень легко добавлять элементы в список. Мы можем добавить элемент в конец списка, вставить элемент по заданному индексу. Мы также можем добавить список в другой список. Если вы хотите объединить несколько списков, используйте перегруженный оператор +.

( 17 оценок, среднее 4.24 из 5 )

Источник

Синтаксис:

Параметры:

sequence — изменяемая последовательность, list или bytearray,
x — произвольный объект, удовлетворяющий любым ограничениям типа и значения, наложенным sequence.

Результат:

новый элемент в конце последовательности sequence.

Описание:

Операция позволяет добавить в конец последовательности новый объект x. Метод sequence.append() производит добавление элемента x в конец последовательности sequence.

Операция добавления в конец последовательности объекта x эквивалентна выполнению выражения sequence[len(sequence):len(sequence)] = [x]

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

Для добавления нескольких значений в конец списка смотрите метод list.extend()

Примеры добавления одного значения в конец списка.

>>> x = [3, 6, 9]
>>> x.append(150)
>>> x
# [3, 6, 9, 150]
>>> x.append([150, 200])
>>> x
# [3, 6, 9, 150, [150, 200]]
>>> x.append('foo')
>>> x
# [3, 6, 9, 150, [150, 200], 'foo']
>>> x.append(('one', 'two'))
>>> x
# [3, 6, 9, 150, [150, 200], 'foo', ('one', 'two')]

Альтернативная операция добавления одного значения в конец списка.

# добавление одного элемента в конец списка
# альтернатива операции x.append(1.3)
>>> x = [1, 1.1, 1.2]
>>> x += [1.3]
>>> x
# [1, 1.1, 1.2, 1.3]

# БУДЬТЕ ВНИМАТЕЛЬНЫ!!! нужно 
# добавлять список из одного элемента
>>> x += 1.4
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'float' object is not iterable

# БУДЬТЕ ОСТОРОЖНЫ!!!
# строка представляет из себя кортеж
>>> x += '1.4'
>>> x
# [1, 1.1, 1.2, 1.3, '1', '.', '4']

# что таким способом добавить строку 
# оберните ее в квадратные скобки
>>> x += ['123']
>>> x
# [1, 1.1, 1.2, 1.3, '1', '.', '4', '123']

Источник

Python List .append() – How to Add an Item to a List in Python

Lists are one of the most useful and versatile data types available in Python. Lists are a collection of arbitrary objects, just like arrays in other programming languages.

In this tutorial you will learn:

An overview of lists and how they are defined.
Methods to insert data in a list using: list.append(), list.extend and list.insert().
Syntax, code examples, and output for each data insertion method.
How to implement a stack using list insertion and deletion methods.

Prerequisites

For this tutorial, you need:

Python 3.
A code editor of your choice.

Lists in Python

Lists have the following properties that make them powerful and flexible:

Lists are ordered.
Lists are accessed using the index. The first index starts at 0.
Lists are mutable and dynamic which means they can be modified after their creation.

How to create a list in Python

You create a list using square brackets in Python.

We can leave them empty and supply values later in the program:

# Create an empty list

programming_lang = []

We can also provide values while creating a list:

# Create a filled list

programming_lang = ['P','Y','T','H','O','N']

This would create a list as shown in the image below:

List items against indexes

How to access items in a list

As list items are ordered, you can access them using their index.

Syntax: list[index].

In the image below, «P» is at index «0» whereas «H» is at index «3».

Let’s write a short program to define a list and access its items:

programming_lang = ['P','Y','T','H','O','N']

print(programming_lang)

print("At index 0:", programming_lang[0])
print("At index 3:",programming_lang[3])

Defining and printing a list

Output:

You can also access items using a negative index, where -1 represents the last list item. If we wanted to access the last item from the list above, we could also use index -1:

programming_lang = ['P','Y','T','H','O','N']

print(programming_lang)

print("At index -1:", programming_lang[-1])
print("At index -5:",programming_lang[-5])

Accessing list via negative index.

Output:

How to find the length of a list

We can easily find the length of a list using the len() method.

programming_lang = ['P','Y','T','H','O','N']

print("Length of List: ",len(programming_lang))

Finding the length of a list

Output:

Finding a list's length.

Finding a list’s length.

Methods to Add Items to a List

We can extend a list using any of the below methods:

list.insert() – inserts a single element anywhere in the list.
list.append() – always adds items (strings, numbers, lists) at the end of the list.
list.extend() – adds iterable items (lists, tuples, strings) to the end of the list.

How to insert items in a list with `insert()`

You can insert items in a list at any index using the insert() method. There are more insertion methods and we will look at them later in this post.

Syntax of insert: insert(index, element).

Example of insert():

# create a list of odd numbers
odd_n = [1,3,5,7,9]

# '21' is inserted at index 3 (4th position)
odd_n.insert(3, 21)


print('List of odd #:', odd_n)

Before insertion:

After insertion:

Output:

How to append an item to a list using `list.append()`

We can add a single item at the end of the list using list.append().

Syntax: list.append(item).

Example:

# crops list
crops = ['corn', 'wheat', 'cotton']

# Add 'cane' to the list
crops.append('cane')

print('Updated crops list: ', crops)

Output:

⚠️Note that trying to append more than one item gives an exception, as list.append() takes only a single argument.

Unable to add multiple items using list.append().

Unable to add multiple items using list.append().

How to add multiple items in a list using `list.extend()`

We can add multiple items to a list using the extend() method.

The below example combines two lists into a single list.

# create a list
even_numbers = [2, 4, 8]

# create another list
more_even_numers = [100, 400]

# add all elements of even_numbers to more_even_numbers
even_numbers.extend(more_even_numers)


print('List after extend():', even_numbers)

Output:

Extending a list using extend().

Extending a list using extend().

Other ways to extend lists in Python:

List slicing

Slicing allows us to select a range of values in a list.

The syntax is shown below:

list[starting index:upto index]

For example,

list[1:3] would return items starting from index 1 up to (not including) index 3.
Missing left index implies starting from index 0.
- list[:len(list)] means start from index 0 and continue until the end.
Missing right index implies until the last index.
- list[0:] implies to start from index 0 until the last item.

Let’s see how we can add lists using slicing.

Example:

A = [99, 100, 101]
B = [103, 104, 105]

# starting from last index +1, add items from list B

A[len(A):] = B

print('A =', A)

Output:

Combining arrays using the + operator

Let’s combine two arrays odd and even into a single list using the + operator.

Example:

odd = [1, 3, 5, 7]
even = [2, 4, 6, 8]

odd += even    # odd = odd + even


# Output: [1, 2, 3, 4]
print('odd and even combined =', odd)

Output:

How to populate an empty list using `for loop` and `append()`

There are two ways to populate empty lists: using a for loop with append() and using list comprehension.

Let’s first use for loop with append().

Example:

In this example, we are calculating area of a square and appending the result in an array.

# Return area of square
# Area of square = length x length

def square_area(side_length):
     result = []
     for length in side_length:
         result.append(length*length)
     return result


lengths = [1, 4, 9, 20]
print(square_area(lengths))

Output:

We can make the above code efficient by completely skipping the for loop - append() combination and using list comprehension instead. Let’s see how in the next section.

How to populate an empty list using list comprehension

List comprehension makes the code simple and readable by combining the for loop and append() into a single line.

We can modify our previous example to achieve list comprehension. Notice the commented out lines here:

# Return area of square
# Area of square = length x length

def square_area(side_length):
     #result = []
     #for length in side_length:
     #    result.append(length*length)
     return [length*length for length in side_length]


lengths = [1, 4, 9, 20]
print(square_area(lengths))

return [length*length for length in side_length] is list comprehension.

Output:

Both of the methods for filling an empty list are valid and suitable in different scenarios.

`Append()` vs `Insert()` vs `Extend()`

Append() always adds a single item at the end of a list. It is useful when only a single item needs to be inserted.

But if you need to make multiple additions, extend() is a better option as it adds iterable items in one batch.

You should use Insert() when insertion is required at a specific index or range of indexes.

How to Implement a Stack (LIFO)

What is a stack (LIFO)?

Stack is an arrangement of items that follows a last-in-first-out order. The item that goes last is the one that comes out first. An example of a stack would be the undo/redo stack in photo editing apps.

The diagram below visually explains a stack.

You can add an item by using append().

You can remove an item by using pop(). See details of the pop() method here.

Queue visualization

Coding stacks

Let’s create a stack class where we first declare an empty list in the init method.

The push() method appends an item to the list.

The pop() method deletes the last item of the list using pop(). If there is no item in the list, an exception will be thrown.

The __len__ method determines the length of the stack.

Lastly, __repr__ returns the output in a readable format.

Class definition:

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

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

    def pop(stack_t):
        try:
            return stack_t._items.pop()
        except IndexError:
            print("Stack is empty, all items deleted")

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

    def __repr__(stack_t):
        return f"stack ({stack_t._items})"

Code body:

Let’s call the class functions and see the output in action.

stack = Stack()

# Push items onto the top of the stack
stack.push(3)
stack.push(5)
stack.push(8)
stack.push(99)

 # Print stack

print(stack)

# Find the length of the stack
print("Length of stack is:" ,len(stack))


# Pop items from the stack
print("popping last item")
stack.pop()
print(stack)

print("popping last item again")
stack.pop()
print(stack)

print("finally the stack is")

print(stack)

Output:

We have added 3, 5, 8, 99 to the stack. Next we printed the stack and its length. Afterwards, we popped two items and printed the stack each time.

Wrapping up

In this tutorial, we learned list creation methods. We also looked at some examples along with a practical implementation of stacks to see how it all works.

What’s your favorite thing you learned from this tutorial? Let me know on Twitter!

You can read my other posts here.

Learn to code for free. freeCodeCamp’s open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Источник

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

Список — это структура данных для хранения объектов с различными типами данных. В каком-то смысле его можно назвать «динамическим» массивом: в Python они практически не накладывают ограничения на количество данных в нём (максимальный размер зависит от параметра sys.maxsize и битности операционной системы) и тип этих данных.

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

Переобъявление

Самый простой и «топорный» способ в Python добавить элемент в список — объявить объект заново:

example_list = [10,11,12]
print(example_list)example_list = [10,11,12,13]
print(example_list)

Вывод:

[10, 11, 12]
[10, 12, 13, 14]

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

Метод append()

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

AppendList.append(object), где

AppendList — список, в который добавляется элемент;
object — новый объект.

Вот пример, как добавить элемент в конец списка Python с помощью append():

AppendList= [11,12,13]
print(AppendList)AppendList.append(14)
print(AppendList)
AppendList.append('another type')
print(AppendList)

Вывод:

[11, 12, 13]
[11, 12, 13, 14]
[11, 12, 13, 14, 'another type']

В Python добавить элемент в пустой список можно с помощью append():

AppendList = []
AppendList.append('timeweb')print(AppendList)

Вывод:

['timeweb']

В качестве нового объекта может выступать другой список:

AppendList = [11,12,13]AddList = [14,15]
AppendList.append(AddList)
print(AppendList)

Вывод:

[11, 12, 13, [14, 15]]

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

Метод extend()

Метод extend() позволяет объединить два списка. Вот синтаксис метода:

ExtendList.extend(iterable_object), где

ExtendList — список, в который добавляются объекты;
iterable_object — объект, чьи элементы будут добавлены в ExtendList.

Перейдем к практической части. Вот как добавить несколько элементов в список Python с помощью extend():

ExtendList= [11,12,13]AddList = [14,15]
ExtendList.extend(AddList)
print(ExtendList)

Вывод:

[11, 12, 13, 14, 15]

Также extend() работает с любыми итерируемыми объектами. Что такое итерируемый объект?

Итерируемый объект — это объект, который может возвращать свои элементы по одному. Списки, кортежи, словари, строки — всё это итерируемые объекты. Рассмотрим, как extend() работает с этими объектами:

ExtendList = [11,12,13]AddDictionary = {'first': 1, 'second': 2}
AddString = 'timeweb.cloud'
AddTuple = (14,15,16,17)
ExtendList.extend(AddDictionary)
print('Extend with dictionary:', ExtendList)
ExtendList.extend(AddString)
print('Extend with string:', ExtendList)
ExtendList.extend(AddTuple)
print('Extend with tuple:', ExtendList)

Вывод:

Extend with dictionary: [11, 12, 13, 'first', 'second']
Extend with string: [11, 12, 13, 'first', 'second', 't', 'i', 'm', 'e', 'w', 'e', 'b', '.', 'c', 'l', 'o', 'u', 'd']
Extend with tuple: [11, 12, 13, 'first', 'second', 't', 'i', 'm', 'e', 'w', 'e', 'b', '.', 'c', 'l', 'o', 'u', 'd', 14, 15, 16, 17]

Вместо непосредственно extend() можно использовать знак сложения +. Такой способ будет работать точно также:

ExtendList = [11,12,13]AddList = [14,15,16]
ExtendList+= AddList
print(ExtendList)
ExtendList = ExtendList + AddList
print(ExtendList)

Вывод:

[11, 12, 13, 14, 15, 16]
[11, 12, 13, 14, 15, 16, 14, 15, 16]

Метод insert()

Чтобы добавить элемент в список Python по индексу, нужно использовать метод insert(). Он помещает элемент на выбранную пользователем позицию. Вот его синтаксис:

InsertList.insert(pos, element), где

InsertList — искомый список;
pos — первый входной аргумент, позицию нового элемента;
element — объект, который хотим добавить.

Вот как в Python добавить элемент в начало списка:

InsertList = [11,12,13]InsertList.insert(0,10')
print(InsertList)

Вывод:

[10, 11, 12, 13]

Другие примеры использования:

InsertList = [11,12,13]InsertList.insert(1,'b')
print(InsertList)
InsertList.insert(4,'c')
print(InsertList)

Вывод:

[11, 'b', 12, 13]
[11, 'b', 12, 13, 'c']

А вот код, как добавить элемент в середину списка Python:

InsertList= [11,12,13]InsertList.insert(len(InsertList)//2,'a')
print(InsertList)
InsertList.insert(len(InsertList)//2,'middle')
print(InsertList)

Вывод:

[11, 'a', 12, 13]
[11, 'a', 'middle', 12, 13]

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

InsertList= [11,12,13]InsertList.insert(-20,'a')
print(InsertList)
InsertList.insert(20,'b')
print(InsertList)

Вывод:

['a', 11, 12, 13]
['a', 11,12, 13, 'b']

Конкатенация

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

Конкатенация с помощью символа звездочки *:

ConcatenatedList= [11,12,13]new_list = [ConcatenatedList, 14]
print(new_list)
new_list = [*ConcatenatedList, 14]
print(new_list)

Вывод:

[[11, 12, 13], 14]
[11, 12, 13, 14]

Как видим, в первом случае добавляется объект, а во втором — его содержимое.

Конкатенация с помощью вложенного цикла:

FirstList = [11, 12, 13, 14, 15]
SecondList = [16, 17, 18]
result = [j for i in [FirstList, SecondList] for j in i] 
print (result)

Вывод:

[11, 12, 13, 14, 15, 16, 17, 18]

Конкатенация с помощью itertools.chain():

import itertools 
FirstList = [11,12,13,14,15] 
SecondList = [16,17,18]
result = list(itertools.chain(FirstList, SecondList))print(result)

Вывод:

[11, 12, 13, 14, 15, 16, 17, 18]

Добавления помощью среза

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

SliceList[START_POS: STOP_POS: STEP], где

SliceList— искомый список;
START_POS — индекс первого объекта в выборке;
STOP_POS — индекс объекта, обозначающий конец выборки. Сам объект в выборку не входит;
STEP — это шаг выборки. Например, если шаг 2, то объекты попадут в выборку через 1.

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

SliceList = [0,1,2,3,4,5,6,7,8,9]new_list = SliceList[0:10:2]
print(new_list)

Вывод:

[0, 2, 4, 6, 8]

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

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

SliceList[START:] = iterable, где

SliceList— это искомый список;
START — позиция, с которой должны идти элементы
iterable — это итерируемый объект, элементы которого попадут в список.

Пример со строкой:

slice_list = [0,1,2,3,4,5,6,7,8,9]slice_string = 'timeweb'
slice_list[len(slice_list):] = slice_string
print(slice_list)

Вывод:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 't', 'i', 'm', 'e', 'w', 'e', 'b']

Пример с другим списком:

slice_list = [0,1,2,3,4,5,6,7,8,9]slice_list2 = [10,11,12]
slice_list[len(slice_list):] = slice_list2
print(slice_list)

Вывод:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Также полезно знать, что срезы можно использовать для замещения части списка:

odd_list = [1,1,3,3,5,5,7,7,9,9]even_list = [0,2,4,6,8]
odd_list[0:10:2] = even_list
print(odd_list)

Вывод:

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

Подведем итоги

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

Источник

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

Синтаксис

Метод append() имеет следующий синтаксис:

list.append(element)

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

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

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

fruits = ['apple', 'banana', 'cherry']
fruits.append('orange')

print("Список после добавления элемента:", fruits)

#Список после добавления элемента: ['apple', 'banana', 'cherry', 'orange']

Пример 2: Добавление элементов в список с использованием цикла

numbers = []

for i in range(5):
    numbers.append(i)

print("Список чисел:", numbers)

#Список чисел: [0, 1, 2, 3, 4]

Пример 3: Добавление элементов из одного списка в другой

list1 = [1, 2, 3]
list2 = [4, 5, 6]

for item in list2:
    list1.append(item)

print("Объединенный список:", list1)

#Объединенный список: [1, 2, 3, 4, 5, 6]

Обратите внимание, что в этом случае можно также использовать метод extend() для объединения двух списков.

Пример 4: Создание вложенного списка с использованием метода append()

list1 = [1, 2, 3]
list2 = [4, 5, 6]

list1.append(list2)

print("Список с вложенным списком:", list1)

#Список с вложенным списком: [1, 2, 3, [4, 5, 6]]

Особенности метода append()

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

Заключение

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

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

Источник

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

Быстрый путеводитель по Python: cписки за 7 минут

Когда речь идет о массивах, обычно мы подразумеваем набор однородных элементов. Но в 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, которые вы не используете, а надо бы

Источник

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Срезы

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

Best Practices

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Заключение

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

1. append()

2. insert()

3. extend()

Заключение

Синтаксис:

Параметры:

Результат:

Описание:

Примеры добавления одного значения в конец списка.

Альтернативная операция добавления одного значения в конец списка.

Prerequisites

Lists in Python

How to create a list in Python

How to access items in a list

How to find the length of a list

Methods to Add Items to a List

How to insert items in a list with insert()

How to append an item to a list using list.append()

How to add multiple items in a list using list.extend()

Other ways to extend lists in Python:

List slicing

Combining arrays using the + operator

How to populate an empty list using for loop and append()

How to populate an empty list using list comprehension

Append() vs Insert() vs Extend()

How to Implement a Stack (LIFO)

What is a stack (LIFO)?

Coding stacks

Wrapping up

Переобъявление

Метод append()

Метод extend()

Метод insert()

Конкатенация

Добавления помощью среза

Подведем итоги

Синтаксис

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

Особенности метода append()

Заключение

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

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

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

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

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

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

How to insert items in a list with `insert()`

How to append an item to a list using `list.append()`

How to add multiple items in a list using `list.extend()`

How to populate an empty list using `for loop` and `append()`

`Append()` vs `Insert()` vs `Extend()`