Qual è la differenza tra i metodi di lista append()
e extend()
?
Qual è la differenza tra i metodi di lista append()
e extend()
?
append
: Aggiunge oggetto alla fine.
x = [1, 2, 3]
x.append([4, 5])
print (x)
ti dà: [1, 2, 3, [4, 5]]
extend
: Estende la lista aggiungendo elementi dal iterabile.
x = [1, 2, 3]
x.extend([4, 5])
print (x)
ti dà: [1, 2, 3, 4, 5]
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']
__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.
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.
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
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.
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]
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
>>> 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]]