with-statement

with open("hello.txt", "wb") as f: f.write("Hello Python!\n") seems to be the same as f = open("hello.txt", "wb") f.write("Hello Python!\n") f.close() What's the advantage of using open .. as instead of f = ? Is it just syntactic sugar? Just saving one line of code? mg. In order to be equivalent to the with statement version, the code you wrote should look instead like this: f = open("hello.txt", "wb") try: f.write("Hello Python!\n") finally: f.close() While this might seem like syntactic sugar, it ensures that you release resources. Generally the world is more complex than these contrived

is there a way to reference an object instance that is created using the "with" statement? Example: with TAnObject.Create do begin DoSomething(instance); end; Where DoSomething would use the instance reference as if you were passing an instance from a variable declared reference to the object created. Example: AnObject := TAnObject.Create; Thanks. Well, you can use such approach: // implement: type TSimpleMethod = procedure of object; function GetThis(const pr: TSimpleMethod): TObject; begin Result := TMethod(pr).Data; end; // usage: with TStringList.Create do try CommaText := '1,2,3,4,5,6,7,8

Some code to illustrate my question: With Test.AnObject .Something = 1337 .AnotherThing = "Hello" ''// why can't I do this to pass the object itself: Test2.Subroutine(.) ''// ... and is there an equivalent, other than repeating the object in With? End With There is no way to refer to the object referenced in the With statement, other than repeating the name of the object itself. EDIT If you really want to, you could modify your AnObject to return a reference to itself Public Function Self() as TypeOfAnObject Return Me End Get Then you could use the following code With Test.AnObject Test2

Is it possible to execute a block of code without the implicit with(global) context that all scripts seem to have by default? For example, in a browser, would there be any way to set up a script so that a line such as const foo = location; throws Uncaught ReferenceError: location is not defined instead of accessing window.location , when location has not been declared first? Lacking that, is there a way that such an implicit reference could result in a warning of some sort? It can be a source of bugs when writing code (see below), so having a way to guard against it could be useful. (Of course

We have code that invokes a variable number of context managers depending on runtime parameters: from contextlib import nested, contextmanager @contextmanager def my_context(arg): print("entering", arg) try: yield arg finally: print("exiting", arg) def my_fn(items): with nested(*(my_context(arg) for arg in items)) as managers: print("processing under", managers) my_fn(range(3)) However, contextlib.nested is deprecated since Python 2.7 : DeprecationWarning: With-statements now directly support multiple context managers The answers to Multiple variables in Python 'with' statement indicate that

Is this the right way to use the python "with" statement in combination with a try-except block?: try: with open("file", "r") as f: line = f.readline() except IOError: <whatever> If it is, then considering the old way of doing things: try: f = open("file", "r") line = f.readline() except IOError: <whatever> finally: f.close() Is the primary benefit of the "with" statement here that we can get rid of three lines of code? It doesn't seem that compelling to me for this use case (though I understand that the "with" statement has other uses). EDIT: Is the functionality of the above two blocks of