Error Handling with try-except

Why Do We Need Error Handling?

When your Python code encounters a situation it can't resolve, it raises an exception and, if unhandled, crashes. This prints a traceback to the console, which is helpful for you as a developer but confusing and jarring for a player.

Let's see what this looks like and how to prevent it.

As the video shows, wrapping potentially problematic code in a try block gives you a way to catch exceptions and handle them gracefully in an except block.

try:
    # Code that might cause an error
    age_str = input("Enter your character's age: ")
    age = int(age_str)
    print(f"Your character is {age} years old.")
except:
    # Code that runs ONLY if an error occurred in the try block
    print("That wasn't a valid number. Please try again.")

print("Program continues...")

If you run this code and enter "twenty" instead of "20", the int() conversion will fail. Instead of crashing, the program will execute the except block and then continue running.

Being Specific: Handling Different Types of Errors

The except block in the example above is a "catch-all." It will catch any error, which can sometimes hide bugs. A better practice is to handle specific, anticipated exceptions.

For example, our calculator from the video could fail in two ways:

1. The user enters text instead of a number (ValueError).
2. The user enters 0 for the denominator (ZeroDivisionError).

We can use multiple except blocks to handle each case with a specific message.

Here is how you would structure code to handle specific errors:

try:
    numerator = int(input("Enter numerator: "))
    denominator = int(input("Enter denominator: "))
    result = numerator / denominator
    print(f"Result is {result}")
except ValueError:
    print("Error: Please enter valid numbers.")
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")

It's also possible to access the error message itself using the as keyword.

player_inventory = ["Sword", "Shield", "Potion"]

# Test your function with a valid index and an invalid one.
# For example: get_item_from_inventory(player_inventory, 1)
# And: get_item_from_inventory(player_inventory, 5)

def get_item_from_inventory(inventory, index):
    try:
        return inventory[index]
    except IndexError:
        return "No item at that slot."

player_inventory = ["Sword", "Shield", "Potion"]

# Test cases
print(f"Item at index 1: {get_item_from_inventory(player_inventory, 1)}")
# Expected output: Item at index 1: Shield

print(f"Item at index 5: {get_item_from_inventory(player_inventory, 5)}")
# Expected output: Item at index 5: No item at that slot.

The Full Structure: else and finally

The try-except statement has two more optional clauses: else and finally. They give you even finer control over your program's flow.

• else: This block runs only if the try block completes successfully (i.e., no exceptions were raised). It's useful for code that should only run on the "happy path."
• finally: This block runs no matter what. It executes whether the try block succeeded or failed. It's perfect for cleanup actions, like closing a file or a network connection.

This flowchart provides a great visual summary of how these blocks work together.

Let's watch a video that explains these clauses in detail.

Here's an example that combines everything, using our file-handling knowledge from the last lesson:

try:
    f = open('game_config.txt', 'r')
    # Let's pretend we read and parse the file here
except FileNotFoundError:
    print("Config file not found. Using default settings.")
else:
    # This runs only if the file was successfully opened
    print("Config file loaded successfully.")
    # We can close the file here, because we know 'f' exists
    f.close() 
finally:
    # This runs regardless of what happened
    print("Configuration setup finished.")

Note: In the previous lesson, we learned to use with open(...), which automatically handles closing the file for you. This is generally preferred over manually calling f.close() in an else or finally block.

Creating Your Own Errors with raise

Sometimes, you need to create an error yourself. For instance, your game's logic might dictate that a player can't use a certain item outside of combat. This isn't a built-in Python error, but you can signal it as one using the raise keyword.

This is very powerful for enforcing game rules.

def use_special_attack(player_in_combat):
    if not player_in_combat:
        raise ValueError("Special attacks can only be used in combat!")
    else:
        print("Player uses Whirlwind Strike!")

try:
    # Player is just walking around the map
    is_in_combat = False
    use_special_attack(is_in_combat)
except ValueError as e:
    # The 'e' variable contains the error message we wrote
    print(f"Cannot perform action: {e}") 

Practice Time

To solidify your understanding, it's best to write some code. The following resource provides a great set of exercises.

Conclusion

Congratulations on completing the first module of this course! You have built a strong foundation in Python, from the basics of variables and loops to the complexities of classes and now, robust error handling.

Here are the key takeaways from today's lesson:

• Wrap code that might fail in a try block to prevent your program from crashing.
• Use except blocks to handle errors. It's best practice to catch specific exceptions (ValueError, FileNotFoundError, etc.) rather than a generic one.
• The else block runs only if the try block succeeds, making it ideal for "happy path" logic.
• The finally block runs no matter what, making it perfect for essential cleanup tasks.
• Use the raise keyword to create your own errors and enforce rules in your program's logic.

In our next lesson, we will begin the most exciting part of our journey yet. We will move into Module 2: Introduction to Game Development with Pygame. You'll set up your game development environment and, for the first time, create a visual game window on the screen. The Python skills you've just solidified are the bedrock upon which you'll build your RPG.