Qual è la differenza tra i metodi di elenco di Python aggiungere ed estendere?

Question

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

Answer 1

append : Aggiunge l'oggetto alla fine.

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

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

---

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

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

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

Answer 2

append aggiunge un elemento a un elenco e estende concatena 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']

Da Tuffati in Python .

Answer 3

  

Qual è la differenza tra i metodi dell'elenco accoda ed estende?

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

append

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

my_list.append(object) 

Qualunque sia l'oggetto, che sia un numero, una stringa, un altro elenco o qualcos'altro, viene aggiunto alla fine di my_list come 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.

estendere

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

my_list.extend(iterable)

Quindi, con extension, ogni elemento dell'iterabile viene aggiunto all'elenco. Ad 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 gli operatori + e + = 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_list modifica 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 confonderti - my_list = my_list + another_list non è equivalente a + = - ti dà un nuovissimo elenco assegnato a my_list.

Complessità temporale

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

L'estensione ha complessità temporale, O (k).

L'iterazione tra le chiamate multiple a append aumenta la complessità, rendendola equivalente a quella di extender, e poiché l'iterazione di extender è implementata in C, sarà sempre più veloce se intendi aggiungere successive elementi da un iterabile in un elenco.

Prestazioni

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

Indirizzare 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 estende . 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 questo apprendiamo che non si ottiene nulla dall'uso di estende quando 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 & # 8482 ;.

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

Conclusione

Vediamo che extension è semanticamente più chiaro e che può essere eseguito molto più velocemente di append , quando si intende 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 .

Answer 4

append aggiunge un singolo elemento. estende aggiunge 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]]

Answer 5

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 ciclo è implementato in C.

Answer 6

Il metodo append () 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 metodo extended () accetta un argomento, un elenco e aggiunge ciascuno degli elementi dell'argomento all'elenco originale. (Gli elenchi sono implementati come classi. & # 8220; La creazione di & # 8221; un elenco sta davvero creando un'istanza di una classe. In quanto tale, un elenco 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']

Da Dive Into Python .

Answer 7

Puoi utilizzare " + " per la restituzione dell'estensione, anziché l'estensione 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 rispetto a append & amp; estendere . Una delle maggiori differenze di + = da append e estende è quando viene usata negli ambiti di funzione, vedi questo post del blog .

Answer 8

  

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 extension puoi estendere un singolo elemento come questo

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

O, diversamente dall'appendice, estendi più elementi in una volta senza annidare l'elenco in quello originale (questa è la ragione per l'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]

estende un elemento

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

  

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 extend, invece, si passa un elenco come argomento, ma si otterrà un elenco con il nuovo elemento che non è nidificato in quello precedente.

>>> 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. Utilizzerai append, per aggiungere non più elementi all'elenco, ma un elemento che è un elenco nidificato, come puoi vedere chiaramente nell'output del codice.

Answer 9

append (oggetto) - 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]]

estende (elenco) - 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]

Answer 10

extend () può essere utilizzato con un argomento iteratore. Ecco un esempio Si desidera creare un elenco da un elenco di elenchi in questo modo:

Da

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

vuoi

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

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

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 l'elenco desiderato.

Ecco come extension () può essere usato equivalentemente con un argomento iteratore:

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

Answer 11

Questo è l'equivalente di append e estende usando l'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]]

Answer 12

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 estende (), 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]

Answer 13

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

Tieni 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 generali ne risentono. In questo senso, list.extend è analogo a " " .join (stringlist).

Answer 14

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

Ad esempio

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

Con append otteniamo:

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

Mentre su estende otteniamo:

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

Answer 15

Un dizionario inglese definisce le parole append e estende come:

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

---

Con questa conoscenza, ora capiamo

1) La differenza tra append e extend

append :

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

estendere :

• Accetta qualsiasi iterabile come argomento e rende l'elenco più grande .
• 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 append e extend

• Entrambi accettano esattamente un argomento.
• Entrambi modificano l'elenco sul posto .
• Di conseguenza, entrambi restituiscono Nessuno .

---

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
lis.append(object)

Answer 16

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 metodo estende non è adatto: in un ciclo for e e la generazione di un oggetto Info ogni volta e l'utilizzo di estende per memorizzarlo nel tuo elenco, fallirà. L'eccezione è come di seguito:

  

TypeError: l'oggetto 'Info' non è iterabile

Ma se si utilizza il metodo append , il risultato è OK. Perché ogni volta che utilizza il metodo extended , 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.

Answer 17

Per distinguerli intuitivamente

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

È come l1 riprodurre 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, creo un cheat sheet esauriente 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'},
                }

Answer 18

estende (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]

Answer 19

append " estende " l'elenco (sul posto) di solo un elemento , il singolo oggetto è passato (come argomento).

estende " estende " l'elenco (sul posto) di tanti elementi quanti l'oggetto passato (come argomento) contiene.

Questo può essere un po 'confuso per gli oggetti str .

1. Se si passa una stringa come argomento: append aggiungerà un singolo oggetto stringa alla fine ma estende aggiungerà quante più " singole " 'str' elementi come la lunghezza di quella stringa.
2. Se passi un elenco di stringhe come argomento: append aggiungerà comunque un singolo 'elenco' alla fine e estende aggiungerà tutti gli elementi 'list' della 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,

Answer 20

Aggiungi ed estendi 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.

Descrizione 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: è 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]