क्या पाइथन में कोई लाइब्रेरी फ़ंक्शन है जो जनरेटर-फ़ंक्शन को किसी फ़ंक्शन को वापस करने के लिए चालू करता है?

Question

कई बार मैंने सोचा है कि जनरेटर शैली और अधिक प्रत्यक्ष हो सकता है कि एक सूची लौट रहा, उदाहरण के लिए,

def foo(input_array): 
    for x in input_array: 
     yield processed(x) 

बनाम

def bar(input_array): 
    accumulator = [] 
    for x in input_array: 
     accumulator.append(processed(x)) 
    return accumulator 

(ठीक है, अगर सचमुच यह इतना आसान थे , मैं map लिखूंगा, लेकिन आपको बिंदु मिल जाएगा: जेनरेटर संस्करण क्लीनर है)। हालांकि, जनरेटर का रिटर्न प्रकार हमेशा वांछित नहीं होता है। क्या कोई अंतर्निर्मित सजावट है जिसे मैं foo को किसी सूची या टुपल को वापस करने वाले फ़ंक्शन में बदलने के लिए उपयोग कर सकता हूं? जिस तरह से मैं लिखते हैं अपने आप को है,

import functools 

def transform_return_value(transformer): 
    def inner(f): 
     @functools.wraps(f) 
     def new_f(*argv, **kwargs): 
      return transformer(f(*argv, **kwargs)) 
     return new_f 
    return inner 

@transform_return_value(list) 
def foo(input_array): 
    for x in input_array: 
     yield processed(x) 

Answer 1

मेरी जानकारी के अनुसार करने के लिए

(और मैं, देखा है क्योंकि मैं वास्तव में एक ही बात सोच है), कोई: वहाँ करने का कोई सीधा रास्ता है यह मानक पुस्तकालय के साथ।

वहाँ unstdlib.py पुस्तकालय में एक अच्छी तरह से परीक्षण listify आवरण है, हालांकि यह है: https://github.com/shazow/unstdlib.py/blob/master/unstdlib/standard/list_.py#L149

def listify(fn=None, wrapper=list): 
    """ 
    A decorator which wraps a function's return value in ``list(...)``. 

    Useful when an algorithm can be expressed more cleanly as a generator but 
    the function should return an list. 

    Example:: 

     >>> @listify 
     ... def get_lengths(iterable): 
     ...  for i in iterable: 
     ...   yield len(i) 
     >>> get_lengths(["spam", "eggs"]) 
     [4, 4] 
     >>> 
     >>> @listify(wrapper=tuple) 
     ... def get_lengths_tuple(iterable): 
     ...  for i in iterable: 
     ...   yield len(i) 
     >>> get_lengths_tuple(["foo", "bar"]) 
     (3, 3) 
    """ 
    def listify_return(fn): 
     @wraps(fn) 
     def listify_helper(*args, **kw): 
      return wrapper(fn(*args, **kw)) 
     return listify_helper 
    if fn is None: 
     return listify_return 
    return listify_return(fn) 

Answer 2

कुशल और संक्षिप्त सूची परिभाषा देखने के लिए का उपयोग करने की सूची समझ:

def foo(input_array): 
    return [processed(x) for x in input_array] 

आप एक चाहते हैं एक सूची वापस करने के लिए समारोह, यह एक सूची वापस आ गया है। यह सजावटी का उपयोग करने से अधिक साफ, समझने, पढ़ने और डीबग करने में आसान है।

आप फ़ंक्शन को कॉल करने के बजाय, इनलाइन को लिखना पसंद कर सकते हैं।

Answer 3

हालांकि @ दाऊद Wolever के जवाब suerly स्पष्ट तरीका है, एक बात मैं अक्सर अपने आप कर रही है (यह एक बाहरी डेकोरेटर को परिभाषित करने की आवश्यकता नहीं है के रूप में) इस तरह, एक स्थानीय समारोह के रूप में जनरेटर लिख रहा है लगता है:

def foo(input_array): 
    def gen(): 
     for x in input_array: 
      yield processed(x) 

    return list(gen())