Question

List five common examples of exceptions.

Short answer

Examples of common exceptions include ZeroDivisionError, FileNotFoundError, IndexError, KeyError, and TypeError.

Step-by-step solution

Introduction to Exceptions

Exceptions are unexpected events or errors that occur during the execution of a program. Handling these exceptions gracefully ensures that the program can continue to run or terminate cleanly.

Example 1: ZeroDivisionError

This exception is raised when a division or modulo operation is attempted with zero as the divisor. For instance, attempting to execute this line of Python code, `10/0`, will result in a `ZeroDivisionError`.

Example 2: FileNotFoundError

This exception occurs when a file operation, such as reading or writing, is performed on a file that does not exist. For example, trying to open a non-existent file with open('nonexistent.txt', 'r') in Python will raise a `FileNotFoundError`.

Example 3: IndexError

An `IndexError` is raised when trying to access an element from a list using an index that is out of the range of the list. For example, attempting to access the 5th element in a 3-element list like `[1, 2, 3][4]` will trigger this exception.

Example 4: KeyError

This exception is raised when a dictionary is accessed with a key that does not exist. For example, if we have a dictionary `{'a': 1}` and we try to access `dict['b']`, it will result in a `KeyError`.

Example 5: TypeError

A `TypeError` occurs when an operation or function is applied to an object of inappropriate type. For example, adding a string to an integer using `1 + 'a'` in Python would raise this exception.

Key concepts

ZeroDivisionError

When working with numerical operations, you might encounter a `ZeroDivisionError`. This occurs when you try to divide a number by zero, which mathematically is undefined. In Python, this would look like `a / 0` or `b % 0`, where `a` and `b` are any numbers.
To handle this error gracefully, you can use a try-except block. Here's a simple example: ```python try: result = 10 / 0 except ZeroDivisionError: print("Cannot divide by zero!") ``` Using this pattern, the program continues to run smoothly without crashing, and you can inform the user about the mistake.

FileNotFoundError

Opening or reading from a file that does not exist leads to a `FileNotFoundError`. Imagine yourself trying to access a book in a library that hasn't been stocked yet—that's precisely what happens in programming when you attempt to open files that are missing.
To gracefully manage this situation, wrap your file operations in a try-except block like this: ```python try: with open('missingfile.txt', 'r') as file: data = file.read() except FileNotFoundError: print("The file you are trying to access does not exist.") ``` Using this method avoids abrupt halts in your program and lets you provide feedback or attempt alternative actions.

IndexError

An `IndexError` happens when you try to access a position in a list or array that doesn't exist. For example, if you have a list with three items and you try to access the fourth item, Python will raise this error.
Here's how you could safely handle such a situation: ```python my_list = [1, 2, 3] try: item = my_list[4] # Intentional error except IndexError: print("Index out of range. Try a smaller index.") ``` With index errors, it is helpful to first verify the length of the list using `len()` to ensure you're working within its bounds.

KeyError

A `KeyError` occurs in Python when you try to access a dictionary's value using a key that isn't present in the dictionary. This is analogous to trying to look up a word in a dictionary page that is missing.
Utilize try-except blocks to catch this exception: ```python my_dict = {'a': 1, 'b': 2} try: value = my_dict['c'] # Key 'c' does not exist except KeyError: print("Key not found!") ``` To pre-emptively avoid `KeyError`, you can use the `get()` method of dictionaries, which returns `None` or a default value if the key is absent.

TypeError

`TypeError` arises when an operation uses an inappropriate data type. For example, adding a string and an integer is nonsensical, and Python will raise this error.
Consider this example where you might incorrectly combine types: ```python try: result = 5 + 'hello' except TypeError: print("Cannot add an integer to a string.") ``` To prevent such errors, ensure operations are performed on compatible types and convert types when necessary using functions like `int()`, `str()`, or `float()`. Always know the type of data you are working with to make sure they fit the operation you are performing.