Jaka jest różnica między dodawaniem i rozszerzaniem metod list Pythona?

3116

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

Claudiu
źródło

Odpowiedzi:

5248

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]

kender
źródło
122
Jaka jest różnica między extendprostym operatorem dodawania i po prostu - w powyższym przykładzie x = x + [4, 5]?
Rohan
303
W rzeczywistości istnieje duża różnica - x + [4, 5]daje nową listę przypisaną do x - x.extend()mutuje oryginalną listę. Rozwijam tutaj swoją odpowiedź poniżej.
Aaron Hall
@AaronHall @Rohan, ale jest taki sam jak x += [4,5].
Astitva Srivastava,
1
@AstitvaSrivastava Właściwie myślę, że rozszerzenie jest szybsze pod względem kodu bajtowego
MilkyWay90
1
Słowo kluczowe przy użyciu appendto Object . Jeśli spróbujesz użyć extendi przejdziesz do słownika , doda on klucz , a nie cały skrót na końcu tablicy.
Anthony
640

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']
Harley Holcombe
źródło
489

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.

Aaron Hall
źródło
1
@Aaron Hall Jeden mały komentarz w algorytmie pomiaru czasu. „ext_one” może zwracać „nieco nieprawidłowy” czas, ponieważ jest również zaangażowane tworzenie listy. Prawdopodobnie lepiej jest utworzyć elementy jako zmienne ( ex1 = 0i ex2 = [0]) i przekazać te zmienne, jeśli chcesz być bardziej rygorystyczny.
ilias iliadis
19
Rzeczywiście idealna odpowiedź. Co z wydajnością l1 += l2vs l1.extend(l2)?
Jean-Francois T.,
6
@ Jean-FrancoisT .: l1 += l2i l1.extend(l2)ostatecznie wykonać ten sam kod ( list_extendfunkcja w listobject.c). Jedynymi różnicami są: 1. +=ponowne przypisanie l1(do siebie dla lists, ale ponowne przypisanie obsługuje typy niezmienne, które nie są później tym samym obiektem), co powoduje, że jest to nielegalne, jeśli w l1rzeczywistości jest atrybutem obiektu niezmiennego; na przykład t = ([],), t[0] += lstnie powiedzie się, gdy t[0].extend(lst)będzie działać. 2. l1 += l2używa dedykowanych kodów bajtowych, podczas gdy l1.extend(l2)stosuje metodę uogólnionej wysyłki; to sprawia, że +=szybciej niż extend.
ShadowRanger,
3
Fakt, że +=należy zmienić przypisanie l1, oznacza, że ​​w niektórych przypadkach wolniejsza wysyłka extendjest częściowo lub w całości nadrobiona przez nieprzypisanie jej z powrotem do lewej strony. Na przykład, jeśli listjest atrybutem obiektu self.l1 += l2i self.l1.extend(l2)ma identyczną wydajność w mojej instalacji w Pythonie 3.6, po prostu dlatego, że rzeczywista operacja jest bardziej podobna self.l1 = self.l1.__iadd__(l2), co oznacza, że ​​musi wykonać umiarkowanie kosztowną STORE_ATTR, self.l1.extend(l2)która nie musi.
ShadowRanger,
2
Proste porównanie w testach lokalnych: dla zmiennej lokalnej (więc po +=prostu używa STORE_FAST, która jest bardzo tania), gdzie dodawana wartość jest istniejąca listz jednym elementem, z operacją powtarzaną 1000 razy, +=zajęło średnio około 33 ns , podczas gdy extendzajęło 78 ns, różnica 45 ns. Jeśli l1jest globalny (wymaga droższego STORE_GLOBAL), różnica zawęża się do 17 ns. Jeśli l1faktycznie local.l1(wymaga jeszcze droższego STORE_ATTR), nie ma znaczącej różnicy między +=i extend(czasy są w przybliżeniu identyczne; extendczasami wygrywa).
ShadowRanger
121

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]]
Greg Hewgill
źródło
62

Append vs Extend

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

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.

wprowadź opis zdjęcia tutaj

wprowadź opis zdjęcia tutaj

Giovanni G. PY
źródło
61

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.

Erik
źródło
20
Wydłużanie jest ~ 4x szybsze na moim komputerze niż dodawanie w pętli (16us vs 4us dla 100 pętli zer)
Alex L
6
extend()prawdopodobnie wstępnie przydziela, a append()prawdopodobnie nie.
Mad Physicist,
@MadPhysicist: Ze względu na kompletność, zdarzają się sytuacje, w których extend() nie można rozsądnie dokonać wstępnej alokacji, ponieważ niektóre iteracje nie są implementowane __len__(), ale tak jak ty byłbym zaskoczony, gdyby nie spróbował. Część wzrostu wydajności wynika również z wykonania części iteracyjnej w czystym C zamiast w Pythonie, jak wskazano w odpowiedzi Aarona .
Soren Bjornstad
44

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 .

CodyChan
źródło
Nie można przedłużyć za pomocą tylko 6, ponieważ nie jest iterowalna. Drugie wyjście w twoim przykładzie jest nieprawidłowe. „abc” jest dodawane jako pojedynczy element, odkąd go przekazałeśextend jako listę z jednym elementem ['abc']: [1, 2, 3, 4, 5, „abc”]. Aby dokonać wyjście przykład prawidłowe, zmienić linię ABC: x.extend('abc'). I usuń x.extend(6)lub zmień na x.extend([6]).
aneroid
37

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 .

denfromufa
źródło
Czy użycie znaku „+” do zwrócenia rozszerzenia ma wpływ na złożoność czasu?
franklin
5
@franklin, zobacz tę odpowiedź, aby uzyskać szczegółowe informacje: stackoverflow.com/a/28119966/2230844
denfromufa
1
Nie rozumiem, jak to odpowiada na pytanie
pppery
22

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]
Chaitanya
źródło
20

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]
Kiriloff
źródło
2
Ta odpowiedź nie kontrastuje z załącznikiem i dlatego nie odpowiada na pytanie
pppery
19

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]]
skdev75
źródło
Dlaczego nie = +? Bardziej zwięzłe
denfromufa,
16

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]
Gr8 Adakron
źródło
12

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).

bconstanzo
źródło
12

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]
Shiv
źródło
8

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)
kmario23
źródło
5

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

Crabime
źródło
4

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'},
                }
Rachunek różniczkowy
źródło
2

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]
tessie
źródło
0

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,
ilias iliadis
źródło
0

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]
vivek
źródło
2
Dlaczego odpowiadasz na pytanie, na które już udzielono odpowiedzi wiele razy? To pytanie ma 10 lat ...
Mike - SMT