Pomijanie wykonywania-z-bloku

Question

Definiuję klasy menedżera kontekstu i chciałbym móc pominąć blok kodu bez zgłaszania wyjątku, jeśli pewne warunki są spełnione podczas wystąpienia. Na przykład:

class My_Context(object): 
    def __init__(self,mode=0): 
     """ 
     if mode = 0, proceed as normal 
     if mode = 1, do not execute block 
     """ 
     self.mode=mode 
    def __enter__(self): 
     if self.mode==1: 
      print 'Exiting...' 
      CODE TO EXIT PREMATURELY 
    def __exit__(self, type, value, traceback): 
     print 'Exiting...' 

with My_Context(mode=1): 
    print 'Executing block of codes...' 

Answer 1

Jeśli chcesz rozwiązanie ad hoc, który wykorzystuje pomysły z withhacks (w szczególności z AnonymousBlocksInPython), to będzie działać:

import sys 
import inspect 

class My_Context(object): 
    def __init__(self,mode=0): 
     """ 
     if mode = 0, proceed as normal 
     if mode = 1, do not execute block 
     """ 
     self.mode=mode 
    def __enter__(self): 
     if self.mode==1: 
      print 'Met block-skipping criterion ...' 
      # Do some magic 
      sys.settrace(lambda *args, **keys: None) 
      frame = inspect.currentframe(1) 
      frame.f_trace = self.trace 
    def trace(self, frame, event, arg): 
     raise 
    def __exit__(self, type, value, traceback): 
     print 'Exiting context ...' 
     return True 

Porównaj następujące:

with My_Context(mode=1): 
    print 'Executing block of code ...' 

z

with My_Context(mode=0): 
    print 'Executing block of code ... ' 

Answer 2

To, co próbujesz zrobić, niestety nie jest możliwe. Jeśli __enter__ zgłasza wyjątek, ten wyjątek jest zgłaszany na oświadczeniu with (__exit__ nie jest wywoływany). Jeśli nie podniesie wyjątku, to zwracana wartość jest podawana do bloku i blok jest wykonywany.

najbliższą rzeczą mogę myśleć to wyraźnie zaznaczone flagi w bloku:

class Break(Exception): 
    pass 

class MyContext(object): 
    def __init__(self,mode=0): 
     """ 
     if mode = 0, proceed as normal 
     if mode = 1, do not execute block 
     """ 
     self.mode=mode 
    def __enter__(self): 
     if self.mode==1: 
      print 'Exiting...' 
     return self.mode 
    def __exit__(self, type, value, traceback): 
     if type is None: 
      print 'Normal exit...' 
      return # no exception 
     if issubclass(type, Break): 
      return True # suppress exception 
     print 'Exception exit...' 

with MyContext(mode=1) as skip: 
    if skip: raise Break() 
    print 'Executing block of codes...' 

ta pozwala także podnieść Break() w środku with bloku symulacji normalnego break oświadczenie.

Answer 3

Według PEP-343, A with oświadczenie przekłada od:

with EXPR as VAR: 
    BLOCK 

do:

mgr = (EXPR) 
exit = type(mgr).__exit__ # Not calling it yet 
value = type(mgr).__enter__(mgr) 
exc = True 
try: 
    try: 
     VAR = value # Only if "as VAR" is present 
     BLOCK 
    except: 
     # The exceptional case is handled here 
     exc = False 
     if not exit(mgr, *sys.exc_info()): 
      raise 
     # The exception is swallowed if exit() returns true 
finally: 
    # The normal and non-local-goto cases are handled here 
    if exc: 
     exit(mgr, None, None, None) 

Jak widać, nie jest niczym oczywistym można zrobić na podstawie zaproszenia do sposobu __enter__() menedżer kontekstu, który może pominąć treść ("BLOCK") instrukcji with.

Ludzie wykonali specyficzne dla implementacji Pythona rzeczy, takie jak manipulowanie stosem wywołań wewnątrz __enter__(), w projektach takich jak withhacks. Pamiętam, jak Alex Martelli opublikował bardzo interesujący wywiad z hackem na stackoverflow za rok lub dwa z powrotem (nie pamiętam wystarczająco dużo postu z ręki, aby go znaleźć i znaleźć).

Ale prostą odpowiedzią na twoje pytanie/problem jest to, że nie możesz zrobić tego, o co prosisz, pomijając treść instrukcji, bez uciekania się do tak zwanej "głębokiej magii" (która niekoniecznie jest przenośna między pythonami wdrożenia). Z głęboką magią możesz być w stanie to zrobić, ale zalecam robić tylko takie rzeczy, jak ćwiczenie, aby zobaczyć, jak można to zrobić, nigdy w "kodzie produkcyjnym".