Comment écrire des fonctions paresseuses qui sont chaînables, en python?

Question

Je veux écrire des fonctions aussi paresseuses que chaînables. Quel serait le meilleur moyen. Je sais que l'one-way serait de faire yield au lieu de return. Je veux que ces fonctions soient paresseuses de la même manière que les fonctions de sqlalchemy sont paresseuses lorsqu'on leur demande de récupérer les données de DB.

Answer 1

Générateurs (fonctions avec yield au lieu de return) peuvent en effet être considérés comme « paresseux » (et itertools.chain peut les enchaîner tout aussi bien que tout autre iterator, si c'est ce que vous entendez par « chainable »).

Mais si par « chainable » (et paresseux) que vous voulez dire que vous voulez appeler fee().fie().fo().fum() et ont tout le « travail » se produire que dans fum (qui semble plus proche de ce SQLAlchemy fait), alors générateurs ne va pas aider - - ce dont vous avez besoin, c'est le modèle de conception "Promise", où chaque fonction/méthode (sauf celle qui fait tout le travail) renvoie un objet qui enregistre toutes les conditions, les paramètres et les contraintes de l'opération, et l'un fonction laborieuse utilise cette information pour finalement effectuer le travail.

Pour donner un exemple très simple, dites que "le travail acharné" effectue un appel RPC de la forme remote(host, **kwargs). Vous pouvez habiller cela dans « vêtements chainable paresseux » comme suit:

class RPC(object): 
    def __init__(self, host): 
     self._host = host 
     self._kws = {} 
    def doit(self, **morekws): 
     return remote(self._host, **dict(self._kws, **morekws)) 
    def __getattr__(self, name): 
     def setkw(value): 
      self._kws[name] = value 
      return self 
     return setkw 

Maintenant, RPC(x).foo('bar').baz('bap').doit() appels remote(x, foo=bar, baz=bap) (et bien sûr, vous pouvez enregistrer les étapes intermédiaires de la chaîne, les passer autour comme arguments, etc, etc, jusqu'à ce que l'appel au doit).