Python: comprensione della differenza tra append ed est

Question

Il codice seguente non verrà eseguito nel suo stato corrente. Tuttavia, se cambio sum_vec.extend(vec1[i] + vec2[i]) a sum_vec.append(vec1[i] + vec2[i]) funziona perfettamente. Comprendo le differenze di base tra append ed extend, ma non capisco perché il codice non funzioni se uso estendere.

def addVectors(v1, v2): 

    vec1 = list(v1) 
    vec2 = list(v2) 
    sum_vec = [] 
    vec1_len = len(vec1) 
    vec2_len = len(vec2) 
    min_len = min(vec1_len, vec2_len) 

    # adding up elements pointwise 
    if vec1_len == 0 and vec2_len == 0: 
     return sum_vec 
    else: 
     for i in xrange(0, min_len): 
      sum_vec.extend(vec1[i] + vec2[i]) 

    # in case one vector is longer than the other 
    if vec1_len != vec2_len: 
     if vec1_len > vec2_len: 
      sum_vec.extend(vec1[min_len : vec1_len]) 
     else: 
      sum_vec.extend(vec2[min_len : vec2_len]) 
    print sum_vec 
    return sum_vec 

v1 = [1,3,5] 
v2 = [2,4,6,8,10] 
addVectors(v1,v2) 

Answer 1

Come altri hanno sottolineato, extend prende un iterabile (come una lista, tupla o stringa), e aggiunge ogni elemento di iterable all'elenco uno alla volta, mentre append aggiunge il suo argomento nel fine della lista come un singolo oggetto. La cosa fondamentale da notare è che extend è una versione più efficiente di chiamare più volte append.

a = [1,2] 
b = [1,2] 

a.extend([3, 4]) 
for x in [3, 4]: 
    b.append(x) 

assert a == b 

append può prendere un iterabile come argomento, ma lo tratta come un unico oggetto:

a = [1,2] 
a.append([3,4]) 
assert a == [1, 2, [3, 4]] # not [1, 2, 3, 4] 

Answer 2

Potete leggere la documentazione sul list:

list.append aggiunge un singolo elemento alla fine della vostra lista:

Aggiungi un elemento alla fine della lista; equivalente a [len (a):] = [x].

list.extend utilizza un iterabile e aggiunge tutto l'esso di elementi alla fine della vostra lista:

estendere l'elenco aggiungendo tutti gli elementi della lista fornita; equivalente a un [len (a):] = L.

è necessario utilizzare:

sum_vec.extend([vec1[i] + vec2[i]]) # note that a list is created 

In questo modo un iterabile con un singolo elemento (vec1[i] + vec2[i]) è passato. Ma list.append è più adatto quando aggiungi sempre un singolo elemento.

Answer 3

Quando si esegue il codice, si ottiene un'eccezione in questo modo:

Traceback (most recent call last): 
    File ".../stack.py", line 28, in <module> 
    addVectors(v1,v2) 
    File ".../stack.py", line 15, in addVectors 
    sum_vec.extend(vec1[i] + vec2[i]) 
TypeError: 'int' object is not iterable 

In altre parole, il metodo extend si aspetta un iterabile come argomento. Tuttavia, il metodo append ottiene un oggetto come argomento.

Ecco un piccolo esempio della differenza tra estendere e aggiungere:

l = [1, 2, 3, 4] 
m = [10, 11] 
r = list(m) 
m.append(l) 
r.extend(l) 

print(m) 
print(r) 

uscita:

[10, 11, [1, 2, 3, 4]] 
[10, 11, 1, 2, 3, 4] 

Answer 4

estendono ha bisogno di un iterabile come parametro se si desidera estendere la lista da un singolo elemento che devi vestire è in una lista

a = [] 
b = 1 

a.extend([b]) 
a.append(b) 

Answer 5

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

letters = ['a', 'b'] 

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

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

names = ['Foo', 'Bar'] 
names.append('Baz') 
print(names) # ['Foo', 'Bar', 'Baz'] 

names.extend('Moo') 
print(names) # ['Foo', 'Bar', 'Baz', 'M', 'o', 'o']