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 … Read more
If you have long variablenames and would end up with: UserHandler.GetUser.First.User.FirstName=”Stefan” UserHandler.GetUser.First.User.LastName=”Karlsson” UserHandler.GetUser.First.User.Age=”39″ UserHandler.GetUser.First.User.Sex=”Male” UserHandler.GetUser.First.User.Occupation=”Programmer” UserHandler.GetUser.First.User.UserID=”0″ ….and so on then I would use WITH to make it more readable: With UserHandler.GetUser.First.User .FirstName=”Stefan” .LastName=”Karlsson” .Age=”39″ .Sex=”Male” .Occupation=”Programmer” .UserID=”0″ end with In the later example there are even performance benefit over the first example because in the … Read more
A with statement does not create a scope (like if, for and while do not create a scope either). As a result, Python will analyze the code and see that you made an assignment in the with statement, and thus that will make the variable local (to the real scope). In Python variables do not … Read more
The two code blocks you gave are not equivalent The code you described as old way of doing things has a serious bug: in case opening the file fails you will get a second exception in the finally clause because f is not bound. The equivalent old style code would be: try: f = open(“file”, … Read more
Those methods are pretty much all you need for making the object work with with statement. In __enter__ you have to return the file object after opening it and setting it up. In __exit__ you have to close the file object. The code for writing to it will be in the with statement body. class … Read more
Python 3.3 and above Python 3.3 introduced contextlib.ExitStack for just this kind of situation. It gives you a “stack”, to which you add context managers as necessary. In your case, you would do this: from contextlib import ExitStack with ExitStack() as stack: if needs_with(): gs = stack.enter_context(get_stuff()) # do nearly the same large block of … Read more
Python 3 Patch builtins.open and use mock_open, which is part of the mock framework. patch used as a context manager returns the object used to replace the patched one: from unittest.mock import patch, mock_open with patch(“builtins.open”, mock_open(read_data=”data”)) as mock_file: assert open(“path/to/open”).read() == “data” mock_file.assert_called_with(“path/to/open”) If you want to use patch as a decorator, using mock_open()‘s … Read more
In Python 2.7 and 3.1 and above, you can write: with A() as X, B() as Y, C() as Z: do_something() This is normally the best method to use, but if you have an unknown-length list of context managers you’ll need one of the below methods. In Python 3.3, you can enter an unknown-length list … Read more
Yes, it acts like the finally block after a try block, i.e. it always executes (unless the python process terminates in an unusual way of course). It is also mentioned in one of the examples of PEP-343 which is the specification for the with statement: with locked(myLock): # Code here executes with myLock held. The … Read more
Another use occurred to me today, so I searched the web excitedly and found an existing mention of it: Defining Variables inside Block Scope. Background JavaScript, in spite of its superficial resemblance to C and C++, does not scope variables to the block they are defined in: var name = “Joe”; if ( true ) … Read more