Chapter 6 Exercises

Comprehensive exercises covering exception handling in Python, sorted from easiest to hardest.

Exercises

Exercise 1: Safe List Access

Write a function safe_get that takes a list and an index. Use try-except to handle IndexError. If the index is valid, return the element. If an IndexError occurs, return None.

Answer:

1
def safe_get(my_list, index):
2
    try:
3
        return my_list[index]
4
    except IndexError:
5
        return None

Exercise 2: Safe Dictionary Access

Write a function safe_dict_get that takes a dictionary and a key. Use try-except to handle KeyError. If the key exists, return its value. If a KeyError occurs, return the string “Key not found”.

Answer:

1
def safe_dict_get(my_dict, key):
2
    try:
3
        return my_dict[key]
4
    except KeyError:
5
        return "Key not found"

Exercise 3: Integer Conversion with Error Handling

Write a function safe_int that takes a value and tries to convert it to an integer. Handle ValueError and TypeError. If conversion succeeds, return the integer. If it fails, return None.

Answer:

1
def safe_int(value):
2
    try:
3
        return int(value)
4
    except (ValueError, TypeError):
5
        return None

Exercise 4: Division with Multiple Exception Types

Write a function divide_numbers that takes two arguments and divides the first by the second. Handle ZeroDivisionError, TypeError, and ValueError separately, each printing a specific message. Return the result if successful, None otherwise.

Answer:

1
def divide_numbers(a, b):
2
    try:
3
        return a / b
4
    except ZeroDivisionError:
5
        print("Cannot divide by zero")
6
        return None
7
    except TypeError:
8
        print("Invalid type for division")
9
        return None
10
    except ValueError:
11
        print("Invalid value for division")
12
        return None

Exercise 5: List Operations with Exception Handling

Write a function process_list that takes a list and an operation (as a string: ‘sum’, ‘max’, ‘min’, ‘average’). Use try-except to handle cases where the list is empty (raise ValueError), contains non-numeric values (handle TypeError), or the operation is invalid (raise ValueError). Return the result of the operation.

Answer:

1
def process_list(my_list, operation):
2
    try:
3
        if not my_list:
4
            raise ValueError("List is empty")
5

6
        if operation == 'sum':
7
            return sum(my_list)
8
        elif operation == 'max':
9
            return max(my_list)
10
        elif operation == 'min':
11
            return min(my_list)
12
        elif operation == 'average':
13
            return sum(my_list) / len(my_list)
14
        else:
15
            raise ValueError("Invalid operation")
16
    except ValueError as e:
17
        print(f"Error: {e}")
18
        return None
19
    except TypeError:
20
        print("Error: List contains non-numeric values")
21
        return None

Exercise 6: Nested Try-Except Blocks

Write a function nested_access that takes a nested list of lists and two indices (row, col). Use nested try-except blocks to handle IndexError at both the outer list level and inner list level. In the outer try block, access the row. In the inner try block (inside the outer try), access the column. Return the element if found, None if either index is out of range.

Answer:

1
def nested_access(matrix, row, col):
2
    try:
3
        row_list = matrix[row]  # Outer try: access row
4
        try:
5
            return row_list[col]  # Inner try: access column
6
        except IndexError:
7
            return None  # Column index out of range
8
    except IndexError:
9
        return None  # Row index out of range

Exercise 7: Exception Handling with Comprehensions

Write a function safe_divide_list that takes two lists of numbers and returns a new list where each element is the division of corresponding elements from the two lists. Use a list comprehension with a helper function that handles ZeroDivisionError and IndexError. If division by zero occurs, use None. If index is out of range, use 0.

Answer:

1
def safe_divide(a, b):
2
    try:
3
        return a / b
4
    except ZeroDivisionError:
5
        return None
6
    except IndexError:
7
        return 0
8

9
def safe_divide_list(list1, list2):
10
    def divide_at_index(i):
11
        try:
12
            return safe_divide(list1[i], list2[i])
13
        except IndexError:
14
            return 0
15

16
    return [divide_at_index(i) for i in range(max(len(list1), len(list2)))]

Exercise 8: Custom Exception for Validation

Write a function validate_age that takes an age value. Try to convert it to an integer first. If conversion fails, raise a TypeError. If the age is negative or greater than 150, raise a ValueError. Then write code that calls this function and handles both exceptions, printing appropriate messages.

Answer:

1
def validate_age(age):
2
    try:
3
        age = int(age)
4
    except (ValueError, TypeError):
5
        raise TypeError("Age must be an integer")
6
    if age < 0:
7
        raise ValueError("Age cannot be negative")
8
    if age > 150:
9
        raise ValueError("Age cannot be greater than 150")
10
    return True
11

12
try:
13
    age_input = input()
14
    validate_age(age_input)
15
    print("Valid age")
16
except TypeError as e:
17
    print(f"TypeError: {e}")
18
except ValueError as e:
19
    print(f"ValueError: {e}")

Exercise 9: Dictionary Operations with Exception Handling

Write a function dict_operations that takes a dictionary and performs multiple operations: gets a value by key, calculates the sum of all numeric values, and finds the maximum value. Use try-except blocks to handle KeyError, TypeError, and ValueError. Return a dictionary with results or error messages.

Answer:

1
def dict_operations(my_dict, key):
2
    result = {}
3

4
    # Get value by key
5
    try:
6
        result['value'] = my_dict[key]
7
    except KeyError:
8
        result['value'] = 'Key not found'
9

10
    # Calculate sum
11
    try:
12
        numeric_values = [v for v in my_dict.values() if type(v) == int or type(v) == float]
13
        if numeric_values:
14
            result['sum'] = sum(numeric_values)
15
        else:
16
            result['sum'] = 'Cannot sum non-numeric values'
17
    except (TypeError, ValueError):
18
        result['sum'] = 'Cannot sum non-numeric values'
19

20
    # Find max
21
    try:
22
        numeric_values = [v for v in my_dict.values() if type(v) == int or type(v) == float]
23
        if numeric_values:
24
            result['max'] = max(numeric_values)
25
        else:
26
            result['max'] = 'Cannot find max of non-numeric values'
27
    except (TypeError, ValueError):
28
        result['max'] = 'Cannot find max of non-numeric values'
29

30
    return result

Exercise 10: Try-Except-Else-Finally with Functions

Write a function process_data that takes a list of numbers and a divisor. Divide each number by the divisor and return a list of results. Use try-except-else-finally blocks. In the try block, perform all divisions. Handle ZeroDivisionError and TypeError by printing error messages. In the else block, print “All operations successful”. In the finally block, print “Processing complete”. Make sure the else block executes when no exceptions occur.

Answer:

1
def process_data(numbers, divisor):
2
    results = []
3
    try:
4
        for num in numbers:
5
            results.append(num / divisor)
6
    except ZeroDivisionError:
7
        print("Cannot divide by zero")
8
        results = []
9
    except TypeError:
10
        print("Invalid divisor type")
11
        results = []
12
    else:
13
        print("All operations successful")
14
    finally:
15
        print("Processing complete")
16
    return results

Exercise 11: Complex Exception Handling with Comprehensions

Write a function safe_matrix_operations that takes a matrix (list of lists) and an operation (‘sum’, ‘max’, ‘min’). Use dictionary comprehension to create a mapping of row indices to their operation results. Handle IndexError, TypeError, and ValueError. If a row is empty or contains non-numeric values, map it to None.

Answer:

1
def safe_matrix_operations(matrix, operation):
2
    def process_row(row):
3
        try:
4
            if not row:
5
                return None
6
            numeric_values = [x for x in row if type(x) == int or type(x) == float]
7
            if not numeric_values:
8
                return None
9
            if operation == 'sum':
10
                return sum(numeric_values)
11
            elif operation == 'max':
12
                return max(numeric_values)
13
            elif operation == 'min':
14
                return min(numeric_values)
15
            else:
16
                raise ValueError("Invalid operation")
17
        except (TypeError, ValueError):
18
            return None
19

20
    return {i: process_row(row) for i, row in enumerate(matrix)}

Exercise 12: Exception Handling with Lambda and Map

Write a function safe_map_divide that takes two lists and a divisor. Use map() with a lambda function to divide each element of the first list by the divisor, then divide by corresponding elements from the second list. Handle ZeroDivisionError and IndexError. Return a list where errors are represented as None.

Answer:

1
def safe_map_divide(list1, list2, divisor):
2
    def safe_divide(x, y):
3
        try:
4
            return (x / divisor) / y
5
        except (ZeroDivisionError, IndexError):
6
            return None
7

8
    return [safe_divide(list1[i], list2[i]) if i < len(list2) else None for i in range(len(list1))]

Exercise 13: Nested Exception Handling with Functions

Write a function process_nested_data that takes a nested dictionary structure. Extract values from nested dictionaries, handle KeyError at multiple levels, and calculate statistics (sum, average) of numeric values found. Use try-except blocks at different nesting levels. Return a dictionary with statistics or error messages.

Answer:

1
def process_nested_data(data):
2
    all_values = []
3
    for key, nested_dict in data.items():
4
        try:
5
            try:
6
                values = nested_dict['values']
7
                if type(values) == list:
8
                    all_values.extend([v for v in values if type(v) == int or type(v) == float])
9
            except KeyError:
10
                pass
11
        except (TypeError, AttributeError):
12
            pass
13

14
    if all_values:
15
        return {
16
            'sum': sum(all_values),
17
            'average': sum(all_values) / len(all_values),
18
            'count': len(all_values)
19
        }
20
    else:
21
        return {'sum': 0, 'average': 0, 'count': 0}

Exercise 14: Complex Exception Handling with Sorting

Write a function safe_sort_with_key that takes a list of dictionaries and a key function (as a lambda or function). Sort the list using the key function, but handle cases where the key doesn’t exist (KeyError), the value is not sortable (TypeError), or the list is empty. Return the sorted list or None if sorting fails.

Answer:

1
def safe_sort_with_key(data, key_func):
2
    try:
3
        if not data:
4
            return []
5
        return sorted(data, key=key_func)
6
    except KeyError:
7
        return None
8
    except TypeError:
9
        return None
10
    except Exception:
11
        return None

Exercise 15: Ultimate Exception Handling Challenge

Write a function complex_data_processor that takes a list of mixed data (numbers, strings, lists, dictionaries). Use comprehensions, map, filter, and exception handling to: 1) Extract all numeric values from nested structures, 2) Calculate statistics (sum, max, min, average), 3) Handle all possible exceptions (TypeError, ValueError, KeyError, IndexError, AttributeError). Return a dictionary with results or error messages for each operation.

Answer:

1
def extract_numbers(item):
2
    numbers = []
3
    try:
4
        if type(item) == int or type(item) == float:
5
            numbers.append(item)
6
        elif type(item) == list:
7
            for subitem in item:
8
                numbers.extend(extract_numbers(subitem))
9
        elif type(item) == dict:
10
            for value in item.values():
11
                numbers.extend(extract_numbers(value))
12
    except (TypeError, ValueError, KeyError, IndexError, AttributeError):
13
        pass
14
    return numbers
15

16
def complex_data_processor(data):
17
    all_numbers = []
18
    for item in data:
19
        all_numbers.extend(extract_numbers(item))
20

21
    try:
22
        if all_numbers:
23
            return {
24
                'sum': sum(all_numbers),
25
                'max': max(all_numbers),
26
                'min': min(all_numbers),
27
                'average': sum(all_numbers) / len(all_numbers)
28
            }
29
        else:
30
            return {'sum': 0, 'max': None, 'min': None, 'average': 0}
31
    except (TypeError, ValueError):
32
        return {'error': 'Cannot process data'}

Chapter 6 Exercises

Table of Contents

Table of Contents

Course Progress

Chapter 6 Exercises

Exercises

Exercise 1: Safe List Access

Safe List Access

Exercise 2: Safe Dictionary Access

Safe Dictionary Access

Exercise 3: Integer Conversion with Error Handling

Integer Conversion with Error Handling

Exercise 4: Division with Multiple Exception Types

Division with Multiple Exception Types

Exercise 5: List Operations with Exception Handling

List Operations with Exception Handling

Exercise 6: Nested Try-Except Blocks

Nested Try-Except Blocks

Exercise 7: Exception Handling with Comprehensions

Exception Handling with Comprehensions

Exercise 8: Custom Exception for Validation

Custom Exception for Validation

Exercise 9: Dictionary Operations with Exception Handling

Dictionary Operations with Exception Handling

Exercise 10: Try-Except-Else-Finally with Functions

Try-Except-Else-Finally with Functions

Exercise 11: Complex Exception Handling with Comprehensions

Complex Exception Handling with Comprehensions

Exercise 12: Exception Handling with Lambda and Map

Exception Handling with Lambda and Map

Exercise 13: Nested Exception Handling with Functions

Nested Exception Handling with Functions

Exercise 14: Complex Exception Handling with Sorting

Complex Exception Handling with Sorting

Exercise 15: Ultimate Exception Handling Challenge

Ultimate Exception Handling Challenge

Course Progress