{"id":17911,"date":"2017-07-19T16:15:14","date_gmt":"2017-07-19T13:15:14","guid":{"rendered":"http:\/\/www.webcodegeeks.com\/?p=17911"},"modified":"2018-01-09T09:35:10","modified_gmt":"2018-01-09T07:35:10","slug":"python-exception-handling","status":"publish","type":"post","link":"https:\/\/www.webcodegeeks.com\/python\/python-exception-handling\/","title":{"rendered":"Python Try and Except Example"},"content":{"rendered":"

Today we will talk about one of the most important things in Python – exception handling. Firstly, let’s start with the definition of exceptions. They are errors detected while the program is being executed. So for example, if you write the program and you think it’s alright and try running it, it may give you some errors.
\n 
\n 
\n 
\n 
\n 
\n 
\n 
\n[ulp id=’R7QVpFMZmjosABLC’]<\/p>\n

1. Basic exceptions<\/h2>\n

Let’s start with some basic exceptions.
\n 
\nPython Shell<\/em><\/span><\/p>\n

\r\n>>> 1\/0\r\nTraceback (most recent call last):\r\n  File \"\", line 1, in \r\nZeroDivisionError: division by zero\r\n<\/pre>\n
So this program gives us the first error, because we can’t divide the number by zero. Let’s try another one.
\n 
\nPython Shell<\/em><\/span><\/p>\n
\r\n>>> \"string\" + 5\r\nTraceback (most recent call last):\r\n  File \"\", line 1, in \r\nTypeError: must be str, not int\r\n<\/pre>\n
So we can’t concatenate the string with the integer number. When the program “crashes”, it means it finished execution with the result of error. <\/p>\n
2. Exception handling<\/h2>\n
Now we are familiar with some of the errors that we may encounter while writing a program. Let’s try to handle those errors. We will create the basic program the takes two numbers and returns the result of its division.
\n 
\nPython<\/em><\/span><\/p>\n
\r\nfirst = input()\r\nsecond = input()\r\nresult = first\/second\r\nprint(result)\r\n<\/pre>\n
What happens when we execute the program? Try it for yourself! You will get a TypeError<\/code>. The reason is simple: when we use input()<\/code> method, we put the data in variables as string<\/code>, not as an integer<\/code> which we need. So how can we solve it? There are actually two ways to solve it: we may convert them to int<\/code> while asking a user for input, or we can convert them while dividing. I will show both ways.
\n 
\nPython<\/em><\/span><\/p>\n
\r\nfirst = int(input())\r\nsecond = int(input())\r\nresult = first\/second\r\nprint(result)\r\n<\/pre>\n
This one is preferrable if you know that you will be working with integers only. Another way is following:
\n 
\nPython<\/em><\/span><\/p>\n
\r\nfirst = input()\r\nsecond = input()\r\nresult = int(first)\/int(second)\r\nprint(result)\r\n<\/pre>\n
This one is preferrable if you know that the user may input some strings which you want to operate (but why would you need division in the first place then?). Anyway, I prefer the first method more.
\nSo what happens if second<\/code> is zero? We get ZeroDivisionError: division by zero<\/code> error. Let’s handle it using try<\/code> and except<\/code>.
\n 
\nPython<\/em><\/span><\/p>\n
\r\nfirst = input()\r\nsecond = input()\r\ntry:\r\n   result = int(first)\/int(second)\r\n   print(result)\r\nexcept Exception as e:\r\n   print(e)\r\n<\/pre>\n
What we do here is that we actually print the type of error which occurs while executing. So if we try to divide by zero, we get division by zero<\/code>. We didn’t get any red lines, the program didn’t crash, so we handled the error successfully!
\nYou may ask, “Hey, we only handle one error! What about the rest?”. I am glad that you asked (if you didn’t, don’t worry. I am glad that you are reading this article now anyway). So what happens if we enter strings, not integers? The program crashes, right? Let’ handle it.<\/p>\n
Firstly, let’s think what we need to do. We ask a user for input and convert it to integer right away. Then, depending on the type of variables we do the following: if both are integer, we do calculate the division and handle DivisionByZero<\/code> exception as well, if at least one of the variables isn’t an integer, we show the user a warning message, and the program finishes. So what I want to do is to actually build a function that will do handling division error and division itself. Let’s call it division<\/code>. Then let’s call it only if both variables are integers.
\n 
\nPython<\/em><\/span><\/p>\n
\r\n#division function\r\ndef division():\r\n   try:\r\n      result = first \/ second\r\n      print(result)\r\n   except Exception as e:\r\n      print(e)\r\n#it's important to have division function before the code below\r\ntry:\r\n   first = int(input())\r\n   second = int(input())\r\n   division()\r\nexcept Exception as e:\r\n   print(\"You can't put anything but integer numbers\")\r\n<\/pre>\n
That’s about it. Let’s advance this program into one more step, shall we? What if we want to run the program until it actually gives us the result. What I mean is that right now the program stops while we put something but integer number. We want from a user to eventually put appropriate numbers, so the program will give us some result. The logic is quite similar (even though there are easier ways to do this, but this one seems pretty easy to follow). Let’s create the function calculation()<\/code> which will be the main one. We will still have the function division()<\/code>.
\n 
\ncalculation.py<\/em><\/span><\/p>\n
\r\ndef division(first, second):\r\n    try:\r\n        result = first \/ second\r\n        print(result)\r\n    except Exception as e:\r\n        print(e)\r\n\r\ndef calculation():\r\n    try:\r\n        first = int(input())\r\n        second = int(input())\r\n        division(first, second)\r\n    except Exception as e:\r\n        print(\"You can't put anything but integer numbers\")\r\n        calculation()\r\ncalculation()\r\n<\/pre>\n
So now, try running it, and you will be able to get the result eventually.<\/p>\n
3. Raising exceptions<\/h2>\n
 Sometimes we would need to raise exceptions to debug our code. Usually, when you create your own exception, the best way is to create the class. Let’s do it:
\n 
\nraise.py<\/em><\/span><\/p>\n
\r\nclass Accident(Exception):\r\n    def __init__(self, message):\r\n        self.message = message\r\n    def print_exception(self):\r\n        print(\"Our custom exception is...\", self.message)\r\n\r\ntry:\r\n    raise Accident(\"here\")\r\nexcept Accident as a:\r\n    a.print_exception()\r\n<\/pre>\n
So this is how we raise the exception: we create the class where we initialize the statement which will be printed, once the exception is raised. So our code raises an exception.<\/p>\n
4. Finally statement <\/h2>\n
Finally statement is used to do the clean-up. For example, the code with finally<\/code> statement will run no matter what.
\n 
\nfinally.py<\/em><\/span><\/p>\n
\r\ndictionary = {\"a\":0, \"b\":1, \"c\":2}\r\ntry:\r\n   value = dictionary[input()]\r\nexcept KeyError:\r\n    print(\"An error has occured!\")\r\nelse:\r\n    print(\"Everything's fine\")\r\nfinally:\r\n    print(\"It's finally over!\")\r\n<\/pre>\n
So a user puts a Key<\/code> that will look for a matching key in the dictionary. If there is no match, it prints \"An error has occured!\"<\/code>. If there is a match, it prints \"Everything's fine\"<\/code>. It prints \"It's finally over!\"<\/code> no matter what.<\/p>\n
5. Summary<\/h2>\n
So handling exceptions is a very important tool that is executed while debugging your program. You should definitely learn how to handle exceptions. Let’s sum up what we need to know:<\/p>\n