Разница между методами добавления и расширения в Python
В чем разница между методами списка append()
и extend()
20 ответов
append
: добавляет объект в конец.
x = [1, 2, 3]
x.append([4, 5])
print (x)
дает вам: [1, 2, 3, [4, 5]]
extend
: расширяет список, добавляя элементы из итерируемого.
x = [1, 2, 3]
x.extend([4, 5])
print (x)
дает вам: [1, 2, 3, 4, 5]
append
добавляет элемент в список, а extend
объединяет первый список с другим списком (или другим итеративным, не обязательно списком).
>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']
>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', ['new', 2]]
>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
Из погрузиться в Python . р>
В чем разница между методами списка, добавляющими и расширяющими?
-
append
добавляет свой аргумент как отдельный элемент в конец списка. Длина самого списка увеличится на один. -
extend
перебирает свой аргумент, добавляя каждый элемент в список, расширяя список. Длина списка увеличится, сколько бы элементов ни было в итерируемом аргументе.
append
Метод list.append
добавляет объект в конец списка.
my_list.append(object)
Независимо от объекта, будь то число, строка, другой список или что-то еще, он добавляется в конец my_list
как одна запись в списке.
>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']
Имейте в виду, что список - это объект. Если вы добавите другой список в список, первый список будет одним объектом в конце списка (что может быть не тем, что вы хотите):
>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
#^^^^^^^^^--- single item at the end of the list.
extend
Метод list.extend
расширяет список, добавляя элементы из итерируемого:
my_list.extend(iterable)
Таким образом, при расширении каждый элемент повторяемого элемента добавляется в список. Например:
>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]
Имейте в виду, что строка является итеративной, поэтому если вы расширяете список строкой, вы добавляете каждый символ при переборе строки (что может быть не тем, что вы хотите):
>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']
Перегрузка оператора, __add__
(+
) и __iadd__
(+=
)
Операторы +
и +=
определены для list
. Они семантически похожи на расширение.
my_list + another_list
создает третий список в памяти, поэтому вы можете вернуть его результат, но для этого требуется, чтобы вторая итерация была список.
my_list += another_list
изменяет список на месте (он является оператором на месте, а списки изменяемые объекты, как мы уже видели), поэтому он не создает новый список. Он также работает как расширение, так как вторая итерация может быть любой итерацией.
Не смущайтесь - my_list = my_list + another_list
не эквивалентно +=
- он дает вам новый список, назначенный my_list.
Сложность времени
Приложение имеет сложность с постоянным временем , O (1).
Расширение имеет временную сложность, O (k).
Итерация по нескольким вызовам append
увеличивает сложность, делая ее эквивалентной расширению, и поскольку итерация расширения реализована в C всегда будет быстрее, если вы собираетесь добавлять последовательные элементы из итерируемого в список.
Производительность
Вы можете задаться вопросом, что является более производительным, поскольку append можно использовать для достижения того же результата, что и extension. Следующие функции делают то же самое:
def append(alist, iterable):
for item in iterable:
alist.append(item)
def extend(alist, iterable):
alist.extend(iterable)
Итак, давайте их время:
import timeit
>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883
Обращение к комментарию о времени
Комментатор сказал:
Идеальный ответ, я просто не могу сравнить время добавления только одного элемента
Делай семантически правильную вещь. Если вы хотите добавить все элементы в итерацию, используйте extend
. Если вы просто добавляете один элемент, используйте append
.
Хорошо, давайте создадим эксперимент, чтобы увидеть, как это работает во времени:
def append_one(a_list, element):
a_list.append(element)
def extend_one(a_list, element):
"""creating a new list is semantically the most direct
way to create an iterable to give to extend"""
a_list.extend([element])
import timeit
И мы видим, что выход из нашего пути создания итерируемого только для использования расширения - это (незначительная) тратавремя:
>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295
Из этого мы узнаем, что ничего не получится от использования extend
, когда у нас есть только один элемент для добавления .
Кроме того, эти сроки не так важны. Я просто показываю им, что в Python выполнение семантически правильной вещи - это выполнение Right Way ™.
Вполне возможно, что вы можете протестировать время двух сопоставимых операций и получить неоднозначный или обратный результат. Просто сосредоточьтесь на том, чтобы делать семантически правильные вещи.
Заключение
Мы видим, что extend
семантически понятнее и может работать намного быстрее, чем append
, , когда вы собираетесь добавить каждый элемент в итерируемый список.
Если у вас есть только один элемент (не входящий в итерацию) для добавления в список, используйте append
.
append
добавляет один элемент. extend
добавляет список элементов.
Обратите внимание, что если вы передаете список для добавления, он все равно добавляет один элемент:
>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
Следующие два фрагмента семантически эквивалентны:
for item in iterator:
a_list.append(item)
и
a_list.extend(iterator)
Последнее может быть быстрее, поскольку цикл реализован на языке C.
Метод append () добавляет один элемент в конец списка.
x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']
Метод extend () принимает один аргумент - список и добавляет каждый элемент аргумента в исходный список. (Списки реализованы в виде классов. «Создание» списка - это действительно создание экземпляра класса. Таким образом, у списка есть методы, которые работают с ним.)
x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']
Из Dive Into Python .
Вы можете использовать «+» для возврата расширения, а не расширения на месте.
l1=range(10)
l1+[11]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]
l2=range(10,1,-1)
l1+l2
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]
Аналогично +=
для поведения на месте, но с небольшими отличиями от append
& extend
. Одно из самых больших отличий +=
от append
и extend
, когда он используется в областях функций, см. это сообщение в блоге .
Добавить против Расширить
![]()
С помощью append вы можете добавить один элемент, который будет расширять список:
>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]
Если вы хотите расширить более одного элемента, вам следует использовать extension, поскольку вы можете добавить только один элемент или один список элементов:
>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]
Чтобы вы получили вложенный список
Вместо этого вы можете расширять один элемент, как этот
>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]
Или, в отличие от append, расширяйте больше элементов за один раз, не вкладывая список в исходный (по этой причине расширение имени)
>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]
Добавление одного элемента с обоими методами
добавить 1 элемент
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
расширить один элемент
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]
Добавление дополнительных элементов ... с разными результатами
Если вы используете append для более чем одного элемента, вы должны передать список элементов в качестве аргументов, и вы получите список NESTED!
>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]
Вместо этого вы можете передать список в качестве аргумента, но вы получите список с новым элементом, который не вложен в старый.
>>> z = [1,2]
>>> z.extend([3,4])
>>> z
[1,2,3,4]
Итак, с большим количеством элементов вы будете использовать extends, чтобы получить список с большим количеством элементов. Вы будете использовать append, чтобы добавить не больше элементов в список, но один элемент, который является вложенным списком, как вы можете ясно увидеть в выводе кода.
append(object)
- обновляет список, добавляя объект в список.
x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]
extend(list)
- по существу объединяет два списка.
x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]
Это эквивалент append
и extend
используя оператор +
:
>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]
Интересный момент, который был намекнут, но не объяснен, заключается в том, что расширение происходит быстрее, чем добавление. Любой цикл, который имеет добавление внутри, должен рассматриваться как замененный list.extend (processing_elements).
Помните, что добавление новых элементов может привести к перераспределению всего списка в лучшее место в памяти. Если это делается несколько раз, потому что мы добавляем 1 элемент за раз, общая производительность страдает. В этом смысле list.extend аналогичен "" .join (stringlist).
Append добавляет все данные сразу. Все данные будут добавлены во вновь созданный индекс. С другой стороны, extend
, как следует из названия, расширяет текущий массив.
Например
list1 = [123, 456, 678]
list2 = [111, 222]
С помощью append
мы получаем:
result = [123, 456, 678, [111, 222]]
Находясь в extend
, мы получаем:
result = [123, 456, 678, 111, 222]
Английский словарь определяет слова append
и extend
as:
append : добавьте (что-то) в конец письменного документа.
вытянуть : сделать больше. Увеличить или расширить
С этим знанием теперь давайте разберемся
1) Разница между append
и extend
append
:
- Добавляет любой объект Python как есть в конец списка (то есть как последний элемент в списке).
- Результирующий список может быть вложенным и содержать гетерогенные элементы (то есть список, строка, кортеж, словарь, набор и т. д.)
extend
:
- Принимает любой итерируемый в качестве аргумента и увеличивает список больше .
- Результирующий список всегда является одномерным списком (т.е. без вложенности), и он может содержать в себе гетерогенные элементы (например, символы, целые числа, число с плавающей точкой) в результате применения
list(iterable)
.
2) Сходство между append
и extend
- Оба принимают ровно один аргумент.
- Оба изменяют список на месте .
- В результате оба возвращают
None
.
Пример
lis = [1, 2, 3]
# 'extend' is equivalent to this
lis = lis + list(iterable)
# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
lis.append(object)
Добавить словарь к другому:
>>>def foo():
dic = {1:'a', 2:'b', 3:'c', 4:'a'}
newdic = {5:'v', 1:'aa'}
for i in dic.keys():
if not newdic.has_key(dic[i]):
newdic[i] = dic[i]
print "Appended one:", newdic
>>>foo()
Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}
Метод "append" добавляет свой параметр в виде одиночного элемента в список, тогда как "extension" получает список и добавляет его содержимое.
Например,
продлить
letters = ['a', 'b']
letters.extend(['c', 'd'])
print(letters) # ['a', 'b', 'c', 'd']
Append
letters.append(['e', 'f'])
print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']]
Различать их интуитивно
l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]
Это как l1
воспроизводить тело внутри ее тела (вложенное).
# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']
Это похоже на то, что два раздельных человека женятся и создают единую семью.
Кроме того, я делаю исчерпывающую таблицу всех методов списка для вашей справки.
list_methods = {'Add': {'extend', 'append', 'insert'},
'Remove': {'pop', 'remove', 'clear'}
'Sort': {'reverse', 'sort'},
'Search': {'count', 'index'},
'Copy': {'copy'},
}
append () добавит переданный ему аргумент как один элемент.
extend () будет перебирать передаваемые аргументы и расширять список, передавая итерированные каждый элемент, в основном он будет добавлять несколько элементов, не добавляя целое как один.
list1 = [1,2,3,4,5]
list2 = [6,7,8]
list1.append(list2)
print(list1)
#[1,2,3,4,5,[6,7,8]]
list1.extend(list2)
print(list1)
#[1,2,3,4,5,6,7,8]
extend (L) расширяет список, добавляя все элементы в данный список L.
>>> a
[1, 2, 3]
a.extend([4) #is eqivalent of a[len(a):] = [4]
>>>a
[1, 2, 3, 4]
a =[1,2,3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
append
«расширяет» список (на месте) на только один элемент , один объект был передан (в качестве аргумента).
extend
«расширяет» список (на месте) на столько элементов, сколько пройденный объект ( в качестве аргумента) содержит.
Это может немного запутать объекты str
.
- Если вы передаете строку в качестве аргумента:
append
добавит один элемент строки в конце, ноextend
добавит столько «одиночных» элементов 'str', сколько длины этой строки. - Если вы передаете список строк в качестве аргумента:
append
все равно добавит один элемент списка в конец иextend
добавит столько элементов списка, сколько длина переданного списка.
def append_o(a_list, element): a_list.append(element) print('append:', end = ' ') for item in a_list: print(item, end = ',') print() def extend_o(a_list, element): a_list.extend(element) print('extend:', end = ' ') for item in a_list: print(item, end = ',') print() append_o(['ab'],'cd') extend_o(['ab'],'cd') append_o(['ab'],['cd', 'ef']) extend_o(['ab'],['cd', 'ef']) append_o(['ab'],['cd']) extend_o(['ab'],['cd'])
дает:
append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,
Append и extension являются одним из механизмов расширяемости в Python.
Append: добавляет элемент в конец списка.
my_list = [1,2,3,4]
Чтобы добавить новый элемент в список, мы можем использовать метод append следующим образом.
my_list.append(5)
Местоположение по умолчанию, в которое будет добавлен новый элемент, всегда находится в позиции (длина + 1).
Вставка. Метод вставки использовался для преодоления ограничений на добавление. С помощью вставки мы можем явно определить точное положение, в которое мы хотим вставить наш новый элемент.
Метод дескриптор вставки (индекс, объект). Он принимает два аргумента: во-первых, это индекс, который мы хотим вставить, а во-вторых, сам элемент.
Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']
Расширить: это очень полезно, когда мы хотим объединить два или более списков в один список. Без расширения, если мы хотим объединить два списка, результирующий объект будет содержать список списков.
a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]
Если мы попытаемся получить доступ к элементу в позиции 2, мы получим список ([3]) вместо элемента. Чтобы объединить два списка, нам нужно будет использовать append.
a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]
Чтобы присоединиться к нескольким спискам
a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]