There is a usual pattern when programming that is opening a resource,doing something with it and closing it. This is what you normally dowith a file, a network connection or a device. Python uses you acommand to take care of this pattern: the \"with\" context manager. In thisarticle, we are going to see just how you can construct classes the follow thesame pattern.

You are watching: Attributeerror: __exit__

Quick arrival to the with Command

If girlfriend would favor to write a string come a file, you deserve to do the following:

f = open(\"My_File.txt\", \"w\")f.write(\"This goes to the file\\n\")f.close()The lines over will develop an empty paper every time you operation them andwill write a line to it. Once the regime is done, it closes the file.If you would eliminate the critical line, f.close, the program would haveworked in the very same way. However, errors occasionally arise and also you wouldlike to be sure that the record was closed and the data was saved. Thelines above can be replaced by the following:

with open(\"My_File.txt\", \"w\") as f: f.write(\"This is within a paper definition manager\\n\")The benefit of making use of the with command is not just that you type oneline less to type, but it is likewise that if miscellaneous would take place whenyou try to write, the document will be safely closed and the data will certainly bewritten. The advantages may no be obvious for an easy examples, butlong-running programs in which a most data is created will start toshow concerns if documents are not closed correctly. Also, when you useresources other than files, such as network relationships or hardwaredevices, friend will also see that appropriately closing the sources isfundamental.

In practice, you can additionally think about the v command as doing thefollowing:

f = open(\"my_file.txt\", \"w\")try: f.write(\"This is the very first line\\n\")except exemption as e: passf.close()raise eYou can shot to watch what happens if girlfriend raise an exception after thewrite command. The data will be in your document and the record would havebeen appropriately closed.

Custom Classes and With

Working with files and other sources is interesting, yet moreinteresting would certainly be to build classes that have the right to be provided within acontext manager. First, we need to know the actions that form thecreation of a class. First, let\"s start with the brute pressure approach,and we develop a an easy class:

class SimpleClass: def simple_method(self): print(\"Simple Method\") def finalize(self): print(\"Finalizing the Class\")That we can simply use like this:

sc = SimpleClass()sc.simple_method()# basic Methodsc.finalize(self)# Finalizing the ClassThis is not an extremely enthusiastic, but it is a beginning point. Let\"s shot touse a context manager v our class:

with SimpleClass() as sc: sc.simple_method()We will confront an issue, the error that appears on the screen should be:

AttributeError: __enter__This basically way that the brute force technique doesn\"t work-related withcontext managers, we must work a bit more. Without going too much incircles, the with needs two techniques of the so-called magic type:__enter__ and also __exit__ that will be operation at the beginning and at theend the the code block.

It is crucial to note that whatever is reverted by __enter__ will belinked come the target that with, i.e. Everything variable we placed afteras. In the simplest of the possibilities, __enter__ return theclass itself, choose this:

class SimpleClass: def __enter__(self): return selfWe additionally need to include an __exit__ method, i m sorry takes number of arguments,not just self:

def __exit__(self, exc_type, exc_val, exc_tb):What you have to remember is that with takes treatment of capturing anyexceptions that might arise and also all the information is passed to the exitmethod so you deserve to decide what to carry out with them. Best now, the just thingwe want to perform is to contact the finalize method. The complete code wouldlook choose this:

class SimpleClass: def simple_method(self): print(\"Simple Method\") def finalize(self): print(\"Finalizing the Class\") def __exit__(self, exc_type, exc_val, exc_tb): self.finalize() def __enter__(self): return selfAnd you can use it choose this:

with SimpleClass() together sc: sc.simple_method()Which will create the adhering to output:

Simple MethodFinalizing the ClassThis is precisely what us were expecting. You can go on and shot togenerate some exception in your code and also see exactly how the regimen handles it.You can also print the arguments passed in bespeak to recognize what youcan perform with them. Because that example, you deserve to do the complying with in the exitmethod:

def __exit__(self, exc_type, exc_val, exc_tb): self.finalize() print(exc_type) print(exc_val) print(exc_tb)And then readjust the code you usage to run it:

with SimpleClass() together sc: sc.simple_method() raise Exception(\"This is an Exception\")Which will generate the adhering to output:

This is one ExceptionThis is enough to make decisions based on the kind of details that the exception is providing. You can inspect the previous write-up on exception to have actually an idea the the sort of things you deserve to accomplish.

With and also Constructors

In the straightforward class the we have actually seen earlier, we fully skipped thediscussion that what happens as soon as you have actually a constructor, i.e. The__init__ an approach is defined. For this reason let\"s quickly shot it. Let\"s do theSimpleClass print at every step:

class SimpleClass: def __init__(self): print(\"Init\") def simple_method(self): print(\"Simple Method\") def finalize(self): print(\"Finalizing the Class\") def __exit__(self, exc_type, exc_val, exc_tb): print(\"Exit\") self.finalize() def __enter__(self): print(\"enter\") return selfIf you run it with the very same code 보다 before, the calculation that girlfriend wouldget is:

InitenterSimple MethodExitFinalizing the ClassSo, now you can see that first, friend instantiate the course (the__init__ an approach is triggered) and only climate the __enter__ isexecuted. This experimenting method is very useful since you canalready discover a lot of without having to find online and go throughendless tutorials.

Another crucial thing to keep in mind is the after the with block, theclass is tho available:

with SimpleClass() together sc: sc.simple_method() # raise Exception(\"This is one Exception\")sc.simple_method()The command only takes care of executing the exit method but walk notforce any garbage collection. This way that the thing is stillavailable ~ the through block. You deserve to test that with records or serialcommunication and also you will an alert that if you try to use the exact same filehandler it gives you one error:

ValueError: I/O operation on closed file.This method that the document handler is tho available, however the resourcewas already closed.

Why go to the Trouble

When we talk about this kind of topics, you constantly have to take into consideration the twosides the a project. You room either making use of someone\"s code or girlfriend aredeveloping password someone else will expand. In the first case, using acontext manager ensures that you monitor the pattern the the originaldeveloper intended. All the work for exemption handling, resourcefreeing, etc. Was already taken care of and also all it takes friend is one lineof code. Therefore, if you room a user, the with deserve to save you a lotof headaches and can speed your development.

If you are a developer, implementing two extra techniques doesn\"t takethat lengthy and enables the user to employ a typical syntax. If you laterimprove your password adding far better error handling, resourcesadministration, etc. The customers of your password will get thoseimprovements automatically, without changing a single line of theircode.

Does every course need to support the with? Let\"s be realistic.Very few of the work your routine performs require access toresources that must be closed. Network communication, machine control,writing to documents are part examples and probably you won\"t encounter manymore. If you room a developer, you have actually to consider whether implementingthe possibility of making use of context managers helps future individuals of yourcode.


The problem of concentrating on very basic examples is that it provides it veryhard to realize the true strength of various patterns and why is the worthgoing v the trouble of implementing new methods, etc. The truth isthat until you have a huge and complex project in your hands, friend won\"treally realize it.

The power of the paper definition manager becomes obvious when your password is usedby various other people and also your class has a clear cycle that opening and closingresources, such as would certainly be the case of working through a file, a networkconnection or a machine in the lab. The main benefit comes indigenous thefact the you deserve to implement complex ways the closing and also handlingexceptions yet at the same time, you provide the user a the majority of freedomabout what come do.

In the example above, the just thing that needs to be excellent is callingthe finalize method, however we can make the exit much more sophisticatedin order to execute some verifications, exemption handling, etc.However, if the user would prefer to have finer control, she deserve to still usethe straight methods.

See more: Resolved: Killing Floor 2 Won T Launch Ing, Resolved: Killing Floor 2 Not Launching

Implementing two techniques in order to permit the user to usage the withand ensure the closing techniques are executed, ns believe, offsets thework that implementing them. If you want to watch a real-world example, youcan check howpyserialhas enforced the __enter__ and also __exit__ methods.