Translate in Your language

Thursday, 9 April 2020

Learning Python Part-25: Error and Exceptions

When writing a program, most of the times we will encounter errors. There are various possible reasons for which errors are generated. 

There are  two distinguishable types of errors: syntax errors and exceptions.

Syntax Erros:

  • Not following the proper syntax of the programming language will generate a syntax error. It is also known as parsing error.
  • Example:
if a < 5
    print(a)

  • In above example, colon ":"  is missing in the if statement after 5.

Exceptions:

  • Even after following  correct syntax of statements or expressions, it may cause an error when executing the program. 
  • Errors detected during execution are called exceptions
  • For example, Exception occurs when a file we try to open does not exist will raise FileNotFoundError or dividing a number by zero will raise ZeroDivisionError and so on.
Example 1:

10 / 0    # running this code will raise below exception.

Traceback (most recent call last):
         File "/Users/eddydesh/PycharmProjects/website/main.py", line 1, in <module>
              10/0
ZeroDivisionError: division by zero


Example2:

open("testfile.txt")      # Trying to open non existing file

Traceback (most recent call last):
      File "/Users/eddydesh/PycharmProjects/website/main.py", line 1, in <module>
           open("testfile.txt")
FileNotFoundError: [Errno 2] No such file or directory: 'testfile.txt' 
  • Whenever these type of runtime error occur, Python creates an exception object. And if it is not handled properly, it prints a traceback to error along with details of why error occurred and program is halted.
Python Built-in Exceptions:
  • There are plenty of built-in exceptions in Python that are raised when corresponding errors occur. 
  • We can view all the built-in exceptions using the local() built-in functions as follows.
>>> locals()

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x101e16fd0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/eddydesh/PycharmProjects/website/main.py', '__cached__': None, 'a': {...}}
  • local() returns a dictionary of built-in exceptions, functions and attributes.
  • For getting below list, use 
print(dir(locals()['__builtins__']))


Python Exception Handling:
  • Python built-in exceptions forces program to output an error when something goes wrong in program. 
  • When exceptions occur, it causes the current process to halt and passes it to the calling process until it is handled.  If not handled, program will crash.
  • For example, if function A calls function B which in turn calls function C and an exception occurs in function C. If it is not handled in C, the exception passes to B and then to A.
  • If not handled at any level, an error message generated and program comes to an unexpected halt.
Catching Exceptions in Python:
  • It is very much possible to write programs that handle selected exceptions. 
  • In Python, exceptions can be handled using a try statement.
  • A critical operation which can raise exception is placed inside the try clause and the code that handles exception is written in except clause.
  • It is up to programmer, what operations will be performed once exception is caught. 
  • Example:
while True:
           try: 
                x = int(input("Please enter a number: "))
                print(x, " is an integer")
                break 
           except: 
                print("Invalid inout. Try again...")


Catching Specific Exceptions in Python:

  • In previous example, we did not mention any exception in the except clause, which is not a ideal programming practice as it will catch all exceptions and handle every case in the same way. 
  • We can specify which exceptions an except clause will catch.
  • A try clause can have any number of except clause to handle them differently but only one will be executed in case an exception occurs.
  • We can use a tuple of values to specify multiple exceptions in an except clause. 
  • Example:
while True:
          try:
                 x = int(input("Please enter first number: "))
                 y = int(input("Please enter second number: "))
                 print("Division is: ", x/y)
                 break
          except ValueError:
                 print("Invalid inout. Try again...")
          except ZeroDivisionError:
                 print("Its a zero division error. Cannot devide by 0. Try again")

try...finally:
  • The try statement in Python can have an optional finally clause. 
  • This clause is executed no matter what, and is generally used to release external resources.
  • For example one use case can be, we may be working with a file and once we are done writing changes, we want to close the file
  • In these kind of operations, we must release resources once used, regardless of operation was successful or not. 
  • These sort of actions are performed in the finally clause for guaranteed execution.
  • Example of file operations.
try:
    f = open("test_file.txt", encoding = 'utf-8’)
    # perform file operations
finally:
    f.close()

  • This makes sure the file is closed even if an exception occurs.
Python Custom(User Defined) Exceptions:
  • Python has many built-in exceptions which forces program to output an error.
  • However, at times we may need to create custom exceptions that serves specific purpose.
  • In Python, users can define such exceptions by creating a new class. 
  • This exception class has to be derived, either directly or indirectly, from Exception class. 
  • Most of the built-in exceptions are also derived form this class.
Example:

class CustomError(Exception):
         pass
raise CustomError
raise CustomError("An error occurred") 

# Output of first raise:
Traceback (most recent call last):
__main__.CustomError

# Output of second raise:
Traceback (most recent call last):
__main__.CustomError: An error occurred

  • Here, we have created a user-defined exception called CustomError which is derived from the Exception class. 
  • This new exception can be raised, like any other exceptions, using the raise statement with an error message(optional).
  • When developing a large Python program, best practice would be to place all the user-defined exceptions in a separate file(Module) something like exceptions.py. Later it can be imported to program.
Raising Exceptions:
  • Until now we discussed about catching the exceptions. However, we may want to raise error intentionally when required.
  • We can also optionally pass in value to the exception to clarify why that exception was raised.
a = 'python'

if not type(a) is int:
      raise TypeError("Enter integers only")


No comments:

Post a comment

Followers

Popular Posts This Week