Raising exceptions in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this exception raising code?

Consider the following Python code that raises an exception. What will be printed when this code runs?

Python

def check_age(age):
    if age < 18:
        raise ValueError("Age must be at least 18")
    return "Access granted"

try:
    print(check_age(16))
except ValueError as e:
    print(f"Error: {e}")

A Access granted

B No output

C ValueError: Age must be at least 18

D Error: Age must be at least 18

💡 Hint

Think about what happens when raise is called inside the function and how the try-except block handles it.

The function check_age raises a ValueError when the age is less than 18. The try-except block catches this exception and prints the error message prefixed by "Error:".

❓ Predict Output

intermediate

What error does this code raise?

Look at this code snippet. What error will it raise when executed?

Python

def divide(x, y):
    if y == 0:
        raise ZeroDivisionError("Cannot divide by zero")
    return x / y

result = divide(10, 0)

A ZeroDivisionError: Cannot divide by zero

B ValueError: Cannot divide by zero

C TypeError: unsupported operand type(s)

D No error, returns 0

💡 Hint

Check the condition that triggers the raise statement and the type of exception raised.

The function explicitly raises a ZeroDivisionError with the message "Cannot divide by zero" when the divisor is zero.

❓ Predict Output

advanced

What is the output of this nested exception raising code?

Analyze this code that raises exceptions inside nested try-except blocks. What will be printed?

Python

def func():
    try:
        raise KeyError("Key missing")
    except KeyError:
        raise ValueError("Value error raised")

try:
    func()
except ValueError as e:
    print(f"Caught: {e}")

A Caught: Value error raised

B No output

C KeyError: Key missing

D Caught: Key missing

💡 Hint

Notice the exception raised inside the except block and which exception is caught outside.

The func raises a KeyError, which is caught and replaced by raising a ValueError. The outer try-except catches the ValueError and prints its message.

❓ Predict Output

advanced

What happens when this code raises an exception without a message?

What will be the output of this code that raises an exception without a message?

Python

try:
    raise RuntimeError
except RuntimeError as e:
    print(f"Caught an error: {e}")

A No output

B Caught an error:

C RuntimeError

D Caught an error: RuntimeError

💡 Hint

Check what the exception object e contains when no message is provided.

When an exception is raised without a message, its string representation is empty, so printing {e} shows an empty string after the colon.

🧠 Conceptual

expert

Which option correctly raises a custom exception with a message?

You want to create and raise a custom exception MyError with the message "Something went wrong". Which option does this correctly?

A

class MyError(Exception):
    pass

raise MyError

B

class MyError(Exception):
    def __init__(self):
        super().__init__("Something went wrong")

raise MyError()

C

class MyError(Exception): pass

raise MyError("Something went wrong")

D

class MyError(Exception):
    def __init__(self, msg):
        self.msg = msg

raise MyError("Something went wrong")

💡 Hint

Remember how to define a custom exception and pass a message when raising it.

Option C defines a custom exception class and raises it with a message directly. Option C requires calling MyError() without arguments but sets the message in __init__. Option C raises the class, not an instance, causing a TypeError. Option C does not call super().__init__, so the message is not set properly.

Practice

1. What does the raise statement do in Python?

easy

A. It creates a new variable.

B. It prints a message to the screen.

C. It stops the program and signals an error.

D. It repeats a block of code.

Solution

1. Step 1: Understand the purpose of raise

   The raise statement is used to stop the program when an error or unexpected situation occurs.

2. Step 2: Compare options with raise behavior

   Only It stops the program and signals an error. correctly describes that raise stops the program and signals an error.

3. Final Answer:

   It stops the program and signals an error. -> Option C

4. Quick Check:

   raise = stop program on error [OK]

Hint: Remember: raise means stop and show error [OK]

Common Mistakes:

• Thinking raise prints messages
• Confusing raise with variable creation
• Assuming raise repeats code

2. Which of the following is the correct syntax to raise a ValueError with a message "Invalid input"?

easy

A. raise ValueError("Invalid input")

B. throw ValueError("Invalid input")

C. raise new ValueError("Invalid input")

D. error ValueError("Invalid input")

Solution

1. Step 1: Recall Python syntax for raising exceptions

   In Python, the correct way to raise an exception is using raise ExceptionType("message").

2. Step 2: Check each option

   raise ValueError("Invalid input") uses correct syntax. Options B, C, and D use invalid keywords or extra words not used in Python.

3. Final Answer:

   raise ValueError("Invalid input") -> Option A

4. Quick Check:

   raise + ExceptionType + message = correct syntax [OK]

Hint: Use 'raise ExceptionType("message")' exactly [OK]

Common Mistakes:

• Using 'throw' instead of 'raise'
• Adding 'new' keyword like other languages
• Using 'error' keyword which doesn't exist

3. What will be the output of this code?

def check_age(age):
    if age < 18:
        raise ValueError("Too young")
    return "Access granted"

try:
    print(check_age(16))
except ValueError as e:
    print(e)

medium

A. Too young

B. Access granted

C. ValueError exception not caught

D. No output

Solution

1. Step 1: Analyze function behavior with age 16

   Since 16 < 18, the function raises a ValueError with message "Too young".

2. Step 2: Check exception handling in try-except

   The exception is caught by the except block, which prints the error message "Too young".

3. Final Answer:

   Too young -> Option A

4. Quick Check:

   Exception message printed = Too young [OK]

Hint: Exception message prints if caught in except [OK]

Common Mistakes:

• Assuming function returns 'Access granted'
• Thinking exception crashes program
• Missing that except prints the error message

4. Find the error in this code snippet:

def divide(a, b):
    if b == 0:
        raise "Cannot divide by zero"
    return a / b

print(divide(10, 0))

medium

A. No error, code runs fine

B. raise must be followed by an exception instance, not a string

C. Division by zero is allowed in Python

D. Function divide should return None when b is zero

Solution

1. Step 1: Identify the raise statement usage

   The code uses raise "Cannot divide by zero", which raises a string, not an exception object.

2. Step 2: Understand correct raise syntax

   Python requires raising an exception instance, e.g., raise ValueError("Cannot divide by zero").

3. Final Answer:

   raise must be followed by an exception instance, not a string -> Option B

4. Quick Check:

   raise needs exception object, not string [OK]

Hint: Always raise an exception object, not a string [OK]

Common Mistakes:

• Raising strings instead of exceptions
• Ignoring that division by zero causes error
• Assuming code runs without error

5. You want to create a function check_score(score) that raises a ValueError if the score is not between 0 and 100 (inclusive). Which code correctly implements this?

hard

A. def check_score(score):
if score <= 0 or score >= 100:
raise ValueError("Score must be 0-100")
return True

B. def check_score(score):
if 0 < score < 100:
raise ValueError("Score must be 0-100")
return True

C. def check_score(score):
if score == 0 or score == 100:
raise ValueError("Score must be 0-100")
return True

D. def check_score(score):
if score < 0 or score > 100:
raise ValueError("Score must be 0-100")
return True

Solution

1. Step 1: Understand the valid score range

   Score must be between 0 and 100, including 0 and 100.

2. Step 2: Check each condition for raising ValueError

   def check_score(score): if score < 0 or score > 100: raise ValueError("Score must be 0-100") return True raises error if score is less than 0 or greater than 100, correctly allowing 0 and 100.

3. Step 3: Verify other options

   def check_score(score): if 0 < score < 100: raise ValueError("Score must be 0-100") return True raises error incorrectly for valid scores between 0 and 100. def check_score(score): if score <= 0 or score >= 100: raise ValueError("Score must be 0-100") return True excludes 0 and 100 incorrectly. def check_score(score): if score == 0 or score == 100: raise ValueError("Score must be 0-100") return True raises error only if score equals 0 or 100, which is wrong.

4. Final Answer:

   def check_score(score): if score < 0 or score > 100: raise ValueError("Score must be 0-100") return True -> Option D

5. Quick Check:

   Raise error outside 0-100 inclusive = def check_score(score): if score < 0 or score > 100: raise ValueError("Score must be 0-100") return True [OK]

Hint: Use 'if score < 0 or score > 100' to check range [OK]

Common Mistakes:

• Using wrong comparison operators
• Excluding valid boundary values
• Raising error inside valid range