वापसी विवरण के बाद और अधिक काम करने का कोई तरीका है?

Question

अगर मैं परिणाम लौटने के बाद एक समारोह में और अधिक काम कर सकता तो मैं थोड़ा उत्सुक था। असल में मैं पिरैमिड फ्रेमवर्क (जो कि केवल पायथन में कोडिंग कर रहा है) का उपयोग कर एक साइट बना रहा हूं, जब मैं इनपुट को संसाधित करता हूं तो मैं पृष्ठ प्रस्तुत करने के लिए चर लौटाता हूं लेकिन कभी-कभी मैं पृष्ठ प्रस्तुत करने के बाद और अधिक काम करना चाहता हूं।

उदाहरण के लिए, आप मेरी साइट पर आते हैं और अपनी प्रोफ़ाइल अपडेट करते हैं और आप जिसकी परवाह करते हैं वह यह है कि यह सफल है इसलिए मैंने 'सफलता' कहकर एक संदेश आउटपुट किया। लेकिन इसके बाद मैं अपना अपडेट लेना चाहता हूं और अपना काम करना चाहता हूं कि आप क्या कर रहे हैं, अपने दोस्तों की गतिविधि धाराओं को अपडेट करें, इत्यादि। अभी मैं परिणाम की स्थिति लौटने से पहले मैं सब कुछ कर रहा हूं, लेकिन मैं ' मैं उत्सुक हूं अगर मैं इसे कर सकता हूं ताकि उपयोगकर्ता अपने प्रतिक्रिया तेज कर सकें।

मैंने पहले से ही बहु-प्रसंस्करण किया है और सबसे खराब मामला है कि मैं सिर्फ इस काम को करने के लिए थ्रेड फोर्क कर सकता हूं लेकिन यदि वापसी विवरण के बाद काम करने का कोई तरीका था तो यह आसान होगा।

उदाहरण:

def profile_update(inputs): 
    #take updates and update the database 
    return "it worked" 
    #do maintainence processing now.. 

Answer 1

नहीं है, दुर्भाग्य से, एक बार आप return बयान मारा, तुम समारोह/विधि (या तो साथ या एक वापसी मान के बिना) से लौटने।

docs for return से

:

वापसी अभिव्यक्ति सूची (या कोई नहीं) वापसी मान के रूप में के साथ वर्तमान समारोह कॉल छोड़ देता है।

आप जनरेटर कार्य करता है और yield बयान में देखना चाहते हो सकता है, यह एक समारोह से मान और प्रसंस्करण और एक अन्य मूल्य की तैयारी जारी रखने के लिए वापस करने के लिए एक रास्ता जब समारोह अगली बार कहा जाता है ।

Answer 2

आप contextmanager का उपयोग क्यों नहीं करते? यह मूल रूप से वही करता है जो आप चाहते हैं।

यहां पाइथन डॉक्स से कैननिकल उदाहरण है।

from contextlib import contextmanager 

@contextmanager 
def tag(name): 
    print "<%s>" % name 
    yield 
    print "</%s>" % name 

अपने समारोह के लिए

तो, तुम सिर्फ कर चाहते हैं:

@contextmanager 
def profile_update(inputs): 
    #take updates and update the database 
    yield "it worked" 
    #do maintainence processing now.. 

और यह कॉल करने के लिए, आप बस करना चाहते हैं:

with profile_update(inputs) as result: #pre-yield and yield here 
    # do whatever while in scope 
# as you move out of scope of with statement, post-yield is executed 

संपादित करें: मैं सिर्फ बातें परीक्षण किया गया था बाहर, और यह पता चला है कि, उपज बयान के साथ, समारोह अभी भी अंत तक निष्पादित करता है। यहां एक गूंगा उदाहरण है जो बिंदु को दिखाता है और जब चीजें निष्पादित होती हैं।

def some_generator(lst): 
    for elem in lst: 
     yield elem 
    lst[0] = "I WAS CHANGED POST-YIELD!!!!" 

>>> q = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> gen = some_generator(q) 
>>> for e in gen: 
... print e, q 

0 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
1 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
3 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
4 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
5 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
6 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
7 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
8 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
9 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

print q 
['I WAS CHANGED POST YIELD!!!', 1, 2, 3, 4, 5, 6, 7, 8, 9] 

एक contextmanager रोक यात्रा (और क्लीनर वाक्य रचना) को पाने के लिए दो next कॉल की जरूरत नहीं का लाभ दिया है, लेकिन अगर आप एक से अधिक मान या कुछ और देखना चाहता है, तो आप इसे इस तरह से भी कर सकता है, लेकिन आप देख सकते हैं कि पोस्ट उपज बयान वास्तव में जब तक जनरेटर next फोन पर StopIteration उठाती नहीं कहा जाता हो जाता है (पाश के लिए समाप्त हो जाती है जब यह StopIteration हो जाता है)

---

किसी कारण से, आप एक उच्च डिग्री की आवश्यकता होती है @contextmanager से अधिक नियंत्रण के लिए, आप als कर सकते हैं ओ __enter__ और __exit__ तरीकों के साथ एक वर्ग को परिभाषित:

class MyContextClass(object): 
    # ... 

    def __enter__(self): 
     # do some preprocessing 
     return some_object 

    def __exit__(self, exc_type, exc_value, traceback): 
     # do some post processing 
     # possibly do some processing of exceptions raised within the block 
     if exc_type == MyCustomErrorType: 
      return True #don't propagate the error 

Answer 3

तुम अब भी वापसी के बाद कुछ काम कर सकता है अगर आप एक कोशिश ब्लॉक से लौटने के लिए, अंत में ब्लॉक अभी भी निष्पादित किया जाएगा, जैसे:

def fun(): 
    try: 
     return 
    finally: 
     print "Yay! I still got executed, even though my function has already returned!" 

का हवाला देते हुए the docs:

जब वापसी एक अंत में +०१२३५१६४१०६ साथ एक कोशिश बयान से बाहर नियंत्रण गुजरताखंड, अंततः फ़ंक्शन को छोड़ने से पहले खंड को निष्पादित किया जाता है।

Answer 4

नहीं, एक रिटर्न कॉलर को वापस मूल्य देता है और बंद हो जाता है।

तो फोन करने वाले (रों) अपने नियंत्रण (पिरामिड ढांचे का हिस्सा नहीं) के तहत भी कर रहे हैं, तो आप profile_updates बदल निम्नलिखित की तरह लग रहे करने के लिए कर सकते हैं:

def profile_update(inputs): 
    #take updates and update the database 
    def post_processing_task(): 
     #do maintainence processing now.. 
    return ("it worked", post_processing_task) 

और फिर एक जोड़ी की उम्मीद फोन करने वाले कोड केवल एक प्रतिक्रिया के बजाय (response, task) का। यह response भाग (उपयोगकर्ता को इसे संवाद) के साथ तुरंत कुछ कर सकता है, फिर पोस्ट-प्रोसेसिंग को संभालने के लिए task() पर कॉल करें।

यह profile_update को यह निर्धारित करने के लिए profile_update की अनुमति देता है कि यह निर्धारित करने के लिए कि कौन से कोड को निष्पादित किया जाना चाहिए (और उन विवरणों को छुपाएं और उच्च स्तर से encapsulated रखें), लेकिन उच्च स्तर को उपयोगकर्ता को प्रतिक्रिया संचार करने के प्रवाह को निर्धारित करने और फिर निष्पादित करने की अनुमति देता है पृष्ठभूमि में पोस्ट प्रोसेसिंग।

Answer 5

try-except-finally संरचना के साथ धोखा देना संभव है। उदाहरण:

def function(): 
    try: 
    #do some stuff here 
    return x 
    except Exception: 
    #do something when an error occures 
    finally: 
    #do here whatever you wanna do after return 

ध्यान दें, कि finally बयान भले ही एक अपवाद पकड़ा गया था निष्पादित किया जाएगा।

Answer 6

import threading 

def profile_update(inputs): 

    # call function to take updates and update the database 
    update_function(inputs) 

    # call the maintainence_function here 
    t = threading.Thread(target=maintainence_function, args=[input1, input2]) 
    # setDaemon=False to stop the thread after complete 
    t.setDaemon(False) 
    # starting the thread 
    t.start() 

    # return response/anything-else you want to return 
    return "it worked" 



def update_function(inputs): 
    # updating the database process here 

def maintainence_function(input1, input2): 
    #do maintainence processing now.. 

यहां हम अजगर की थ्रेडिंग कार्यक्षमता का उपयोग करते हैं।

सबसे पहले हम अपडेट फ़ंक्शन को कॉल करते हैं (यदि आवश्यक हो तो आप इस फ़ंक्शन को थ्रेड में भी उपयोग कर सकते हैं और यदि प्रतिक्रिया इस फ़ंक्शन पर निर्भर नहीं होती है और यदि आपको तुरंत प्रतिक्रिया देने की आवश्यकता है)।

फिर हमने एक धागा बनाया है जो रखरखाव_फंक्शन फ़ंक्शन को पूरा करेगा और इसे समाप्त करने के बाद रोक देगा। लेकिन उस कार्य को समाप्त होने तक प्रतिक्रिया में देरी नहीं होगी।

यानी: लौटाएं "यह काम किया गया" वापस लौटा दिया जाएगा और फिर थ्रेड थोड़ी सी प्रक्रिया में फंक्शन रखरखाव_फंक्शन के काम को बनाए रखेगा।