append aggiunge un elemento a un elenco e extend concatena la prima lista con un'altra lista (o un'altra iterabile, non necessariamente una lista).

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

A partire dal Immergiti in Python.

Qual è la differenza tra i metodi di lista accodati ed estesi?

• append aggiunge il suo argomento come un singolo elemento alla fine di una lista. La lunghezza della lista stessa aumenterà di uno.
• extend itera sul suo argomento aggiungendo ogni elemento alla lista, estendendo la lista. La lunghezza della lista aumenterà di molti elementi nell'argomento iterabile.

append

Il list.append metodo aggiunge un oggetto alla fine dell'elenco.

my_list.append(object) 

Qualunque sia l'oggetto, se un numero, una stringa, un altro elenco o qualcos'altro, viene aggiunto alla fine di my_list come una singola voce sulla lista.

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

Quindi tieni presente che una lista è 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 on end of list.

extend

Il list.extend metodo estende un elenco aggiungendo elementi da un iterabile:

my_list.extend(iterable)

Quindi con estensione, ogni elemento del iterabile viene aggiunto alla lista. 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 è un iterabile, quindi se estendi un elenco con una stringa, aggiungi ciascun carattere mentre esegui l'iterazione sulla stringa (che potrebbe non essere quello che desideri):

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

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

Entrambi + e += gli operatori sono definiti per list. Sono semanticamente simili all'estensione.

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

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

Non confondersi - my_list = my_list + another_list non è equivalente a += - ti dà una nuova lista assegnata a my_list.

Complessità del tempo

Append has complessità a tempo costante, O (1).

Estende la complessità del tempo, O (k).

Iterazione attraverso le chiamate multiple a append aggiunge complessità, rendendolo equivalente a quello di estensione, e poiché l'iterazione di est è 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 utilizzato per ottenere lo stesso risultato dell'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 dedichiamoli:

import timeit

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

Affrontare un commento sui tempi

Un commentatore ha detto:

Risposta perfetta, mi manca solo il momento del confronto aggiungendo solo un elemento

Fai la cosa semanticamente corretta. Se vuoi aggiungere tutti gli elementi in un iterabile, usa extend. Se stai aggiungendo solo 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 iterable solo per usare ext è una (minore) perdita di tempo:

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

Apprendiamo da ciò che non si ottiene nulla dall'uso extend quando abbiamo solo uno elemento da aggiungere.

Inoltre, questi tempi non sono così importanti. Li sto solo mostrando per sottolineare che, in Python, fare la cosa semanticamente corretta è fare le cose Destra Modo.

È 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

Lo vediamo extend è semanticamente più chiaro e può essere eseguito molto più velocemente di append, quando intendi aggiungere ogni elemento in un iterabile a un elenco. 

Se hai solo un singolo elemento (non in un iterabile) da aggiungere alla lista, usa append.

append aggiunge un singolo elemento. extend aggiunge un elenco di elementi.

Si noti che se si passa una lista da aggiungere, viene comunque aggiunto un elemento:

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

I seguenti due snippet sono semanticamente equivalenti:

for item in iterator:
    a_list.append(item)

e

a_list.extend(iterator)

Quest'ultimo potrebbe essere più veloce in quanto il ciclo è implementato in C.

Puoi usare "+" per restituire l'estensione, invece di estenderla sul posto.

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]

allo stesso modo += per comportamento sul posto, ma con lievi differenze da append & extend. Una delle più grandi differenze di += a partire dal append e extend è quando è usato negli ambiti di funzione, vedi questo post del blog.

Il metodo append () aggiunge un singolo oggetto 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 metodo extend () accetta un argomento, un elenco e aggiunge tutti gli elementi dell'argomento all'elenco originale. (Le liste sono implementate come classi. "Creare" una lista è davvero un'istanza di una classe. Come tale, una lista ha metodi che operano su di essa.)

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

A partire dal Dive Into Python.

 Aggiungi vs Estendi

Con append puoi aggiungere un singolo elemento che estenderà la lista:

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

Se vuoi estendere più di un elemento dovresti usare estendi, perché puoi solo aggiungere un elmento o un elenco di elementi:

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

In modo da ottenere una lista annidata

Invece con estensione puoi estendere un singolo elemento come questo

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

Oppure, a differenza di append, estendi più elementi in una volta senza annidare la lista in quella 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

 aggiungi 1 elemento

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

 estendi un elemento

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

 Aggiungere 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 estensione, invece, si passa una lista come argomento, ma si otterrà una lista con il nuovo elemento che non è annidato in quello vecchio.

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

Quindi, con più elementi, utilizzerai l'estensione per ottenere un elenco con più elementi. Userai append, per aggiungere non più elementi all'elenco, ma un elemento che è un elenco annidato come puoi vedere chiaramente nell'output del codice.

append(object) - Aggiorna la lista aggiungendo un oggetto alla lista.

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

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 usato con un argomento iteratore. Ecco un esempio. Desiderate creare una lista da un elenco di liste 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 usare itertools.chain.from_iterable() fare così. 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

Tornando 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 ottieni la lista dei desideri

Ecco come in modo equivalente extend() può essere usato 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 di append e extend usando il + 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]]