I&#39;d just like to exit out of a `with` statement under certain conditions:

    with open(path) as f:
        print &#39;before condition&#39;
        if &lt;condition&gt;: break #syntax error!
        print &#39;after condition&#39;

Of course, the above doesn&#39;t work. Is there a way to do this? (I know that I can invert the condition: `if not &lt;condition&gt;: print &#39;after condition&#39;` -- any way that is like above?)


Break or exit out of &quot;with&quot; statement?

I have some legacy code with a legacy function that takes a filename as an argument and processes the file contents.  A working facsimile of the code is below.

What I want to do is not have to write to disk with some content that I generate in order to use this legacy function, so I though I could use `StringIO` to create an object in place of the physical filename.  However, this does not work, as you can see below.

I thought `StringIO` was the way to go with this.  Can anyone tell me if there is a way to use this legacy function and pass it something in the argument that isn&#39;t a file on disk but can be treated as such by the legacy function?  The legacy function does have the `with` context manager doing work on the `filename` parameter value.

The one thing I came across in google was: http://bugs.python.org/issue1286, but that didn&#39;t help me...


**Code**

    from pprint import pprint
    import StringIO

        # Legacy Function
    def processFile(filename):
        with open(filename, &#39;r&#39;) as fh:
            return fh.readlines()

        # This works
    print &#39;This is the output of FileOnDisk.txt&#39;
    pprint(processFile(&#39;c:/temp/FileOnDisk.txt&#39;))
    print

        # This fails
    plink_data = StringIO.StringIO(&#39;StringIO data.&#39;)
    print &#39;This is the error.&#39;
    pprint(processFile(plink_data))

**Output**

This is the output in `FileOnDisk.txt`:

    [&#39;This file is on disk.\n&#39;]

This is the error:

&lt;!-- language: lang-none --&gt;

    Traceback (most recent call last):
      File &quot;C:\temp\test.py&quot;, line 20, in &lt;module&gt;
        pprint(processFile(plink_data))
      File &quot;C:\temp\test.py&quot;, line 6, in processFile
        with open(filename, &#39;r&#39;) as fh:
    TypeError: coercing to Unicode: need string or buffer, instance found


StringIO and compatibility with &#39;with&#39; statement (context manager)

I have the following code:

    class Test:

        def __init__(self, name):
            self.name = name

        def __enter__(self):
            print(f&#39;entering {self.name}&#39;)

        def __exit__(self, exctype, excinst, exctb) -&gt; bool:
            print(f&#39;exiting {self.name}&#39;)
            return True

    with Test(&#39;first&#39;) as test:
        print(f&#39;in {test.name}&#39;)

    test = Test(&#39;second&#39;)
    with test:
        print(f&#39;in {test.name}&#39;)

Running it produces the following output:

```lang-none
entering first
exiting first
entering second
in second
exiting second
```

But I expected it to produce:

```lang-none
entering first
in first
exiting first
entering second
in second
exiting second
```

Why isn&#39;t the code within my first example called?




Invoking a constructor in a &#39;with&#39; statement

Is there a way to create a temporary directory in a context manager with Python 2.7?

    with tempfile.TemporaryDirectory() as temp_dir:
        # modify files in this dir
    
    # here the temporary diretory does not exist any more.

tempfile.TemporaryDirectory context manager in Python 2.7

Suppose you have three objects you acquire via context manager, for instance A lock, a db connection and an ip socket.
You can acquire them by:

    with lock:
       with db_con:
           with socket:
                #do stuff

But is there a way to do it in one block? something like

    with lock,db_con,socket:
       #do stuff

Furthermore, is it possible, given an array of unknown length of objects that have context managers, is it possible to somehow do:

    a=[lock1, lock2, lock3, db_con1, socket, db_con2]
    with a as res:
        #now all objects in array are acquired


If the answer is &quot;no&quot;, is it because the need for such a feature implies bad design, or maybe I should suggest it in a pep? :-P


Create a &quot;with&quot; block on several context managers?

How do I test the following code with [`unittest.mock`][1]:

    def testme(filepath):
        with open(filepath) as f:
            return f.read()


  [1]: https://docs.python.org/3/library/unittest.mock.html

How do I mock an open used in a with statement (using the Mock framework in Python)?

Is this the right way to use the python &quot;with&quot; statement in combination with a try-except block?:

    try:
        with open(&quot;file&quot;, &quot;r&quot;) as f:
            line = f.readline()
    except IOError:
        &lt;whatever&gt;

If it is, then considering the old way of doing things:

    try:
        f = open(&quot;file&quot;, &quot;r&quot;)
        line = f.readline()
    except IOError:
        &lt;whatever&gt;
    finally:
        f.close()

Is the primary benefit of the &quot;with&quot; statement here that we can get rid of three lines of code?  It doesn&#39;t seem that compelling to me **for this use case** (though I understand that the &quot;with&quot; statement has other uses).

EDIT: Is the functionality of the above two blocks of code identical?

EDIT2: The first few answers talk generally about the benefits of using &quot;with&quot;, but those seem of marginal benefit here.  We&#39;ve all been (or should have been) explicitly calling f.close() for years.  I suppose one benefit is that sloppy coders will benefit from using &quot;with&quot;.

Using python &quot;with&quot; statement with try-except block

Is it possible to declare more than one variable using a `with` statement in Python?

Something like:

    from __future__ import with_statement
    
    with open(&quot;out.txt&quot;,&quot;wt&quot;), open(&quot;in.txt&quot;) as file_out, file_in:
        for line in file_in:
            file_out.write(line)


... or is cleaning up two resources at the same time the problem?
        




 



Multiple variables in a &#39;with&#39; statement?

I have to open a file-like object in python (it&#39;s a serial connection through /dev/) and then close it. This is done several times in several methods of my class. How I WAS doing it was opening the file in the constructor, and then closing it in the destructor. I&#39;m getting weird errors though and I think it has to do with the garbage collector and such, I&#39;m still not used to not knowing exactly when my objects are being deleted =\

The reason I was doing this is because I have to use `tcsetattr` with a bunch of parameters each time I open it and it gets annoying doing all that all over the place. So I want to implement an inner class to handle all that so I can use it doing  
`with Meter(&#39;/dev/ttyS2&#39;) as m:`

I was looking online and I couldn&#39;t find a really good answer on how the `with` syntax is implemented. I saw that it uses the `__enter__(self)` and `__exit(self)__` methods. But is all I have to do implement those methods and I can use the with syntax? Or is there more to it?

Is there either an example on how to do this or some documentation on how it&#39;s implemented on file objects already that I can look at?

Implementing use of &#39;with object() as f&#39; in custom class in python

Is there a way to begin a block of code with a with statement, but conditionally?

Something like:

    if needs_with():
        with get_stuff() as gs:
        
    # do nearly the same large block of stuff,
    # involving gs or not, depending on needs_with()

To clarify, one scenario would have a block encased in the with statement, while another possibility would be the same block, but not encased (i.e., as if it wasn&#39;t indented)

Initial experiments of course give indentation errors..

Conditional with statement in Python

I saw this in someone&#39;s code. What does it mean?

        def __enter__(self):
            return self
    
        def __exit__(self, type, value, tb):
            self.stream.close()


***

    from __future__ import with_statement#for python2.5 
    
    class a(object):
        def __enter__(self):
            print &#39;sss&#39;
            return &#39;sss111&#39;
        def __exit__(self ,type, value, traceback):
            print &#39;ok&#39;
            return False
    
    with a() as s:
        print s
        
        
    print s

Explaining Python&#39;s &#39;__enter__&#39; and &#39;__exit__&#39;

I came across the Python `with` statement for the first time today.  I&#39;ve been using Python lightly for several months and didn&#39;t even know of its existence!  Given its somewhat obscure status, I thought it would be worth asking:

 1. What is the Python `with` statement
    designed to be used for?   
 1. What do
    you use it for? 
 1. Are there any
    gotchas I need to be aware of, or
    common anti-patterns associated with
    its use?  Any cases where it is better use `try..finally` than `with`?
 1. Why isn&#39;t it used more widely?
 1. Which standard library classes are compatible with it?

What is the python &quot;with&quot; statement designed for?

[Alan Storm&#39;s comments][1] in response to my answer regarding the [`with` statement][2] got me thinking. I&#39;ve seldom found a reason to use this particular language feature, and had never given much thought to how it might cause trouble. Now, I&#39;m curious as to how I might make effective use of `with`, while avoiding its pitfalls.

Where have you found the `with` statement useful?

  [1]: http://www.stackoverflow.com/questions/61088/hidden-features-of-javascript#61118
  [2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with


Are there legitimate uses for JavaScript&#39;s &quot;with&quot; statement?

At work, I&#39;m frequently working on projects where numerous properties of certain objects have to be set during their construction or early during their lifetime. For the sake of convenience and readability, I often use the &lt;code&gt;With&lt;/code&gt; statement to set these properties. I find that

    With Me.Elements
        .PropertyA = True
        .PropertyB = &quot;Inactive&quot;
        &#39; And so on for several more lines
    End With

Looks much better than

    Me.Elements.PropertyA = True
    Me.Elements.PropertyB = &quot;Inactive&quot;
    &#39; And so on for several more lines

for very long statements that simply set properties.

I&#39;ve noticed that there are some issues with using &lt;code&gt;With&lt;/code&gt; while debugging; however, **I was wondering if there were any compelling reasons to avoid using &lt;code&gt;With&lt;/code&gt; in practice**? I&#39;ve always assumed the code generated via the compiler for the above two cases is basically the same which is why I&#39;ve always chosen to write what I feel to be more readable. 

The VB.NET &#39;With&#39; Statement - embrace or avoid?

Consider the following:

    with open(path, mode) as f:
        return [line for line in f if condition]

Will the file be closed properly, or does using `return` somehow bypass the [context manager](https://docs.python.org/library/contextlib.html)?


In Python, if I return inside a &quot;with&quot; block, will the file still close?

I am reading only `firstline` from python using :

    with open(file_path, &#39;r&#39;) as f:
        my_count = f.readline()
    print(my_count)

I am bit confused over scope of variable my_count. Although prints work fine, would it be better to do something like `my_count = 0` outside with statement first (for eg in C in used to do int `my_count = 0`)

Scope of variable within &quot;with&quot; statement?

So I want to do something like follows:

    {% if age &gt; 18 %}
        {% with patient as p %}
    {% else %}
        {% with patient.parent as p %}
        ...
    {% endwith %}
    {% endif %}

But Django is telling me that I need another {% endwith %} tag.  Is there any way to rearrange the withs to make this work, or is the syntactic analyzer purposefully carefree in regards to this sort of thing?

Maybe I&#39;m going about this the wrong way.  Is there some sort of best practice when it comes to something like this?

Django {% with %} tags within {% if %} {% else %} tags?

What is a clean way to create a multi-line `with` in python? I want to open up several files inside a single `with`, but it&#39;s far enough to the right that I want it on multiple lines. Like this:

    class Dummy:
        def __enter__(self): pass
        def __exit__(self, type, value, traceback): pass
    
    with Dummy() as a, Dummy() as b,
         Dummy() as c:
        pass

Unfortunately, that is a `SyntaxError`. So I tried this:

    with (Dummy() as a, Dummy() as b,
          Dummy() as c):
        pass

Also a syntax error. However, this worked:

    with Dummy() as a, Dummy() as b,\
         Dummy() as c:
        pass

But what if I wanted to place a comment? This does not work:

    with Dummy() as a, Dummy() as b,\
         # my comment explaining why I wanted Dummy() as c\
         Dummy() as c:
        pass

Nor does any obvious variation on the placement of the `\`s.

Is there a clean way to create a multi-line `with` statement that allows comments inside it?

All With Statement Solutions on Gang of Coders

Total of 18 With Statement Solutions

Break or exit out of "with" statement?

StringIO and compatibility with 'with' statement (context manager)

Invoking a constructor in a 'with' statement

tempfile.TemporaryDirectory context manager in Python 2.7

Create a "with" block on several context managers?

How do I mock an open used in a with statement (using the Mock framework in Python)?

Using python "with" statement with try-except block

Multiple variables in a 'with' statement?

Implementing use of 'with object() as f' in custom class in python

Conditional with statement in Python

Explaining Python's 'enter' and 'exit'

What is the python "with" statement designed for?

Are there legitimate uses for JavaScript's "with" statement?

The VB.NET 'With' Statement - embrace or avoid?

In Python, if I return inside a "with" block, will the file still close?

Scope of variable within "with" statement?

Django {% with %} tags within {% if %} {% else %} tags?

Python multi-line with statement