Qual è la differenza tra i metodi dell'elenco append()e extend()?

append: Aggiunge l'oggetto alla fine.

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

ti dà: [1, 2, 3, [4, 5]]

extend: Estende l'elenco aggiungendo elementi dall'iterabile.

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

ti dà: [1, 2, 3, 4, 5]

appendaggiunge un elemento a un elenco e extendconcatena il primo elenco con un altro elenco (o un altro iterabile, non necessariamente un elenco).

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

Qual è la differenza tra i metodi di elenco append ed extender?

• appendaggiunge il suo argomento come singolo elemento alla fine di un elenco. La lunghezza dell'elenco stesso aumenterà di uno.
• extendscorre il proprio argomento aggiungendo ogni elemento all'elenco, estendendo l'elenco. La lunghezza dell'elenco aumenterà di molti elementi nell'argomento iterabile.

append

Il list.appendmetodo aggiunge un oggetto alla fine dell'elenco.

my_list.append(object) 

Qualunque sia l'oggetto, sia un numero, una stringa, un altro elenco o qualcos'altro, viene aggiunto alla fine di my_listcome una singola voce nell'elenco.

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

Quindi tieni presente che un elenco è un oggetto. Se aggiungi un altro elenco a un elenco, il primo elenco sarà un singolo oggetto alla fine dell'elenco (che potrebbe non essere quello che desideri):

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

Il list.extendmetodo estende un elenco aggiungendo elementi da un iterabile:

my_list.extend(iterable)

Quindi, con extension, ogni elemento dell'iterabile viene aggiunto all'elenco. Per esempio:

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

Tieni presente che una stringa è iterabile, quindi se estendi un elenco con una stringa, aggiungerai ogni carattere mentre esegui l'iterazione sulla stringa (che potrebbe non essere quella che desideri):

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

Sovraccarico operatore, __add__( +) e __iadd__( +=)

Entrambi +e gli +=operatori sono definiti per list. Sono semanticamente simili da estendere.

my_list + another_list crea un terzo elenco in memoria, in modo da poterne restituire il risultato, ma richiede che il secondo iterabile sia un elenco.

my_list += another_listmodifica l'elenco sul posto ( è l'operatore sul posto e gli elenchi sono oggetti mutabili, come abbiamo visto), quindi non crea un nuovo elenco. Funziona anche come extender, in quanto il secondo iterabile può essere qualsiasi tipo di iterabile.

Non ti confondere - my_list = my_list + another_listnon equivale a +=- ti dà un nuovissimo elenco assegnato a my_list.

Complessità temporale

Append ha una complessità temporale costante , O (1).

Extend ha complessità temporale, O (k).

Scorrere le molteplici chiamate per appendaumentare la complessità, rendendola equivalente a quella di extender, e poiché l'iterazione di extender è implementata in C, sarà sempre più veloce se si intende aggiungere elementi successivi da un iterabile a un elenco.

Prestazione

Potresti chiederti cosa è più performante, poiché append può essere usato per ottenere lo stesso risultato di estensione. Le seguenti funzioni fanno la stessa cosa:

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

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

Quindi cronometriamoli:

import timeit

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

Affrontare un commento sugli orari

Un commentatore ha detto:

Risposta perfetta, mi manca solo il momento del confronto con l'aggiunta di un solo elemento

Fai la cosa semanticamente corretta. Se si desidera aggiungere tutti gli elementi in un iterabile, utilizzare extend. Se stai solo aggiungendo un elemento, usa append.

Ok, quindi creiamo un esperimento per vedere come funziona nel tempo:

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

E vediamo che fare di tutto per creare un iterabile solo per usare extender è una (minore) perdita di tempo:

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

Da ciò apprendiamo che non si ottiene nulla dall'uso extendquando abbiamo solo un elemento da aggiungere.

Inoltre, questi tempi non sono così importanti. Sto solo mostrando loro di sottolineare che, in Python, fare la cosa semanticamente corretta sta facendo le cose nel modo giusto ™.

È concepibile che tu possa testare i tempi su due operazioni comparabili e ottenere un risultato ambiguo o inverso. Concentrati solo sul fare la cosa semanticamente corretta.

Conclusione

Si vede che extendè semanticamente più chiara, e che può funzionare molto più veloce di append, quando si intende di aggiungere ogni elemento in un iterabile a un elenco.

Se hai solo un singolo elemento (non in un iterabile) da aggiungere all'elenco, usa append.

appendaccoda un singolo elemento. extendaggiunge un elenco di elementi.

Nota che se passi un elenco da aggiungere, aggiunge comunque un elemento:

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

Aggiungi vs Estendi

Con append puoi aggiungere un singolo elemento che estenderà l'elenco:

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

Se si desidera estendere più di un elemento, è necessario utilizzare extender, poiché è possibile aggiungere solo un elemento o un elenco di elementi:

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

In modo da ottenere un elenco nidificato

Invece con extendi, puoi estendere un singolo elemento come questo

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

Oppure, in modo diverso, da append, estendi più elementi in una volta senza annidare l'elenco in quello originale (questo è il motivo dell'estensione del nome)

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

Aggiunta di un elemento con entrambi i metodi

Sia append che extender possono aggiungere un elemento alla fine dell'elenco, sebbene append sia più semplice.

aggiungere 1 elemento

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

estendere un elemento

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

Aggiunta di più elementi ... con risultati diversi

Se usi append per più di un elemento, devi passare un elenco di elementi come argomenti e otterrai un elenco NESTED!

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

Con extension, invece, si passa un elenco come argomento, ma si otterrà un elenco con il nuovo elemento che non è nidificato in quello vecchio.

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

Quindi, con più elementi, utilizzerai ext per ottenere un elenco con più elementi. Tuttavia, l'aggiunta di un elenco non aggiungerà più elementi all'elenco, ma un elemento che è un elenco nidificato, come è possibile vedere chiaramente nell'output del codice.

I seguenti due frammenti sono semanticamente equivalenti:

for item in iterator:
    a_list.append(item)

e

a_list.extend(iterator)

Quest'ultimo potrebbe essere più veloce poiché il loop è implementato in C.

Il append()metodo aggiunge un singolo elemento alla fine dell'elenco.

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

Il extend()metodo accetta un argomento, un elenco e aggiunge ciascuno degli elementi dell'argomento all'elenco originale. (Gli elenchi sono implementati come classi. "Creare" un elenco è davvero un'istanza di una classe. Come tale, un elenco ha metodi che operano su di esso.)

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

Da Dive Into a Python .

È possibile utilizzare "+" per restituire l'estensione, anziché estenderla in posizione.

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]

Analogamente +=per il comportamento sul posto, ma con lievi differenze rispetto a append& extend. Una delle maggiori differenze +=rispetto a appended extendè quando viene utilizzata negli ambiti delle funzioni, vedi questo post sul blog .

append(object) - Aggiorna l'elenco aggiungendo un oggetto all'elenco.

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) - Concatena essenzialmente due elenchi.

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()può essere utilizzato con un argomento iteratore. Ecco un esempio Si desidera creare un elenco da un elenco di elenchi in questo modo:

A partire dal

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

tu vuoi

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

Puoi usarlo itertools.chain.from_iterable()per farlo. L'output di questo metodo è un iteratore. La sua implementazione è equivalente a

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

Torniamo al nostro esempio, possiamo fare

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

e ottenere l'elenco desiderato.

Ecco come si extend()può usare equivalentemente con un argomento iteratore:

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

Questo è l'equivalente appende l' extendutilizzo +dell'operatore:

>>> 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 () : viene sostanzialmente utilizzato in Python per aggiungere un elemento.

Esempio 1:

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

Esempio 2:

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

extend () : dove extend (), viene utilizzato per unire due elenchi o inserire più elementi in un elenco.

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

Esempio 2:

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

Un punto interessante che è stato accennato, ma non spiegato, è che l'estensione è più veloce di append. Per ogni ciclo che ha aggiunto all'interno dovrebbe essere considerato come sostituito da list.extend (processing_elements).

Tenere presente che l'apprendimento di nuovi elementi potrebbe comportare la riallocazione dell'intero elenco in una posizione migliore nella memoria. Se ciò viene fatto più volte perché stiamo aggiungendo 1 elemento alla volta, le prestazioni complessive ne risentono. In questo senso, list.extend è analogo a "" .join (stringlist).

Aggiungi aggiunge tutti i dati contemporaneamente. Tutti i dati verranno aggiunti all'indice appena creato. D'altra parte, extendcome suggerisce il nome, estende l'array corrente.

Per esempio

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

Con appendotteniamo:

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

Mentre extendsiamo attivi otteniamo:

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

Un dizionario inglese definisce le parole appende extendcome:

append : aggiungi (qualcosa) alla fine di un documento scritto.
estendi : ingrandisci. Ingrandisci o espandi

Con questa conoscenza, ora capiamo

1) La differenza tra appendeextend

append:

• Aggiunge qualsiasi oggetto Python così com'è alla fine dell'elenco (ovvero come l'ultimo elemento dell'elenco).
• L'elenco risultante può essere nidificato e contenere elementi eterogenei (ovvero elenco, stringa, tupla, dizionario, set, ecc.)

extend:

• Accetta qualsiasi iterabile come argomento e ingrandisce l'elenco .
• L'elenco risultante è sempre un elenco monodimensionale (cioè nessun annidamento) e può contenere elementi eterogenei (es. Caratteri, numeri interi, float) come risultato dell'applicazione list(iterable).

2) Somiglianza tra appendeextend

• Entrambi accettano esattamente un argomento.
• Entrambi modificano l'elenco sul posto .
• Di conseguenza, entrambi i ritorni None.

Esempio

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)

Spero di poter fare un utile complemento a questa domanda. Se il tuo elenco memorizza un oggetto di tipo specifico, ad esempio Info, ecco una situazione in cui il extendmetodo non è adatto: in un forciclo e generando un Infooggetto ogni volta e usando extendper memorizzarlo nel tuo elenco, fallirà. L'eccezione è come di seguito:

TypeError: l'oggetto 'Info' non è iterabile

Ma se si utilizza il appendmetodo, il risultato è OK. Perché ogni volta che utilizza il extendmetodo, lo tratterà sempre come un elenco o qualsiasi altro tipo di raccolta, lo ripeterà e lo posizionerà dopo l'elenco precedente. Un oggetto specifico non può essere ripetuto, ovviamente.

Per distinguerli intuitivamente

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

È come l1riprodurre un corpo all'interno del suo corpo (nidificato).

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

È come se due individui separati si sposassero e costruissero una famiglia unita.

Inoltre, realizzo un cheat sheet esaustivo di tutti i metodi della lista come riferimento.

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

extend(L)estende l'elenco aggiungendo tutti gli elementi nell'elenco specificato 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"estende" l'elenco (sul posto) di un solo elemento , il singolo oggetto passato (come argomento).

extend"estende" l'elenco (sul posto) di tutti gli elementi che l'oggetto passato (come argomento) contiene.

Questo può essere leggermente confuso per gli stroggetti.

1. Se si passa una stringa come argomento: appendaggiungerà un singolo elemento stringa alla fine ma extendaggiungerà tanti "singoli" elementi "str" ​​quanti sono la lunghezza di quella stringa.
2. Se passi un elenco di stringhe come argomento: appendaggiungerà comunque un singolo elemento "elenco" alla fine e extendaggiungerà tutti gli elementi "elenco" quanti sono la lunghezza dell'elenco passato.

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

produce:

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

L'aggiunta e l'estensione sono uno dei meccanismi di estensibilità in Python.

Aggiungi: aggiunge un elemento alla fine dell'elenco.

my_list = [1,2,3,4]

Per aggiungere un nuovo elemento all'elenco, possiamo usare il metodo append nel modo seguente.

my_list.append(5)

La posizione predefinita in cui verrà aggiunto il nuovo elemento è sempre nella posizione (lunghezza + 1).

Inserisci: il metodo di inserimento è stato utilizzato per superare i limiti di append. Con insert possiamo definire esplicitamente la posizione esatta in cui vogliamo inserire il nostro nuovo elemento.

Descrittore del metodo di inserimento (indice, oggetto). Sono necessari due argomenti, in primo luogo l'indice in cui vogliamo inserire il nostro elemento e in secondo luogo l'elemento stesso.

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

Estendi: questo è molto utile quando vogliamo unire due o più elenchi in un unico elenco. Senza estensione, se vogliamo unire due elenchi, l'oggetto risultante conterrà un elenco di elenchi.

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

Se proviamo ad accedere all'elemento in pos 2, otteniamo un elenco ([3]), invece dell'elemento. Per unire due elenchi, dovremo usare append.

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

Per unire più elenchi

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