Perché questo codice Python (comporre un'estensione di lista con una mappa di se stesso) rende il mio sistema bloccato?

Question

Quando eseguo

a = ['a'] 
a.extend(map(lambda x: 'b' + x, a)) 

si blocca il mio sistema fino a quando posso fare un Ctrl + C se corro come uno script Python dal guscio, e l'esecuzione dal interprete mi ha fatto avere per spegnere difficile la mia il computer portatile.

Tuttavia,

a = ['a'] 
a.extend(list(map(lambda x: 'b' + x, a))) 

funziona bene e dà il risultato atteso.

Perché succede?

In un primo momento, ho pensato che potrebbe essere perché stavo cercando di estendere a con una funzione di mappa che riceve un a stesso, così mi ha scritto:

a = ['a'] 
tmp = map(lambda x: 'b' + x, a) 
a.extend(tmp) 

tuttavia, che anche congelato.

Allo stesso modo, questo sembra funzionare bene:

a = ['a'] 
tmp = list(map(lambda x: 'b' + x, a)) 
a.extend(tmp) 

Perché succede questo?

Sto facendo questo su Python 3.4.3.

Answer 1

Questo perché in Python 3.La funzione x map() restituisce un iteratore, che utilizza il riferimento della lista passato ad esso come secondo parametro. Quindi, mentre stai iterando sopra l'iteratore della mappa, stai anche estendendo la lista, e questa continua all'infinito, quindi ottieni MemoryError o finisci con un ciclo infinito.

esempio per mostrare questo comportamento -

>>> m = map(lambda x: a.extend(x), a) 
>>> m 
<map object at 0x021E0E70> 
>>> for i,x in enumerate(m): 
...  print("Hello") 
... 
Hello 
Hello 
.... # lots of Hello 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "<stdin>", line 1, in <lambda> 
MemoryError 

Quindi, quando si fa - a.extend(map(lambda x: 'b' + x, a)). State facendo qualcosa di simile a -

a = ['a'] 
for x in a: 
    a.extend('b'+x) 

Se si tenta il codice di cui sopra, si continua a ottenere la o il ciclo infinito MemoryError.

Quando si esegue -

a.extend(list(map(lambda x: 'b' + x, a))) 

Si utilizza l'iteratore convertendolo in un elenco, prima di sta estendendo la lista a, quindi non finire in un ciclo infinito. In questo caso si sta facendo qualcosa di simile a-

a = ['a'] 
templist = [] 
for x in a: 
    templist.extend('b' + x) 
a.extend(templist) 

Ecco perché non si ottiene l'errore. Si prega di notare che il codice sopra potrebbe non essere il modo in cui python esegue internamente map, è solo qualcosa di simile.

Answer 2

In python 3, verrà generato un iteratore dalla funzione map().

Vedendo a.extend() funzione, pitone troverà che si desidera estendere la lista a con un iteratore relative al a e automaticamente aiutare a fare l'iterazione.

E qui inizia l'iterazione.

In primo luogo, è un 'a' in un. L'iteratore all'interno della funzione map() dà 'a', un 'ba' viene generato dall'espressione lambda e viene aggiunto all'elenco a. a diventa ['a', 'ba'] ora.

Poi, l'iteratore interno map() funzione trova che l'iterazione di a non sta dando StopIteration causa a 's nuovo amico 'ba'' s ritornassi. Pertanto, l'iteratore all'interno della funzione map() fornisceper lambda da elaborare. A 'bba' viene generato qui e viene inserito in a.

Ecco come funziona la propagazione infinita di a.

Il seguente codice può aiutare:

a = ['a'] 
import time 
a.extend(map(lambda x: ('b' + x, print(x), time.sleep(1))[0], a)) 

E dovrebbe essere banale per capire perché il vostro usando di list() per trasformare l'iteratore in un elenco statico non innescare questo.

Answer 3

Penso meccanismo di gestione oggetto di Python è diversa da C/C++, vedere questo:

a = ['a'] 

for x in a: a.append('b')

se si digita nella riga di comando Python, si incontra un ciclo infinito, e dopo si immette CTRL + C, e

>>> a 

si otterrà un lungo elenco che contiene 'a' e 'b', e penso che nel ciclo for, l'una e l'una di a.append ('b') sono t lui stesso oggetto e nella stessa memoria. Questo è quello che penso.