Python Exception Handling

Exception Handling in Python

• Exception handling manages errors that may occur during a program's execution, preventing abnormal termination.

Introduction

• A Python program may not execute fully or produce unexpected output due to various errors.
• Exceptions are errors that trigger automatically but can be forcefully triggered and handled with code.

Syntax Errors

• These are detected when the rules of a programming language are not followed.
• They are also known as parsing errors.
• The interpreter doesn't execute the program until syntax errors are fixed.
• When encountered in shell mode, Python displays the error name and a description.
• Similarly, in script mode, a dialog box shows the error name and description.

Exceptions

• An exception can arise even if a statement is syntactically correct, such as trying to open a non-existent file or dividing by zero.
• Exceptions are Python objects representing errors.
• When an error occurs, an exception is said to be "raised".
• Programmers need to handle exceptions to prevent program termination.
• Programmers anticipate situations with errors and include appropiate code to handle code.
• Although SyntaxError is also an exception, other exceptions generate when a program is syntactically correct.

Built-in Exceptions

• Commonly occurring exceptions defined in the compiler/interpreter.
• Python's standard library has a wide range of built-in exceptions for common errors, providing solutions like raising exceptions when
  • There is an error in python code (SyntaxError)
  • A built-in method received an argument of the right data type, but the value was mismatched (ValueError)
  • A file the program stated cannot be opened (IOError)
  • The user hits the delete key to interrupt the program (KeyboardInterupt)
  • A module cannot be found (ImportError)
  • The end of file is reached without reading the data (EOFError)
  • When a math operation divides by zero (ZeroDivisionError)
  • The index or substring is outside the sequence (IndexError)
  • Global / Local variable is not defined (NameError)
  • There is incorrect indentation in the code (IndentationError)
  • An operator is supplied with a value of incorrect data type (TypeError)
  • A calculation exceeds the limit for number data type (OverflowError)

Raising Exceptions

• Python interpreter raises an exception each time an error is detected (throws)
• Handlers execute when a specific exception is raised.
• Programmers can use raise and assert statements to forcefully raise an exception.
• When raised, no code in the block executes.
• Raising an exception means interrupting the programs normal flow, and jumping to the exception handler code written to handle situations.

The "raise" Statement

• The "raise" statement is to throw an exception.
• The syntax is:
  • raise exception-name[(optional argument)]
• The argument displays when an exception is raised.
• It can detect built-in, and user-defined errors
• E.g when "length" is greater than the numbers in a list, this will throw an exception

The "assert" Statement

• The "assert" expression tests an expression in a program.
• If the result is false, the exception is raised.
• This is in general used at the beginning of the function, or after the function calls to check for a vale input.
• The syntax is:
  • assert Expression[, arguments]

Handling Exceptions

• Each error must be handled by the programmer, to avoid crashing the program.
• The exception Handling process has these points
  • Python categorizes exceptions so specific exception handlers can be created
  • Exception handlers separate the logic of the segments, and statements for detection
    • The compiler / interpreter track the error

Process of Handling

• When and error occurs, the interpreter creates an exception object.
• The object contains information about the type, name, and code where the error occurred
• This throws the object to the runtime system
• The process searches for the method, in which the error has occurred. If not found, the process searches the method from which this method was called.
• If a suitable handler is found, this catching process executes the runtime process

Catching Exceptions

• When the code handles an exception, it is said to have been caught
• Exceptions are caught in the try block, and handled in the except block

Try and Except block Usage

• The try block of code that we suspect will have errors, this is followed by an except block
• The code handles the possible exception is written.
• If an exception is encountered, the try block will stop and and the control will transfer to the except block/
• The syntax is

try:
   [ code that may have exception ]
except [expception-name]:
   [ code for exception handling

• Can have multiple "except" blocks for a the try loop

Using Except Without Specifying an Exception

• With this except can handle uncaught, or new errors or undefined errors
• Syntax should be written as the last clause in try and except

"try...except...else" Clause

- Use an optional `else` clause with try...except
    - The `except` block will be executed if there is some sort exception
    - If no error, none of the `except` block executes, and the `else` clause will be executed

Finally Clause

- An optional `finally` clause will be executed
- This will ALWAYS be executed. Regardless if there is an uncaught exception or not
- Syntax, Finally will always come at the end
- Commonly used when working with files eg, to ensure the object file is closed, which finally clause does