अजगर `map` और खोल

Question

मैं जानता हूँ कि तर्क, कि

map(function, arguments) 

for argument in arguments: 
    function(argument) 

के बराबर है यह नक्शा समारोह का उपयोग करने के लिए निम्न कार्य करना संभव है?

for arg, kwargs in arguments: 
    function(arg, **kwargs) 

Answer 1

आप कर सकते हैं एक लैम्ब्डा के साथ:

map(lambda a: function(a[0], **a[1]), arguments) 

या आप एक जनरेटर अभिव्यक्ति या सूची समझ इस्तेमाल कर सकते हैं, पर निर्भर करता है कि आप क्या चाहते:

(function(a, **k) for a, k in arguments) 
[function(a, **k) for a, k in arguments] 

अजगर 2 में, map() रिटर्न एक सूची (इसलिए सूची समझ समतुल्य है), पायथन 3, map() में जनरेटर है (इसलिए जनरेटर अभिव्यक्ति इसे प्रतिस्थापित कर सकती है)।

कोई अंतर्निहित या मानक लाइब्रेरी विधि नहीं है जो यह सीधे करती है; उपयोग का मामला बहुत विशिष्ट है।

Answer 2

आपको बस याद रखना होगा कि नक्शा फ़ंक्शन में तर्कों को अलग तर्कों के बजाय एक टुपल के रूप में पास करेगा। आप अपने मूल समारोह को बदल नहीं सकते हैं, तो आप यह एक सहायक समारोह के साथ कॉल कर सकते हैं:

def f(tup): 
    args, kwargs = tup 
    function(args, **kwargs) 

map(f, arguments) 

Answer 3

केवल स्थितीय तर्क के मामले के लिए, आप itertools.starmap(fun, args) उपयोग कर सकते हैं:

वापसी पुनरावर्तक जिनके मान दिया गया अनुक्रम से लिया गया तर्क टुपल के साथ मूल्यांकन किए गए फ़ंक्शन से वापस लौटाया जाता है।

उदाहरण:

from itertools import starmap 

def f(i, arg): 
    print(arg * (i+1)) 

for _ in starmap(f, enumerate(["a", "b", "c"])): 
    pass 

प्रिंट:

a 
bb 
ccc 

Answer 4

मैं एक ही जरूरत में चल रही है और निम्नलिखित समारोह बनाने समाप्त हो गया:

def kwarg_map(element_constructor, **kwarg_lists): 
    """ 
    A helper function for when you want to construct a chain of objects with individual arguments for each one. Can 
    be easier to read than a list expansion. 

    :param element_constructor: A function of the form object = fcn(**kwargs) 
    :param kwarg_lists: A dict of lists, where the index identifies two which element its corresponding value will go. 
    :return: A list of objects. 

    e.g. Initializing a chain of layers: 
     layer_sizes = [784, 240, 240, 10] 
     layers = kwarg_map(
      Layer, 
      n_in = layer_sizes[:-1], 
      n_out = layer_sizes[1:], 
      activation = ['tanh', 'tanh', 'softmax'], 
      ) 

    is equivalent to: 
     layers = [Layer(n_in=784, n_out=240, activation='tanh'), Layer(n_in=240, n_out=240, activation='tanh'), Layer(n_in=240, n_out=10, activation='softmax')] 
    """ 
    all_lens = [len(v) for v in kwarg_lists.values()] 
    assert len(kwarg_lists)>0, "You need to specify at least list of arguments (otherwise you don't need this function)" 
    n_elements = all_lens[0] 
    assert all(n_elements == le for le in all_lens), 'Inconsistent lengths: %s' % (all_lens,) 
    return [element_constructor(**{k: v[i] for k, v in kwarg_lists.iteritems()}) for i in xrange(n_elements)]