Python exceptions

If an operation cannot be completed due to an error, the program must:

• return to a stable state and allow other operations

• try to save your work and finish

This task is difficult because usually the code that detects the error is not the one that can perform such tasks this is why you should inform that you can handle it

The most common solution are the error codes

Python offers another way to deal with errors under exceptional conditions: the exceptions

An exceptional condition is one that prevents the continuation of an operation

It's not known how to handle it, but you can't continue

In Python, an exception is thrown for someone who knows how to handle it to handle it in a higher context

f = open('readme.txt') #the file readme.txt does not exist in the system, it will throw an exception of type FileNotFoundError
text = f.readlines()
f.close()

In the example the open function checks whether the file readme.txt existed in the system and if it doesn't exist the exception is thrown FileNotFoundError who is untreated at the moment

When the interpreter detects the throw of the exception, the current method ends and launches an object that provides information about the error that occurred

Normally each type of error will be handled individually

Handling of the exceptions

Once detected the error makes it necessary to indicate who is in charge of treating it

An exception handler has the following format:

try:
    operations that can raise exceptions
except:
    exception treatment
[else:
    operations executed when an exception has not been generated]
[finally:
    common operations executed whether or not exceptions occur]

try block

The block try delimits the group of operations that may produce exceptions

except block

The block except it is the place to which control is passed if any of the operations throws an exception

try:
    f = open('readme.txt') #the file readme.txt does not exist in the system, it will throw an exception of type FileNotFoundError
    text = f.readlines()
    f.close()
except:
    print("I/O error") #will show I/O error when exception occurs

The example used a block try with his block except to handle the errors in the previous example

If any of the operations in the block throw an exception, the block is interrupted try and runs the except

At the end of this, it is normally continued

If no exception is thrown, the block except is ignored

Multiple exceptions

There is also the possibility to use an exception name to handle specific errors

Some of which are already recognized by the system, such as the exception FileNotFoundError, which is launched when a file does not exist in the system

try:
    f = open('readme.txt') #the file readme.txt does not exist in the system, it will throw an exception of type FileNotFoundError
    text = f.readlines()
    f.close()
except FileNotFoundError as e:
    print("I/O error", type(e).__name__ ) #will show I/O Error FileNotFoundError, when FileNotFoundError exception occurs
except EOFError as e:
    print("End Of File error", type(e).__name__ ) #will show End Of File error EOFError, when the EOFError exception occurs

The example used a block try with several blocks except to handle several exceptions

A block try can have several except associated

We've added the sentence as to the block except after naming it to make it the object of exception we've called and

As you can see, after turning it into an object, we can use it as if it were a class

When an exception does not correspond to any catch spreads backwards in the sequence of invocations until a catch adequate

def f1(action):
    try:
        if action == 1:
            raise FileNotFoundError
        elif action == 2:
            raise EOFError
    except FileNotFoundError as e:
        print("I/O error", type(e).__name__ ) #will show I/O Error FileNotFoundError, when FileNotFoundError exception occurs
    except EOFError as e:
        print("End Of File error", type(e).__name__ ) #will show End Of File error EOFError, when the EOFError exception occurs
    
def f2(value):
    try:
        f1(value)
    except EOFError as e:
        print("Error corrected f2") #will show Error corrected f2, when the EOFError exception occurs
    else:
        print("Normal completion f2") #mostrará Normal completion f2, when there have been no mistakes

#simulation of errors
f2(1)
#show
#I/O Error FileNotFoundError
#Normal completion f2
f2(2)
#show
#End Of File error EOFError
#Normal completion f2

In the example is managed the exceptions of the methods f1 and f2 and if you don't find any, it continues the execution of the code in the normal way outside of the block try

The sentence has been used raise followed by the name of the type of exception to propagate it and treat it elsewhere

In this case we have treated it within the f1 function itself in its exception blocks

Although spreading it could have been treated outside of it elsewhere in the script

A block has also been used else that allows the code to continue execution in case there are no exceptions before continuing outside the block try

else block

Allows code execution to continue in case there are no exceptions before continuing outside the block try

The block else can be used to exit a loop if the statement is added at the end of a loop break

It is optional and if it is not used, it will continue the execution of the code in the block finally and finally outside the block try

while(True):
    try:
        n = float( input("Enter a number: ") )
        m = 4
        print("{}/{} = {}".format(n, m, n / m) )
    except:
        print("An error has occurred, enter the number correctly")
    else:
        print("Everything has worked correctly")
        break  #Important to break the iteration if everything went well

Finally block

There may be occasions in which you want to perform some operation if exceptions occur as if not

Such operations can be placed within a block finally

If there is no exception, the block will be executed try, then the block else and finally the finally

Like the block else, is optional and if it is not used, it will continue to execute the code outside the block try

try:
    f = open('readme.txt') #the file readme.txt does not exist in the system, it will throw an exception of type FileNotFoundError
    texto = f.readlines()
except FileNotFoundError as e:
    print("I/O error", type(e).__name__ ) #will show I/O Error FileNotFoundError, when FileNotFoundError exception occurs
except EOFError as e:
    print("End Of File error", type(e).__name__ ) #will show End Of File error EOFError, when the EOFError exception occurs
    finally:
        try:
            f.close() #the file is closed regardless of whether there have been exceptions or not
        except IOError as e:
            print("I/O error", type(e).__name__ ) #will show I/O Error FileNotFoundError, when it occurs you cannot close the file

Rules of use

1. Standard

   • If an exception can be handle should not be spread

   • It is more convenient to use methods that do not produce errors

2. Standard

   • Do not use exceptions to avoid a query

     • Not to abuse them

       class Heap:
           def pop():
               raise EmptyStackError

3. Standard

   • To separate the error handling logic

     All together
     cad = "test" for c in cad: try: obj1.mesg1() except NameError as a: Treatment of a try: obj2.mesg2() except NameError as b: Treatment of b

     Separate
     cad = "test" try: for c in cad: obj1.mesg1() obj2.mesg2() except NameError as a: Treatment of a except NameError as b: Treatment of b

4. Standard

   • Do not ignore an exception already that we leave the code with errors without control

     try:
        operations
     except EmptyStackError:
         pass #For the interpreter to shut up