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.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 list append i extend?

• append dodaje swój argument jako pojedynczy element na końcu listy. Długość samej listy zwiększy się o jeden.
• extend iteracja nad argumentem dodaje każdy element do listy, rozszerzając listę. Długość listy zwiększy się o tyle, ile elementów było w argumencie iterowalnym.

append

Metoda list.append dodaje obiekt na koniec listy.

my_list.append(object) 

Jakikolwiek jest obiekt, czy to liczba, łańcuch znaków, inna lista, czy coś innego, jest dodawany 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 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

Metoda list.extend rozszerza listę przez dodanie elementów z iterable:

my_list.extend(iterable)

Tak więc z extend, każdy element iterable jest dołączany 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 łańcuch jest iterowalny, więc jeśli rozszerzysz Listę o łańcuch, dodasz każdy znak podczas iteracji nad łańcuchem (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__ (+) oraz __iadd__ (+=)

Oba operatory + i += są zdefiniowane dla list. Są semantycznie podobne do rozszerz.

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

my_list += another_list modyfikuje listę in-place (to jest operatorem in-place, a listy są obiektami zmiennymi, jak widzieliśmy), więc nie tworzy nowej listy. Działa również jak extend, ponieważ drugi iterable może być dowolnym iterable.

Nie daj się pogubić - my_list = my_list + another_list nie jest odpowiednikiem += - daje zupełnie nowy lista przypisana do my_list.

Złożoność Czasu

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

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

Iteracja poprzez wielokrotne wywołania do append dodaje złożoność, czyniąc ją równoważną do extend, a ponieważ iteracja extend jest zaimplementowana w C, zawsze będzie szybsza, jeśli zamierzasz dodawać kolejne elementy z iterable do listy.

Wydajność

Możesz się zastanawiać co jest bardziej wydajne, ponieważ append może być używany do osiągnięcia tego samego wyniku co extend. 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)

Więc czas ich:

import timeit

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

Adresowanie komentarza do timingów

Komentator powiedział:

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

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

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

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

Uczymy się z tego, że nie ma nic zyskanego z używania extend, gdy mamy tylko jeden {69]} element do dołączenia.

Jest możliwe, że możesz przetestować czas na dwóch porównywalnych operacjach i uzyskać niejednoznaczny lub odwrotny wynik. Skup się na tym, co jest semantycznie poprawne.

Podsumowanie

Widzimy, że extend jest semantycznie wyraźniejszy i że może działać znacznie szybciej niż append, kiedy zamierzasz dołączyć każdy element w iterable do listy.

Jeśli masz tylko jedną element (nie w iterowalnym) aby dodać do listy, użyj append.

append dodaje pojedynczy element. extend dodaje listę elementów.

Zauważ, że jeśli przekazujesz listę do dodania, 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 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ć extend, ponieważ możesz dodać tylko jeden elment lub jedną listę elementu:

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

Aby otrzymać zagnieżdżoną listę

Zamiast extend, możesz rozszerzyć pojedynczy element w ten sposób

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

Lub, inaczej, od append, rozszerzyć więcej elementów w jednym czasie bez zagnieżdżania listy do oryginalnej (stąd nazwa extend)

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

Dodawanie jednego elementu obiema metodami

Zarówno append, jak i extend mogą dodać jeden element na końcu listy, choć append jest prostsze.

Dołącz 1 element

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

Extend one element

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

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 argumentów i otrzymasz zagnieżdżoną listę!

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

W extend zamiast tego przekazujesz 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, przy większej liczbie elementów, użyjesz extend, aby uzyskać listę z większą liczbą elementów. Jednak dodanie listy nie doda więcej elementów do listy, ale jeden element, który jest listą zagnieżdżoną, jak widać wyraźnie na wyjściu kod.

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 zaimplementowana w C.

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() pobiera jeden argument, listę i dołącza każdą z pozycji argumentu do oryginalnej listy. (Listy są zaimplementowane jako klasy. "Tworzenie" listy jest tak naprawdę tworzeniem instancji klasy. Jako taka lista ma 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']

Od Zanurz Się W Pythonie.

Możesz użyć "+" do zwracania rozszerzenia, zamiast rozszerzania 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 += dla zachowania w miejscu, ale z niewielkimi różnicami od append & extend. Jedną z największych różnic += od append i extend jest to, gdy jest używana w zakresach funkcji, Zobacz Ten post 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 zrobić listę z listy list 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 użyć itertools.chain.from_iterable(), Aby to zrobić. Wyjście tej metody jest iteratorem. Jego implementacja jest równoważna

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 zrobić

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

Oto jak równoważnie extend() może być użyte 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 append i extend używając 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]]

Dołącz(): jest w zasadzie używany w Pythonie do dodawania 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]]

extend(): gdzie extend (), służy do scalania dwóch list lub wstawiania wielu elementów w 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]

Ciekawostką, która została zasugerowana, ale nie wyjaśniona, jest to, że extend jest szybszy niż append. Dla każdej pętli, która ma dołączone wewnątrz powinno być uznane za zastąpione list.extend (processed_elements).

Należy pamiętać, że wprowadzenie nowych elementów może skutkować ponownym przeniesieniem całej listy na lepsze miejsce w pamięci. Jeśli jest to zrobione kilka razy, ponieważ dodajemy 1 element na raz, ogólna wydajność spada. W tym sensie lista.extend jest analogiczny do "".join (stringlist).

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

Na przykład

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

Z append otrzymujemy:

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

Podczas extend otrzymujemy:

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

Angielski Słownik definiuje słowa append i extend jako:

Append : dodaj (coś) na końcu dokumentu.
extend : Powiększ. Powiększ lub rozwiń

Z tą wiedzą, teraz zrozummy

1) różnica między append A extend

append:

• dodaje dowolny obiekt Pythona jako-is na koniec listy (tj. jako ostatni element w lista).
• wynikowa lista może być zagnieżdżona i zawierać heterogeniczne elementy (np. list, string, tuple, dictionary, set, itd.)

extend:

• przyjmuje dowolny iterowalny jako swój argument i czyni listę większą.
• lista wynikowa jest zawsze jednowymiarową listą (tzn. bez zagnieżdżania) i może zawierać w sobie heterogeniczne elementy (np. znaki, liczby całkowite, float) w wyniku zastosowania list(iterable).

2) podobieństwo między append A extend

• obie biorą dokładnie jeden argument.
• obie modyfikują listę na miejscu .
• w rezultacie oba zwracają 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ć przydatne uzupełnienie tego pytania. Jeśli Twoja lista przechowuje określony obiekt typu, na przykład Info, oto sytuacja, że metoda extend nie jest odpowiednia: w pętli for i generowaniu obiektu Info za każdym razem i używaniu extend do przechowywania go na liście, to się nie powiedzie. Wyjątek jest jak poniżej:

TypeError: obiekt' Info ' nie jest iterowalny

Ale jeśli użyjesz metody append, wynik będzie OK. Ponieważ za każdym razem używając extend metoda, zawsze będzie traktowała ją jako listę lub inny typ kolekcji, iterację i umieszczanie jej po poprzedniej liście. Nie da się oczywiście iterować określonego obiektu.

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 l1 odtworzyć ciało wewnątrz jej ciała (zagnieżdżone).

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

Poza tym robię wyczerpujący arkusz cheatsheet wszystkich metod listy w celach informacyjnych.

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

extend(L) rozszerza listę poprzez dodanie wszystkich elementów 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 "extends" the list (in place) by only one items, the single object passed (as argument).

extend "rozszerza" listę (w miejscu) o tyle elementów, ile zawiera przekazany obiekt (jako argument).

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

1. jeśli przekazujesz łańcuch jako argument: append doda pojedynczy element ciągu na końcu, ale extend doda tyle "pojedynczych" pozycji 'str' jak długość tego łańcucha.
2. jeśli przekazuje listę łańcuchów jako argument: append nadal będzie dodawać pojedynczą pozycję "listy" na końcu i extend doda tyle elementów "listy" co 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,

Append i extend są jednym z mechanizmów rozszerzalności w Pythonie.

Append: 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, w której nowy element zostanie dodany jest zawsze w pozycji (length+1).

Insert: metoda insert została użyta do przezwyciężenia ograniczeń append. Za pomocą insert możemy jawnie zdefiniować dokładną pozycję, którą chcemy nasz nowy element do wstawienia w.

Deskryptor metody insert (index, object). Wymaga dwóch argumentów, po pierwsze jest to indeks, który 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']

Extend: 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 pos 2, otrzymamy listę ([3]), zamiast element. Aby połączyć dwie listy, musimy 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]