Break or exit out of "with" statement?

I think you should just restructure the logic:

with open(path) as f:
    print 'before condition checked'
    if not <condition>:
        print 'after condition checked'

with giving you trouble? Throw more with-able objects at the problem!

class fragile(object):
    class Break(Exception):
      """Break out of the with statement"""

    def __init__(self, value):
        self.value = value

    def __enter__(self):
        return self.value.__enter__()

    def __exit__(self, etype, value, traceback):
        error = self.value.__exit__(etype, value, traceback)
        if etype == self.Break:
            return True
        return error

Just wrap the expression you're going to with with fragile, and raise fragile.Break to break out at any point!

with fragile(open(path)) as f:
    print 'before condition'
    if condition:
        raise fragile.Break
    print 'after condition'

Benefits of this setup

• Uses with and just the with; doesn't wrap your function in a semantically misleading one-run 'loop' or a narrowly specialized function, and doesn't force you to do any extra error handling after the with.
• Keeps your local variables available, instead of having to pass them to a wrapping function.

• Nestable!

  with fragile(open(path1)) as f:
      with fragile(open(path2)) as g:
          print f.read()
          print g.read()
          raise fragile.Break
          print "This wont happen"
      print "This will though!"
  

  This way, you don't have to create a new function to wrap the outer with if you want both to break.

• Doesn't require restructuring at all: just wrap what you already have with fragile and you're good to go!

Downsides of this setup

• Doesn't actually use a 'break' statement. Can't win em all ;)

This is an ancient question, but this is an application for the handy "breakable scope" idiom. Just imbed your with statement inside:

for _ in (True,):
    with open(path) as f:
        print 'before condition'
        if <condition>: break
        print 'after condition'

This idiom creates a "loop", always executed exactly once, for the sole purpose of enclosing a block of code inside a scope that can be broken out of conditionally. In OP's case, it was a context manager invocation to be enclosed, but it could be any bounded sequence of statements that may require conditional escape.

The accepted answer is fine, but this technique does the same thing without needing to create a function, which is not always convenient or desired.

The best way would be to encapsulate it in a function and use return:

def do_it():
    with open(path) as f:
        print 'before condition'
        if <condition>:
            return
        print 'after condition'