Post-Funktionsaufrufe mit der Anweisung

Question

ausblenden

Ich habe eine Funktion f, die zwei Parameter zurückgibt. Nach dieser Funktion verwende ich den ersten Parameter. Ich brauche den zweiten, um Dinge mit einer anderen Funktion zusammen zu kleben g. So würde mein Code wie folgt aussehen:

a, b = f() 
# do stuff with a 
g(b) 

Diese sehr repetitiv ist, so dass ich dachte ich so etwas wie ein RAII Ansatz nutzen könnten. Aber, da ich weiß nicht, wann Objekte werden sterben und mein Hauptziel ist der repetitiven Code, um loszuwerden, habe ich die with Aussage:

with F() as a: 
    # do stuff with a 

Das ist es. Ich habe im Grunde um diese Funktion ein Objekt F erstellt, das __enter__ und __exit__ Funktionen liefert (und natürlich __init__ Funktion).

Allerdings frage ich mich immer noch, ob dies die richtige "Pythonic" -Methode ist, dies zu handhaben, da eine with-Anweisung Ausnahmen behandeln sollte. Vor allem diese __exit__ Funktion hat drei Argumente, die ich im Moment nicht verwende.

Edit (weitere Erklärungen): Immer wenn ich f() anrufen muss ich etwas mit b tun. Es ist egal, was dazwischen passiert ist. Ich drückte es als g(b) aus. Und genau das verberge ich in der with-Anweisung. So muss der Programmierer nach jedem Aufruf von f() nicht mehr g(b) eingeben, was sehr unordentlich und verwirrend werden könnte, da #do stuff with a langwierig werden könnte.

Answer 1

Eine etwas pythonic Art und Weise tun, die contextlib Modul zu verwenden wäre. Sie können Ihre eigene Klasse mit den Funktionen __enter__ und __exit__ ausrollen.

from contextlib import contextmanager 

def g(x): 
    print "printing g(..):", x 

def f(): 
    return "CORE", "extra" 

@contextmanager 
def wrap(): 
    a, b = f() 
    try: 
     yield a 
    except Exception as e: 
     print "Exception occurred", e 
    finally: 
     g(b) 
if __name__ == '__main__': 
    with wrap() as x: 
     print "printing f(..):", x 
     raise Exception() 

Ausgang:

$ python temp.py 
printing f(..): CORE 
Exception occurred 
printing g(..): extra 

Answer 2

Für jemand anderen, der Ihren Code liest (oder Sie in 6 Monaten), wird ein Kontextmanager wahrscheinlich die Erstellung/Initialisierung und Schließung/Löschung einer Ressource implizieren, und ich würde sehr vorsichtig sein, das Idiom neu zu verwenden.

Sie könnten Zusammensetzung verwenden, anstatt ein Kontext-Manager:

def func(a, b): 
    # do stuff with a & optionally b 

def new_f(do_stuff): 
    a, b = f() 
    do_stuff(a, b) 
    g(b) 


new_f(func)