Gibt es eine Möglichkeit, nach einer Rücksendeanweisung mehr Arbeit zu leisten?

Question

Ich war ein bisschen neugierig, ob ich mehr Arbeit in einer Funktion machen könnte, nachdem ich ein Ergebnis zurückgegeben habe. Im Grunde mache ich eine Website mit dem Pyramiden-Framework (das einfach in Python codiert), nachdem ich die Eingaben verarbeitet habe. Ich gebe Variablen zurück, um die Seite zu rendern, aber manchmal möchte ich nach dem Rendern der Seite mehr arbeiten.

Zum Beispiel kommen Sie auf meine Website und aktualisieren Sie Ihr Profil und alles, was Sie interessieren, ist, dass es erfolgreich ist, so dass ich eine Nachricht mit dem Titel "Erfolg!" aber danach möchte ich dein Update nehmen und meine Aktivitäts-Logs aktualisieren, was du tust, deine Aktivitäts-Streams für deine Freunde aktualisierst usw. Momentan mache ich das alles, bevor ich den Ergebnisstatus zurückgebe, der dir wichtig ist, aber ich ' Ich bin neugierig, ob ich es nachher kann, damit die Benutzer ihre Antworten schneller bekommen.

Ich habe multi-processing vor und schlimmsten Fall gemacht ich könnte nur einen Thread fork diese Arbeit tun, aber wenn es eine Möglichkeit gab, nach einer return-Anweisung Arbeit zu tun, dann wäre das einfacher.

Beispiel:

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

Answer 1

Nein, leider, sobald Sie die return Aussage treffen, kehren Sie von der Funktion/Methode (entweder mit oder ohne Rückgabewert).

Vom docs for return:

Rückkehr verlässt den aktuellen Funktionsaufruf mit der Ausdrucksliste (oder keine) als Rückgabewert.

Möglicherweise möchten Sie in Generator-Funktionen suchen und die yield Aussage ist dies ein Weg, um einen Wert aus einer Funktion zurückzukehren und weiterverarbeiten und einen anderen Wert Vorbereitung zurückgegeben werden, wenn die Funktion das nächste Mal aufgerufen wird, .

Answer 2

Warum verwenden Sie keine contextmanager? Es macht im Grunde genau das, was Sie wollen.

Hier ist das kanonische Beispiel aus den Python-Dokumenten.

from contextlib import contextmanager 

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

Also für Ihre Funktion, würden Sie gerade tun:

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

Und es zu nennen, würden Sie gerade tun:

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 

EDIT: Ich habe nur die Dinge zu testen out, und es stellt sich heraus, dass die Funktion mit einer yield-Anweisung immer noch bis zum Ende ausgeführt wird. Hier ist ein dummes Beispiel, das den Punkt darstellt und wann die Dinge ausgeführt werden.

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] 

A contextmanager hat den Vorteil, nicht erfordern zwei next Anrufe zum Anschlag Iteration (und saubere Syntax) zu bekommen, aber wenn Sie mehrere Werte oder etwas zurückgeben wollen, könnten Sie es auch auf diese Weise tun, aber können Sie den Generator wirft StopIteration auf dem next Aufruf aufgerufen wird der Beitrag yield-Anweisung nicht wirklich sehen, dass bis (die for-Schleife endet, wenn es StopIteration bekommt)

---

aus irgendeinem Grund Wenn Sie einen höheren Grad erfordern der Kontrolle als @contextmanager bietet, können Sie auch o definiert eine Klasse mit __enter__ und __exit__ Methoden:

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

Sie noch etwas Arbeit nach der Rückkehr tun könnte, wenn man von einem Try-Block zurückzukehren, die schließlich Block würde noch ausgeführt werden, zB:

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

Zitiert the docs:

Wenn Rückkehr geht die Steuerung aus einer try-Anweisung mit einem schließlich clause, dass die finally-Klausel ausgeführt wird, bevor die Funktion wirklich verlassen wird.

Answer 4

Nein, eine Rückgabe gibt den Wert an den Aufrufer zurück und stoppt.

Wenn der Anrufer (n) sind auch unter Ihrer Kontrolle (nicht Teil der Pyramide Rahmen), könnten Sie profile_updates wie folgt aussehen ändern:

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

Und dann codieren den Anrufer um ein Paar zu erwarten von (response, task), anstatt nur eine Antwort. Es kann etwas sofort mit dem response Teil (kommunizieren Sie es mit dem Benutzer), dann task() aufrufen, um die Nachbearbeitung zu behandeln.

Dies ermöglicht profile_update zu bestimmen, welcher Code danach ausgeführt werden muss (und diese Details von der höheren Ebene verdeckt und verkapselt zu halten), ermöglicht es jedoch der höheren Ebene, den Kommunikationsfluss einer Antwort an den Benutzer zu bestimmen und dann die Ausführung auszuführen Nachbearbeitung im Hintergrund.

Answer 5

Es ist möglich, mit der Struktur try-except-finally zu betrügen. Beispiel:

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 

Beachten Sie, dass die finally Anweisung selbst ausgeführt werden, wenn eine Ausnahme abgefangen wurde.

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.. 

Hier verwenden wir die Threading-Funktionalität von Python.

Zuerst rufen wir die Update-Funktion auf (Sie können diese Funktion bei Bedarf auch im Thread verwenden und wenn die Antwort nicht von dieser Funktion abhängt und Sie die Antwort sofort geben müssen).

Dann haben wir einen Thread erstellt, der die maintainance_function-Funktion vervollständigt und nach dem Beenden stoppt. Aber die Antwort wird nicht verzögert, bis diese Funktion beendet ist.

dh: return "es hat funktioniert" wird zurückgegeben und dann auch der Thread behält die Funktion der Funktion Maintenance_function wenn ts ein bisschen Prozess.