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

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ę, dodając elementy z iterowalnego.

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

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

appenddodaje 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.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

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

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']

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

• appenddodaje swój argument jako pojedynczy element na końcu listy. Długość samej listy wzrośnie o jeden.
• extenditeruje swój argument, dodając każdy element do listy, rozszerzając listę. Długość listy wzrośnie o tyle, ile wielu elementów było w iterowalnym argumencie.

append

list.appendMetoda dołącza obiekt na końcu listy.

my_list.append(object) 

Niezależnie od tego, czy jest to obiekt, czy to liczba, ciąg, inna lista czy coś innego, zostaje dodany na końcu my_listjako pojedynczy wpis na liście.

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

Pamiętaj więc, że lista jest obiektem. Jeśli dodasz inną listę do listy, pierwsza lista będzie pojedynczym obiektem na końcu listy (co może nie być tym, czego chcesz):

>>> 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.extendSposób obejmuje listę przez dodanie elementów z iterowalny:

my_list.extend(iterable)

Zatem z rozszerzeniem każdy element iterowalny zostaje dodany 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 ciąg, dołączysz każdy znak podczas iteracji nad ciągiem (co może nie być tym, czego chcesz):

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

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

Zarówno +i +=operatorzy są zdefiniowane dla list. Są semantycznie podobne do rozszerzenia.

my_list + another_list tworzy trzecią listę w pamięci, więc możesz zwrócić wynik, ale wymaga to, aby druga iterowalna była lista.

my_list += another_listmodyfikuje listę w miejscu (jest to operator lokalny, a listy są obiektami zmiennymi, jak widzieliśmy), aby nie tworzyła nowej listy. Działa również jak przedłużyć, ponieważ druga iterowalność może być dowolną iterowalną.

Nie daj się pomylić - my_list = my_list + another_listnie jest równoważne z+= daj - daje ci zupełnie nową listę przypisaną do mojej_listy.

Złożoność czasu

Dołącz ma stałą złożoność czasową , O (1).

Wydłużenie ma złożoność czasową, O (k).

Iterowanie przez wiele wywołań w appendcelu zwiększenia złożoności, czyniąc je równoważnym z rozszerzeniem, a ponieważ iteracja rozszerzenia jest zaimplementowana w C, zawsze będzie szybciej, jeśli zamierzasz dołączyć kolejne elementy z iterowalnej do listy.

Wydajność

Możesz się zastanawiać, co jest bardziej wydajne, ponieważ append może być użyty do osiągnięcia tego samego rezultatu co rozszerzenie. Następujące 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 ich:

import timeit

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

Adresowanie komentarza na temat terminów

Komentator powiedział:

Idealna odpowiedź, po prostu brakuje mi czasu porównania dodając tylko jeden element

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

Ok, więc stwórzmy eksperyment, aby zobaczyć, jak to działa w czasie:

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

Widzimy, że wyjście z naszej drogi, aby stworzyć iterowalną opcję użycia przedłużyć, jest (niewielką) stratą 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 extendzyskujemy na używaniu, gdy mamy tylko jeden element do dołączenia.

Te czasy nie są tak ważne. Po prostu pokazuję im, aby stwierdzili, że w Pythonie robienie semantycznie poprawnych rzeczy jest robieniem rzeczy we właściwy sposób ™.

Można sobie wyobrazić, że możesz przetestować czasy dla dwóch porównywalnych operacji i uzyskać niejednoznaczny lub odwrotny wynik. Skoncentruj się na robieniu semantycznie poprawnej rzeczy.

Wniosek

Widzimy, że extendjest to semantycznie wyraźniejsze i że może działać znacznie szybciej niż wtedyappend , gdy zamierzasz dołączyć każdy element w iterowalnej liście.

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

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

Pamiętaj, że jeśli prześlesz listę do dołączenia, nadal dodaje jeden element:

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

Append vs Extend

Za pomocą append możesz dołączyć 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ć przedłużyć, ponieważ możesz dołączyć tylko jeden element lub jedną listę elementów:

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

Aby uzyskać zagnieżdżoną listę

Zamiast tego z rozszerzeniem możesz przedłużyć taki pojedynczy element

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

Lub, inaczej niż w append, rozszerzaj więcej elementów za jednym razem bez zagnieżdżania listy w oryginalnym (to jest powód rozszerzenia nazwy)

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

Dodanie jednego elementu za pomocą obu metod

Zarówno append jak i ext mogą dodawać jeden element na końcu listy, chociaż append jest prostszy.

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]

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

Jeśli użyjesz 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]]

Zamiast tego z argumentem ext przekazujesz listę jako argument, ale uzyskasz 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, przy większej liczbie elementów, użyjesz rozszerzenia, aby uzyskać listę z większą liczbą elementów. Jednak dodanie listy nie doda do niej więcej elementów, ale jeden element, który jest listą zagnieżdżoną, co można wyraźnie zobaczyć w wynikach kodu.

Następujące 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 implementowana w C.

append()Metoda dodaje pojedynczy element do końca listy.

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

extend()Metoda przyjmuje jeden argument, listy i dołącza każdy z elementów argumentu do pierwotnej listy. (Listy są implementowane jako klasy. „Tworzenie” listy naprawdę tworzy instancję klasy. W związku z tym lista zawiera metody, które na niej działają.)

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

Z Dive Into Python .

Możesz użyć „+” do zwrócenia rozszerzenia, zamiast rozszerzenia w 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 +=w przypadku zachowania na miejscu, ale z niewielkimi różnicami w stosunku do append& extend. Jedną z największych różnic +=od appendi extendjest, gdy jest on stosowany w zakresach funkcyjnych zobaczyć ten wpis na blogu .

append(object) - Aktualizuje listę, dodając obiekt do listy.

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) - Zasadniczo łączy dwie listy.

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]

extend()może być używany z argumentem iteratora. Oto przykład. Chcesz utworzyć listę z listy w ten sposób:

Od

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

chcesz

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

Możesz itertools.chain.from_iterable()to zrobić. Wynik tej metody jest iteratorem. Jego wdrożenie jest równoważne z

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Wracając do naszego przykładu, możemy to zrobić

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

i zdobądź listę poszukiwanych.

Oto, jak równorzędnie extend()można użyć z argumentem iteratora:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Jest to odpowiednik appendi extendużycie +operatora:

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

append () : Jest używany w Pythonie do dodania jednego elementu.

Przykład 1:

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

Przykład 2:

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

ext () : Gdzie ext (), służy do scalania dwóch list lub wstawiania wielu elementów na jednej liście.

Przykład 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Przykład 2:

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

Interesującym punktem, który został zasugerowany, ale nie wyjaśniony, jest to, że rozszerzenie jest szybsze niż dołączanie. Każda pętla, która ma dołączoną wewnątrz, powinna zostać uznana za zastąpioną list.extend (przetworzone_elementy).

Należy pamiętać, że rozpoznanie nowych elementów może spowodować przeniesienie całej listy w lepsze miejsce w pamięci. Jeśli dzieje się to kilka razy, ponieważ dodajemy 1 element na raz, ogólna wydajność spada. W tym sensie list.extend jest analogiczny do „” .join (lista ciągów).

Dołącz dodaje wszystkie dane naraz. Całe dane zostaną dodane do nowo utworzonego indeksu. Z drugiej strony, extendjak sama nazwa wskazuje, rozszerza bieżącą tablicę.

Na przykład

list1 = [123, 456, 678]
list2 = [111, 222]

Dzięki appendotrzymujemy:

result = [123, 456, 678, [111, 222]]

Podczas extendgdy otrzymujemy:

result = [123, 456, 678, 111, 222]

Słownik angielski definiuje słowa appendi extendjako:

Dołącz : add (coś) na końcu dokumentu pisemnego.
przedłużyć : powiększ. Powiększ lub rozwiń

Mając tę ​​wiedzę, zrozummy teraz

1) Różnica między appendiextend

append:

• Dołącza dowolny obiekt Pythona w stanie, w jakim się znajduje na końcu listy (tj. Jako ostatni element na liście).
• Powstała lista może być zagnieżdżona i zawierać heterogeniczne elementy (tj. Listę, ciąg, krotkę, słownik, zestaw itp.)

extend:

• Akceptuje każdy iterowalny argument i powiększa listę .
• Wynikowa lista jest zawsze listą jednowymiarową (tzn. Bez zagnieżdżania) i może zawierać w niej elementy heterogeniczne (np. Znaki, liczby całkowite, liczba zmiennoprzecinkowa) w wyniku zastosowania list(iterable).

2) Podobieństwo między appendiextend

• Oba biorą dokładnie jeden argument.
• Oba modyfikują listę w miejscu .
• W rezultacie oba wracają None.

Przykład

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
list.append(object)

Mam nadzieję, że mogę zrobić użyteczne uzupełnienie tego pytania. Jeśli na przykład lista zawiera obiekt określonego typu Info, oto sytuacja, w której extendmetoda nie jest odpowiednia: w forpętli i generowaniu Infoobiektu za każdym razem i extendzapisywaniu go na liście nie powiedzie się. Wyjątek jest jak poniżej:

TypeError: Obiekt „Info” nie jest iterowalny

Ale jeśli użyjesz tej appendmetody, wynik będzie OK. Ponieważ za każdym razem, gdy ta extendmetoda jest używana , zawsze będzie traktowana jako lista lub jakikolwiek inny typ kolekcji, iterowana i umieszczana po poprzedniej liście. Oczywiście konkretnego obiektu nie można powtórzyć.

Aby odróżnić je intuicyjnie

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

To tak, jakby l1reprodukować ciało w jej ciele (zagnieżdżone).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

To tak, jakby dwie oddzielne osoby wzięły ślub i zbudowały zjednoczoną rodzinę.

Poza tym tworzę obszerną ściągę wszystkich metod z listy dla twojego odniesienia.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

extend(L)rozszerza listę, dodając wszystkie elementy z podanej listy 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„rozszerza” listę (na miejscu) tylko o jeden element , pojedynczy obiekt przekazany (jako argument).

extend„rozszerza” listę (na miejscu) o tyle pozycji, ile zawiera obiekt przekazany (jako argument).

Może to być nieco mylące dla strobiektów.

1. Jeśli przekażesz ciąg jako argument: appenddoda na końcu pojedynczy ciąg znaków, ale extenddoda tyle elementów „pojedynczego” ciągu, ile długość tego łańcucha.
2. Jeśli przekażesz listę ciągów jako argument: appendnadal doda jeden element listy na końcu i extenddoda tyle elementów listy, ile długość przekazanej listy.

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

produkuje:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

Dołącz i rozszerz są jednym z mechanizmów rozszerzalności w Pythonie.

Dołącz: dodaje element na końcu listy.

my_list = [1,2,3,4]

Aby dodać nowy element do listy, możemy użyć metody append w następujący sposób.

my_list.append(5)

Domyślna lokalizacja dodawania nowego elementu jest zawsze w pozycji (długość + 1).

Wstaw: metodę wstawiania zastosowano w celu przezwyciężenia ograniczeń dołączania. Za pomocą insert możemy jawnie zdefiniować dokładną pozycję, w której chcemy wstawić nasz nowy element.

Deskryptor metody wstawiania (indeks, obiekt). Wymaga dwóch argumentów, po pierwsze jako indeks, w którym chcemy wstawić nasz element, a po drugie sam element.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

Rozszerz: Jest to bardzo przydatne, gdy chcemy połączyć dwie lub więcej list w jedną listę. Bez rozszerzenia, jeśli chcemy połączyć dwie listy, wynikowy obiekt będzie zawierał listę list.

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

Jeśli spróbujemy uzyskać dostęp do elementu w pozycji 2, otrzymamy listę ([3]) zamiast elementu. Aby dołączyć do dwóch list, będziemy musieli użyć append.

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

Aby dołączyć do wielu list

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]