Python Exceptions and Error Handling

• Errors can occur during Python program execution as syntax errors, runtime errors, or logical errors.
• Exceptions are Python errors that get triggered automatically but can also be forcefully triggered/handled via code.
• This chapter focuses on exception handling in Python programs.

Syntax Errors

• Syntax errors, also called parsing errors, arise from not following programming language rules.
• If a syntax error is present, the interpreter will not execute the program until fixed.
• Python displays the error name and a description when a syntax error is encountered in shell mode.
• A dialog box specifying the error name and description appears when running a program with a syntax error in script mode.

Exceptions

• Exceptions are errors during execution, even if the syntax is correct, such as trying to open a nonexistent file or dividing by zero.
• Exceptions disrupt the normal execution and must be handled.
• An exception is a Python object representing an error, raised when an error occurs.
• Programmers should anticipate and handle potential errors to prevent abnormal program termination.
• SyntaxError is an exception, but other exceptions arise when a program's syntax is correct.

Built-in Exceptions

• Commonly occurring exceptions are defined in the compiler/interpreter as built-in exceptions.
• Python's standard library includes built-in exceptions with standardized solutions for common errors.
• When a built-in exception occurs, the appropriate exception handler code executes, displaying the reason and exception name.
• The programmer must then take action to handle the exception.

Common Built-in Exceptions

• SyntaxError: Raised when Python code has a syntax error.
• ValueError: Raised when a function receives the correct data type but an inappropriate value.
• IOError: Raised when a file cannot be opened.
• KeyboardInterrupt: Raised when the user interrupts program execution.
• ImportError: Raised when a requested module is not found.
• EOFError: Raised when the end of file is reached without reading any data.
• ZeroDivisionError: Raised when dividing by zero.
• IndexError: Raised when a sequence index is out of range.
• NameError: Raised when a variable is not defined.
• IndentationError: Raised when indentation is incorrect.
• TypeError: Raised when an operator receives an incorrect data type.
• OverFlowError: Raised when a calculation exceeds the numeric data type limit.
• A programmer can create custom exceptions to suit specific needs, known as user-defined exceptions.

Raising Exceptions

• The Python interpreter raises an exception each time an error is detected in a program.
• Exception handlers are designed to execute when a specific exception is raised.
• Programmers can forcefully raise exceptions using raise and assert statements.
• Raising an exception interrupts normal execution and jumps to the exception handler code.

The raise Statement

• The raise statement throws an exception.
• Syntax is raise exception-name[(optional argument)].
• The argument is a string displayed when the exception is raised.

The assert Statement

• The assert statement tests an expression and raises an exception if false.
• It is used at the beginning of functions to check for valid input.
• Syntax is assert Expression[,arguments].
• If the expression is false, an AssertionError is raised.

Handling Exceptions

• Exception handling prevents programs from crashing by writing code to give messages or instructions when an exception occurs.
• Exception handling is used in other programming languages to capture runtime errors.

Need for Exception Handling

• Python categorizes exceptions into distinct types for creating specific handlers.
• Exception handlers separate the main program logic from error detection and correction.
• Code with potential errors is placed in one block, and the code for when an exception occurs is placed in another.
• The compiler or interpreter tracks the exact error position.
• Exception handling works for both user-defined and built-in exceptions.

Process of Handling Exceptions

• Upon an error, Python creates an exception object with information like type, filename, and position.
• The exception object is handed to the runtime system to find appropriate handling code.
• Creating/handing over the exception object is called "throwing an exception".
• When an exception occurs, control jumps to an exception handler, abandoning remaining statements.
• The runtime looks for an exception handler, first in the method where the error occurred, then in the calling method, in reverse order until a suitable handler is found in the call stack.
• Executing a suitable handler is known as "catching the exception".
• If no handler is found, the program stops.

Catching Exceptions

• An exception is "caught" when code designed to handle it executes.
• Exceptions are caught in the try block and handled in the except block.
• Every try block is followed by an except block with code to handle possible exceptions.
• If an exception occurs, the try block stops, and control goes to the except block.

Using try and except Blocks

• A try block contains suspicious code where an exception might occur.
• An except block contains code to handle a specific exception.
• If an exception occurs in the try block, execution stops, and control transfers to the except block.
• The program continues normally if no exception occurs in the try block.
• Multiple except blocks can handle different exception types for a single try block.

Using except Without Specifying an Exception

• An except clause without a specified exception can handle any unhandled exception.
• This except clause should be the last in the try...except block.

Using try...except...else

• An optional else clause can be used with try...except.
• The else block executes only if no exception is raised in the try block.

Finally Clause

• The try statement has an optional finally clause.
• Statements in the finally block always execute, regardless of exceptions.
• finally clauses are used to ensure that file objects are closed.
• finally should be at the end of the try clause, after all except blocks and the else block (if used).

Recovering and Continuing with the finally clause

• If an error is detected in the try block, and an exception has been thrown, the appropriate except block will be executed to handle the error.
• If the exception is not handled by any of the except clauses, then it is re-raised after the execution of the finally block.
• After the finally block, Python transfers control to a previously entered try or to the next higher-level default exception handler.
• Unlike except, execution of the finally clause does not terminate the exception. Rather, the exception continues to be raised after execution of finally.
• Code with potential errors goes inside a try block.
• Handler codes go inside each except clause to handle matching exceptions raised in the try block.
• The optional else clause contains codes to be executed if no exception occurs.
• The optional finally block contains codes that are executed irrespective of whether an exception occurs or not.

Key Points

• Syntax errors/parsing errors: detected when programming language rules are not followed.
• Exceptions: Python objects that represents an error.
• Exceptions need to be handled so the program does not terminate abruptly.
• When an exception occurs and a built-in exception is defined, the corresponding error message is displayed
• Common built-in exceptions: SyntaxError, ValueError, IOError, KeyboardInterrupt, ImportError, EOFError, ZeroDivisionError, IndexError, NameError, IndentationError, TypeError, and OverFlowerror.
• Python interpreter raises/throws an exception when an error is encountered.
• Exception Handlers: codes designed to execute when a specific exception is raised
• Raising an exception: interrupts normal program flow and jumps to the exception handler
• Raise and assert statements are used to raise exceptions.
• Exception handling: involves additional code to give messages/instructions to the user, preventing crashes.
• An exception is "caught" when code designed to handle it executes.
• Exceptions: caught in the try block and handled in the except block.
• Finally block statements are always executed, regardless of exceptions.