In che modo i generatori Python sanno chi sta chiamando?

Question

Questa domanda mi sta facendo tirare fuori i capelli.

se faccio:

def mygen(): 
    for i in range(100): 
     yield i 

e chiamare da mille discussioni, come fa il generatore sa cosa inviare seguente per ogni thread? Ogni volta che lo chiamo, il generatore salva una tabella con il contatore e il riferimento del chiamante o qualcosa del genere?

È strano.

Per favore, chiarisci la mia mente su quello.

Answer 1

mygen non deve ricordare nulla. Ogni chiamata a mygen() restituisce un iterabile indipendente. Questi iterables, d'altra parte, hanno lo stato: ogni volta che viene richiamato lo next(), si passa alla posizione corretta nel codice del generatore: quando viene rilevato un numero yield, il controllo viene restituito al chiamante. L'implementazione effettiva è piuttosto caotica, ma in linea di principio è possibile immaginare che un tale iteratore memorizzi le variabili locali, il bytecode e la posizione corrente nel bytecode (puntatore dell'istruzione a.k.a.). Non c'è niente di speciale nei thread qui.

Answer 2

Una funzione come questa, quando chiamata, restituirà un oggetto generatore. Se si dispone di thread separati che chiamano next() sullo stesso oggetto generatore, interferiranno reciprocamente. Vale a dire, 5 thread chiamando next() 10 volte ciascuno otterrà 50 rendimenti diversi.

Se due thread creano un generatore chiamando lo mygen() all'interno del thread, avranno oggetti generatore separati.

Un generatore è un oggetto e il suo stato verrà archiviato in memoria, quindi due thread che creano uno mygen() si riferiranno a oggetti separati. Non sarebbe diverso da due thread che creano un oggetto da un class, ognuno avrà un oggetto diverso, anche se la classe è la stessa.

se si proviene da uno sfondo C, questo è non la stessa cosa di una funzione con le variabili static. Lo stato viene mantenuto in un oggetto, non staticamente nelle variabili contenute nella funzione.

Answer 3

Potrebbe essere più chiaro se si guarda in questo modo. Invece di:

for i in mygen(): 
    . . . 

uso:

gen_obj = mygen() 
for i in gen_obj: 
    . . . 

allora si può vedere che mygen() viene chiamato solo una volta, ed è crea un nuovo oggetto, ed è l'oggetto che viene iterato. È possibile creare due sequenze nello stesso thread, se si voleva:

gen1 = mygen() 
gen2 = mygen() 
print(gen1.__next__(), gen2.__next__(), gen1.__next__(), gen2.__next__()) 

questo stampa 0, 0, 1, 1.

Si potrebbe accedere allo stesso iteratore da due fili, se volete, basta memorizzare l'oggetto generatore in un globale:

global_gen = mygen() 

filettatura 1:

for i in global_gen: 
    . . . 

filettatura 2:

for i in global_gen: 
    . . . 

Questo probabilmente causerebbe tutti i tipi di scempio. :-)