empty - python list()




Differenza tra i metodi append e ext list in Python (16)

Qual è la differenza tra i metodi di lista append() ed extend() ?


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.


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 iterates sul suo argomento aggiungendo ogni elemento alla lista, estendendo la lista. La lunghezza della lista 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 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 at the end of the list.

extend

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

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 gli operatori + e += sono definiti per la list . Sono semanticamente simili all'estensione.

my_list + another_list crea una terza lista in memoria, quindi puoi restituirne il risultato, ma richiede che il secondo iterable sia una lista.

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 estensione, in quanto il secondo iterabile può essere qualsiasi tipo di iterabile.

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

Complessità del tempo

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

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

L'iterazione delle chiamate multiple per append aggiunge complessità, rendendola equivalente a quella 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 iterable, 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 c'è nulla ottenuto dall'uso extend quando abbiamo un solo 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 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

Vediamo che l' extend è semanticamente più chiara e che può essere eseguita 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 alla lista, usa append .


Aggiungi un dizionario a un altro:

>>>def foo():
    dic = {1:'a', 2:'b', 3:'c', 4:'a'}
    newdic = {5:'v', 1:'aa'}
    for i in dic.keys():
        if not newdic.has_key(dic[i]):
            newdic[i] = dic[i]
    print "Appended one:", newdic

>>>foo()
Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}

Append aggiunge tutti i dati contemporaneamente. L'intero dato verrà aggiunto all'indice appena creato. D'altra parte, extend , come suggerisce il nome, estende l'array corrente.

Per esempio

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

Con append otteniamo:

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

Mentre in extend otteniamo:

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

Il metodo "append" aggiunge il suo parametro come un singolo elemento alla lista, mentre "extend" ottiene una lista e ne aggiunge il contenuto.

Per esempio,

estendere

    letters = ['a', 'b']
    letters.extend(['c', 'd'])
    print(letters) # ['a', 'b', 'c', 'd']

aggiungere

    letters.append(['e', 'f'])
    print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']]

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

Da Dive Into Python .


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 il comportamento sul posto, ma con lievi differenze da append ed extend . Una delle maggiori differenze di += da append ed extend è quando viene utilizzata negli ambiti delle funzioni, vedere questo post sul blog .


Questo è l'equivalente di append ed extend 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]]

Spero di poter fare un utile complemento a questa domanda. Se il tuo elenco memorizza un oggetto tipo specifico, ad esempio Info , ecco una situazione in cui il metodo extend non è adatto: in un ciclo for e generando un oggetto Info ogni volta e utilizzando extend per memorizzarlo nell'elenco, fallirà. L'eccezione è come di seguito:

TypeError: l'oggetto 'Info' non è iterable

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


Un dizionario inglese definisce le parole append ed extend come:

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

Con quella conoscenza, ora capiamo

1) La differenza tra append ed extend

append :

  • Aggiunge qualsiasi oggetto Python così com'è alla fine della lista (cioè come ultimo elemento nella lista).
  • L'elenco risultante può essere annidato e contenere elementi eterogenei (ad esempio elenco, stringa, tupla, dizionario, insieme, ecc.)

extend :

  • Accetta qualsiasi iterable come argomento e amplia la lista.
  • L'elenco risultante è sempre un elenco dimensionale (cioè senza nidificazione) e può contenere elementi eterogenei (es. Caratteri, numeri interi, float) come risultato dell'applicazione list(iterable) .

2) Somiglianza tra append ed extend

  • Entrambi richiedono esattamente un argomento.
  • Entrambi modificano la lista sul posto .
  • Di conseguenza, entrambi restituiscono 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
lis.append(object)

extend (L) estende l'elenco aggiungendo tutti gli elementi nell'elenco L specificato.

>>> 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 : aggiunge 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 dal iterabile.

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

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


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

extend "estende" l'elenco (in posizione) di un numero di elementi quanti l'oggetto passato (come argomento) contiene.

Ciò potrebbe confondere leggermente gli oggetti str .

  1. Se passi una stringa come argomento: append aggiungerà un singolo elemento di stringa alla fine, ma extend aggiungendo tanti elementi "single" "str" ​​come la lunghezza di quella stringa.
  2. Se si passa un elenco di stringhe come argomento: append ancora un singolo elemento 'elenco' alla fine e extend aggiungendo tanti elementi 'elenco' come 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,

append aggiunge un elemento a un elenco e extend 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', 2]]

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

Da Dive into Python .


extend() può essere utilizzato 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() 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 la lista dei desideri

Ecco come 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]

append () : Fondamentalmente è usato 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 () : Where 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]




extend