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

Question

क्या एक सजावट लिखने का कोई तरीका है जैसे कि निम्नलिखित काम करेगा?

assert 'z' not in globals() 

@my_decorator 
def func(x, y): 
    print z 

---

संपादित करें: वाक्य रचना चीनी/सूखी: हॉप की "? क्यों" करने के लिए anwser

से चले गए जवाब में।

यह कैशिंग के बारे में नहीं है, यह x & y के मानों के आधार पर z (और z1, z2, z3, ...) की गणना करने के बारे में है।

मैं कार्य करता है जो संबंधित बातें करते हैं के बहुत सारे है, और मैं ऐसा नहीं करना चाहता हर एक समारोह की शुरुआत में

z1, z2, z3=calculate_from(x, y) 

लिखने के लिए है - क्या मैं कहीं गलत यह मिल जाएगा। अगर यह सी था तो मैं इसे सीपीपी के साथ करूँगा (अगर यह लापरवाह था, तो मैं मैक्रोज़ के साथ ऐसा करूँगा ...), लेकिन मैं देखना चाहता था कि सजावटी एक ही काम कर सकते हैं या नहीं।

यदि यह मदद करता है, तो मैं लगभग निश्चित रूप से सजावटी "precalculate_z" को कॉल करता हूं, और यह निश्चित रूप से किसी भी सार्वजनिक एपीआई का हिस्सा नहीं होगा।

मैं शायद के साथ-साथ विश्वस्तरीय अधोसंरचना का उपयोग करने से एक समान प्रभाव हो सकता है, लेकिन मैं यह देखने के लिए अगर यह कच्चे कार्यों के साथ संभव था चाहता था।

Answer 1

गूंज हॉप के जवाब

1. ऐसा मत करो।
2. गंभीरता से, ऐसा मत करो। लिस्प और रूबी अपने स्वयं के कस्टम वाक्यविन्यास लिखने के लिए अधिक उपयुक्त भाषाएं हैं। उनमें से एक का प्रयोग करें। या यह
3. करने के लिए एक क्लीनर तरीका ढूंढें यदि आपको जरूरी है, तो आप गतिशील स्कॉप्ड वेरिएबल्स चाहते हैं, न कि स्पष्ट रूप से स्कॉप्ड।

पायथन में गतिशील रूप से स्केल किए गए चर नहीं हैं, लेकिन आप इसे अनुकरण कर सकते हैं। यहाँ एक उदाहरण है कि यह एक वैश्विक बाध्यकारी बनाने के द्वारा simulates है, लेकिन बाहर निकलने पर पिछले मान पुनर्स्थापित करता है:

http://codepad.org/6vAY8Leh

def adds_dynamic_z_decorator(f): 
    def replacement(*arg,**karg): 
    # create a new 'z' binding in globals, saving previous 
    if 'z' in globals(): 
     oldZ = (globals()['z'],) 
    else: 
     oldZ = None 
    try: 
     globals()['z'] = None 
     #invoke the original function 
     res = f(*arg, **karg) 
    finally: 
     #restore any old bindings 
     if oldZ: 
     globals()['z'] = oldZ[0] 
     else: 
     del(globals()['z']) 
    return res 
    return replacement 

@adds_dynamic_z_decorator 
def func(x,y): 
    print z 

def other_recurse(x): 
    global z 
    print 'x=%s, z=%s' %(x,z) 
    recurse(x+1) 
    print 'x=%s, z=%s' %(x,z) 

@adds_dynamic_z_decorator 
def recurse(x=0): 
    global z 
    z = x 
    if x < 3: 
    other_recurse(x) 

print 'calling func(1,2)' 
func(1,2) 

print 'calling recurse()' 
recurse() 

मैं उपयोगिता या इसके बाद के कोड के विवेक पर कोई वारंटी देते हैं। दरअसल, मैं वारंट करता हूं कि पागल है, और जब तक आप अपने पायथन सहकर्मियों से फ़्लॉगिंग नहीं करना चाहते हैं, तब तक इसका उपयोग करना चाहिए।

यह कोड eduffy और जॉन मॉन्टगोमेरी के कोड दोनों के समान है, लेकिन यह सुनिश्चित करता है कि 'z' बनाया गया है और स्थानीय चर के रूप में ठीक तरह से पुनर्स्थापित किया जाएगा - उदाहरण के लिए, ध्यान दें कि 'other_recurse' कैसे देख सकता है 'रिकर्स' के शरीर में निर्दिष्ट 'जेड' के लिए बाध्यकारी।

Answer 2

मुझे स्थानीय दायरे के बारे में पता नहीं है, लेकिन आप अस्थायी रूप से एक वैकल्पिक वैश्विक नाम स्थान प्रदान कर सकते हैं। की तरह कुछ:

 


import types 

def my_decorator(fn): 
    def decorated(*args,**kw): 
     my_globals={} 
     my_globals.update(globals()) 
     my_globals['z']='value of z' 
     call_fn=types.FunctionType(fn.func_code,my_globals) 
     return call_fn(*args,**kw) 
    return decorated 

@my_decorator 
def func(x, y): 
    print z 

func(0,1) 

 

कौन सा "Z का मान"

Answer 3

प्रिंट चाहिए क) यह मत करो।

बी) गंभीरता से, आप ऐसा क्यों करेंगे?

सी) आप अपने सजावटी के भीतर जेड को ग्लोबल घोषित कर सकते हैं, इसलिए जब तक पहली बार सजावटी को बुलाया नहीं जाता है, तो ज़ेड ग्लोबल्स() में नहीं होगा, इसलिए जोर नहीं लगेगा।

डी) क्यों ???

Answer 4

मैं शायद के साथ-साथ विश्वस्तरीय अधोसंरचना का उपयोग करने से एक समान प्रभाव हो सकता है, लेकिन मैं यह देखने के लिए अगर यह कच्चे कार्यों के साथ संभव था चाहता था।

खैर, पायथन एक ऑब्जेक्ट उन्मुख भाषा है। आपको मेरी राय में कक्षा में ऐसा करना चाहिए। एक अच्छा वर्ग इंटरफ़ेस बनाना निश्चित रूप से आपकी समस्या को सरल बना देगा। यह नहीं है जो सजावटी के लिए बनाया गया था।

Answer 5

मैं पहली बार "कृपया मत" गूंज प्रयास करेंगे, लेकिन तुम्हारी पसंद है। यहाँ आप के लिए एक समाधान है:

assert 'z' not in globals() 

class my_dec: 
    def __init__ (self, f): 
     self.f = f 
    def __call__ (self,x,y): 
     z = x+y 
     self.f(x,y,z) 

@my_dec 
def func (x,y,z): 
    print z 

func (1,3) 

यह औपचारिक पैरामीटर में z की आवश्यकता होती है, लेकिन वास्तविक नहीं।

Answer 6

स्पष्ट से स्पष्ट स्पष्ट है।

क्या यह पर्याप्त है?

def provide_value(f): 
    f.foo = "Bar" 
    return f 

@provide_value 
def g(x): 
    print g.foo 

(तुम सच में बुराई चाहते हैं, f.func_globals को बताए मज़ा लगता है।)

Answer 7

दूसरों एक काम डेकोरेटर बनाने का कुछ तरीके दे दिया है, कई ऐसा न करने की सलाह दी है, क्योंकि यह शैलीगत अलग है सामान्य पायथन व्यवहार से यह वास्तव में कोड को समझने की कोशिश कर रहे किसी को भी भ्रमित करेगा।

यदि आपको चीजों को फिर से समझने की आवश्यकता है, तो क्या उन्हें किसी ऑब्जेक्ट में उन्हें समूहित करने का अर्थ होगा? कन्स्ट्रक्टर z1 ... कन्स्ट्रक्टर में जेएनएन, तो इन मानों का उपयोग करने वाले फ़ंक्शंस उदाहरण के हिस्से के रूप में पूर्व-गणना वाले उत्तरों तक पहुंच सकते हैं।