स्थानीय चर नाम फ़ंक्शन पैरामीटर नाम के समान होते हैं

Question

क्या यह लिखने का एक और अधिक शानदार तरीका है?

f(a=a, b=b, c=c, d=d, e=e) 

पृष्ठभूमि: मैं भी कई तर्क

f(a, b, c, d, e): 
    pass 

के साथ एक समारोह है मैं अपने कार्यक्रम मैं स्थानीय चर कि समारोह पैरामीटर के रूप में बिल्कुल एक ही नाम दिया जाता है।

a, b, c, d, e = range(5) 

मैं कीवर्ड तर्क के साथ फ़ंक्शन को कॉल करना चाहता हूं। चूंकि चर का नाम समान है, इस प्रकार कॉल दिखाई देगी।

g = f(a=a, b=b, c=c, d=d, e=e) # this can get very long 

बेशक

, मैं इस उदाहरण में स्थिति कीवर्ड का नहीं इस

g = f(a, b, c, d, e) 

लेकिन a, b, c, d, e की तरह बस चर के नाम का उपयोग कर रहे aruguments गुजरती हैं और यह कर सकते हैं सही क्रम देखने में आसान है। हालांकि दुर्भाग्यवश मेरे कार्यक्रम में चर को अधिक जटिल रूप से नामित किया गया है और कोई आसानी से स्पष्ट प्राकृतिक आदेश नहीं है। इसलिए मैं वास्तव में किसी भी गलतियों से बचने के लिए उन्हें कीवर्ड द्वारा पास करना चाहता हूं।

Answer 1

आप निम्न की तरह कुछ कर सकता है:

a, b, c, d, e = range(5) 
arg_dict = lambda l: dict((k, globals()[k]) for k in l.split(', ')) 

arg_dict('a, b, c, d, e') => {'a': 0, 'c': 2, 'b': 1, 'e': 4, 'd': 3} है, तो आप इस तरह अपने फ़ंक्शन को कॉल कर सकते हैं:

f(**arg_dict('a, b, c, d, e')) 

यह आपको निर्दिष्ट करने के लिए वास्तव में कौन-चर आप करना चाहते हैं की क्षमता देता है उपयोग। इसके लिए एक वैकल्पिक तरीका globals() का उपयोग नहीं करेगा eval() का उपयोग करना होगा, लेकिन यह लैम्ब्डा का संभावित रूप से असुरक्षित उपयोग कर सकता है।

arg_dict = lambda l: dict(zip(l.split(', '), eval(l))) 

आप के बजाय लैम्ब्डा में globals() का उपयोग कर आप निम्नलिखित का उपयोग कर सकते की एक तर्क के रूप में locals() पारित करने के लिए पसंद करेंगे, तो:

arg_dict = lambda l, d=locals(): dict((k, d[k]) for k in l.split(', ')) 
f(**arg_dict('a, b, c, d, e')) 

locals() सुझाव के लिए senderle के लिए धन्यवाद।

Answer 2

आप यहां ** किलोवाट का उपयोग क्यों नहीं कर सकते?

def foo(**kw): 
    for k,v in kw.items(): 
     print k,v 


foo(a=2) 
foo(a=3, b=4) 
foo(nonsene=True, blather=False) 

Answer 3

locals() अपने स्थानीय चर देता है, तो आप

def somewhere(): 
    x = 3 # its a local 
    f(**locals()) # same as f(x=3) 

कर सकता है, लेकिन आप निश्चित रूप से देख सकते हैं कि यह कैसे बहुत नाजुक है।