Pytanie Różnica między metodami append vs. extend list w Pythonie


Jaka jest różnica między metodami listy append() i extend()?


2690
2017-10-31 05:55


pochodzenie




Odpowiedzi:


append: Dołącza obiekt na końcu.

x = [1, 2, 3]
x.append([4, 5])
print (x)

daje Ci: [1, 2, 3, [4, 5]]


extend: Rozszerza listę, dołączając elementy z iteracji.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

daje Ci: [1, 2, 3, 4, 5]


4090
2017-10-31 06:02



Jaka jest różnica pomiędzy extend i po prostu używając operatora dodawania - w powyższym przykładzie, x = x + [4, 5]? - Rohan
Właściwie to jest duża różnica - x + [4, 5] daje ci nową listę przypisaną do x - x.extend() zmienia oryginalną listę. Poniżej przedstawię moją odpowiedź. - Aaron Hall♦


append dodaje element do listy, i extend łączy pierwszą listę z inną listą (lub inną iterowalną, niekoniecznie listą).

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> 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']

Od Zanurz się w Pythonie.


525
2017-10-31 05:57





Jaka jest różnica między metodami dodawania i rozszerzania listy?

  • append dodaje swój argument jako pojedynczy element na końcu listy. Długość samej listy zwiększy się o jeden.
  • extend iteruje nad argumentem dodając każdy element do listy, rozszerzając listę. Długość listy wzrośnie o tyle, że wiele elementów było w argumentach iteracyjnych.

append

The list.append metoda dołącza obiekt do końca listy.

my_list.append(object) 

Niezależnie od obiektu, liczby, ciągu, innej listy lub czegoś innego, zostanie dodany na końcu my_list jako pojedynczy wpis na liście.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Należy więc pamiętać, że lista jest obiektem. Jeśli do listy dodasz inną listę, pierwsza lista będzie pojedynczym obiektem na końcu listy (która może nie być tym, czego potrzebujesz):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item on end of list.

extend

The list.extend metoda rozszerza listę przez dołączanie elementów z pliku iterowalnego:

my_list.extend(iterable)

Tak więc z rozszerzeniem każdy element iteracji zostaje dołączony do listy. Na przykład:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Pamiętaj, że ciąg jest iterowalny, więc jeśli rozszerzysz listę o łańcuch, dopiszesz każdy znak podczas iteracji po ciągu znaków (co może nie być tym, czego potrzebujesz):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Przeciążenie operatora, __add__, (+) i __iadd__ (+=)

Obie + i += operatorzy są zdefiniowani dla list. Są semantycznie podobne do przedłużenia.

my_list + another_list tworzy trzecią listę w pamięci, dzięki czemu możesz zwrócić jej wynik, ale wymaga ona, aby druga iterowalna była listą.

my_list += another_list modyfikuje listę w miejscu (to jest operator na miejscu i listy są zmiennymi obiektami, jak widzieliśmy), więc nie tworzy nowej listy. Działa również jak rozszerzyć, ponieważ druga iteracja może być dowolnego rodzaju iterowalna.

Nie daj się pomylić - my_list = my_list + another_list nie jest równoważne += - daje ci całkiem nową listę przypisaną do my_list.

Złożoność czasu

Append ma stała złożoność czasu, O (1).

Extend ma złożoność czasu, O (k).

Iterowanie przez wiele połączeń do append dodaje złożoności, czyniąc ją równoważną z rozszerzeniem, a ponieważ iteracja rozszerzenia jest zaimplementowana w C, zawsze będzie szybsza, jeśli zamierzasz dołączać kolejne elementy z listy iterowalnej do listy.

Wydajność

Możesz zastanawiać się, co jest bardziej wydajne, ponieważ append może być użyty do osiągnięcia tego samego rezultatu, co rozszerzenie. Poniższe funkcje robią to samo:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Czas więc je:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Adresowanie komentarza dotyczącego czasu

Komentujący powiedział:

Doskonała odpowiedź, brakuje mi czasu porównywania dodawania tylko jednego elementu

Zrób semantycznie poprawną rzecz. Jeśli chcesz dołączyć wszystkie elementy do iteracji, użyj extend. Jeśli dodajesz tylko jeden element, użyj append.

Ok, więc utwórzmy eksperyment, aby przekonać się, jak to działa na czas:

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

I widzimy, że wyjście z naszej drogi, aby stworzyć możliwość iteracji, aby tylko ją wykorzystać, to (niewielka) strata czasu:

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

Dowiadujemy się z tego, że nic nie zyskało z użycia extend kiedy mamy tylko jeden element do dołączenia.

Również te czasy nie są tak ważne. Po prostu pokazuję im, że w Pythonie robienie semantycznie poprawnych rzeczy polega na robieniu rzeczy Dobrze Droga.

Można sobie wyobrazić, że można przetestować czas na dwóch porównywalnych operacjach i uzyskać dwuznaczny lub odwrotny wynik. Po prostu skup się na robieniu semantycznie poprawnej rzeczy.

Wniosek

Widzimy to extend jest semantycznie czystszy i może działać znacznie szybciej niż append, kiedy zamierzasz dopisać każdy element w postaci iterowalnej do listy. 

Jeśli masz tylko jeden element (nie w wersji iterowalnej) do dodania do listy, użyj append.


268
2018-01-23 22:44



Doskonała odpowiedź, brakuje mi czasu porównywania dodawania tylko jednego elementu - David Sánchez
@Aaron Hall Jeden mały komentarz w algorytmie wyczucia czasu. "extend_one" może zwracać czas "nieco nieprawidłowy", ponieważ dotyczy to również tworzenia listy. Prawdopodobnie lepiej jest tworzyć elementy jako zmienne (ex1 = 0 i ex2 = [0]) i przekazuj te zmienne, jeśli chcesz być bardziej rygorystyczny. - ilias iliadis
Idealna odpowiedź w rzeczy samej. A co z wydajnością l1 += l2 vs l1.extend(l2)? - Jean-Francois T.


append dołącza pojedynczy element. extend dołącza listę elementów.

Zwróć uwagę, że jeśli przekażesz listę do dodania, nadal dodaje jeden element:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

92
2017-10-31 05:57





Poniższe dwa fragmenty są semantycznie równoważne:

for item in iterator:
    a_list.append(item)

i

a_list.extend(iterator)

Ten ostatni może być szybszy, ponieważ pętla jest zaimplementowana w C.


42
2017-08-20 21:11



Rozszerzenie na moim komputerze jest ~ 4x szybsze niż dołączanie w pętli (16us vs 4us dla 100 pętli zer) - Alex L
extend() prawdopodobnie preallocates, while append() prawdopodobnie nie. - Mad Physicist


Możesz użyć "+" dla przedłużenia, zamiast rozszerzania na miejscu.

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]

podobnie += dla zachowania na miejscu, ale z niewielkimi różnicami append & extend. Jedna z największych różnic += od append i extend jest, gdy jest używany w zakresach funkcji, patrz ten wpis na blogu.


29
2017-08-26 11:21



Czy użycie zwrotu "+" ma wpływ na złożoność czasu? - franklin
@franklin, zobacz tę odpowiedź dla szczegółów: stackoverflow.com/a/28119966/2230844 - denfromufa
Nie rozumiem, jak to odpowiada na pytanie - ppperry


Metoda append () dodaje pojedynczy element na końcu listy.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

Metoda extend () przyjmuje jeden argument, listę i dołącza każdy z argumentów do pierwotnej listy. (Listy są zaimplementowane jako klasy. "Tworzenie" listy naprawdę tworzy instancję klasy, dlatego lista zawiera metody, które działają na niej.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

Od Zanurz się w Pythonie.


29
2017-10-31 13:12



Nie możesz rozszerzyć o 6, ponieważ nie jest to możliwe. Drugie wyjście w twoim przykładzie jest błędne. "abc" jest dodawany jako pojedynczy element od momentu, w którym go przekazałeś extend jako listę z jednym elementem ['abc']: [1, 2, 3, 4, 5, "abc"]. Aby poprawić poprawność przykładowego wyniku, zmień linię abc na: x.extend('abc'). I usuń x.extend(6) lub zmień na x.extend([6]). - aneroid


 Dołącz lub rozszerzaj

enter image description here

Za pomocą append możesz dodać pojedynczy element, który rozszerzy listę:

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

Jeśli chcesz rozszerzyć więcej niż jeden element, powinieneś użyć rozszerzenia, ponieważ możesz dodać tylko jeden element lub jedną listę elementów:

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

Aby uzyskać listę zagnieżdżoną

Zamiast tego możesz rozszerzyć pojedynczy element, taki jak ten

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

Lub, inaczej niż w dołączeniu, rozszerzaj więcej elementów w jednym czasie bez zagnieżdżania listy w oryginalnej (to jest powód przedłużenia nazwy)

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

 Dodanie jednego elementu za pomocą obu metod

enter image description here

 dołącz 1 element

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

 przedłużyć jeden element

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]

 Dodawanie kolejnych elementów ... z różnymi wynikami

Jeśli używasz append dla więcej niż jednego elementu, musisz przekazać listę elementów jako argumenty, a otrzymasz listę NESTED!

>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]

Z rozszerzeniem zamiast tego podajesz listę jako argument, ale otrzymasz listę z nowym elementem, który nie jest zagnieżdżony w starym.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

Tak więc, z większą ilością elementów, użyjesz rozszerzenia, aby uzyskać listę z większą liczbą elementów. Będziesz używał append, aby dołączyć nie więcej elementów do listy, ale jeden element, który jest listą zagnieżdżoną, jak widać wyraźnie na wyjściu kodu.

enter image description here

enter image description here


17
2017-10-18 07:33



To jest najlepsza odpowiedź - Billal BEGUERADJ