Introduction au générateur de générateur Python

Quand j'ai suivi le blog de Liao Xuefeng pour apprendre Python, quand j'ai vu le chapitre sur les générateurs, j'ai d'abord mentionné générateur et rendement, puis en cherchant des informations, j'ai trouvé le concept de coroutines, ceci. L'article résume ces concepts.

　générateur Littéralement compris, il s'agit d'un générateur. Il existe deux façons de l'implémenter :

1. Différent pour les générateurs de listes ([]) , il est représenté par (). (Il s'avère que cela s'appelle une expression génératrice, haha)

Méthode d'accès, vous pouvez utiliser la boucle for pour accéder, vous pouvez également utiliser .next pour accéder.

N = ['Hello', 'World', 18, 'Apple', 'None']
hh = (s.lower() for s in N if isinstance(s,str) ==True)print hh#for item in hh:#    print item#print hh.next()#print hh.next()#print hh.next()#print hh.next()

Résultat de sortie

à 0x7f543a074690>
hello
world
apple
aucun

hh est la valeur renvoyée par le générateur, semblable à un tableau. Prise en charge de l'accès aux boucles et de l'accès .next(). Une chose à noter est que hh.next() ne peut pas être exécuté après l'exécution de la boucle for, comme lorsque le pointeur atteint la fin ou que l'itérateur en C++ pointe vers la fin. , puis accède à Une erreur se produira.

2. Utilisez rendement pour générer (appelé fonction génératrice)

Qu'il soit appelé avec next() ou une boucle for, une fois rendement exécuté, la valeur n est renvoyée, puis le current L'état est en attente puis revient.

def create_counter(n):print "create counter"#while True:while False:yield nprint 'increment n'n += 1cnt = create_counter(2)#print cntfor item in cnt:print item#print next(cnt)#print next(cnt)#print cnt.next()#print cnt.next()

Par exemple, dans cet exemple, lors de l'impression de cnt,

indique qu'il s'agit d'un générateur.
Quand est False, seul le compteur de création sera imprimé.

Quand il est True, une boucle infinie se produira lors de l'utilisation d'une boucle for.

Coroutine :

Je sais qu'il existe des notions de processus et de threads, mais je ne sais vraiment pas ce qu'est une coroutine.

D'un point de vue technique de vue Dites : "Une coroutine est une fonction dont vous pouvez suspendre l'exécution." Si vous comprenez cela comme "comme un générateur", alors vous avez raison . J'ai vu ça dans un article.

La raison pour laquelle Python a une efficacité d'exécution élevée

1. Le changement de sous-programme n'est pas un changement de thread, mais est contrôlé par le programme lui-même. Par conséquent, il n'y a pas de surcharge de changement de thread, en comparaison. avec le multi-threading, plus le nombre de threads est grand, plus les avantages en termes de performances des coroutines sont évidents.

2. Il n'y a aucun mécanisme de verrouillage impliqué dans le processus d'exécution.

Ci-joint un exemple simple de producteur et de consommateur :

def consumer():
    r = ''while True:
        n = yield rif not n:returnprint('[CONSUMER] Consuming %s...' % n)
        time.sleep(1)
        r = '200 OK'def produce(c):
    c.next()
    n = 0while n < 5:
        n = n + 1print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)print('[PRODUCER] Consumer return: %s' % r)
    c.close()if __name__=='__main__':
    c = consumer()
    produce(c)

1. La fonction consommateur est un générateur.
2. c.send(None) est en fait équivalent à next(c). Lorsqu'il est exécuté pour la première fois, il ne s'exécute que jusqu'à ce que n = rendement r, puis s'arrête, puis renvoie la valeur de r à. l'appelant.
3. rendement r est une expression assignée par send(msg), et send(msg) a une valeur de retour : le paramètre de la prochaine expression rendement r, qui est r. .
4. Une fois que le produit produit quelque chose, passez à l'exécution du consommateur via c.send(n). Le consommateur reçoit le message via le rendement, le traite et renvoie le résultat via le rendement. En d'autres termes, c.send(1) enverra non seulement une donnée à c, mais il attendra également le prochain rendement pour renvoyer une donnée de c. Il a une valeur de retour. Il est terminé après un seul passage. les données renvoyées (200 OK) continueront à s'exécuter.
5. L'ensemble du processus est sans verrouillage et exécuté par un seul thread. Le producteur et le consommateur coopèrent pour terminer la tâche, c'est pourquoi on l'appelle « coroutine » plutôt que multitâche préemptive de threads.

Pour résumer, rendement r est une expression assignée par c.send, puis La valeur de retour est le paramètre suivant de l'expression rendement r.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!