How to pass a variable to an exception in Python?

In Python, you can pass variables to exceptions to include dynamic information in error messages. This is useful for providing context about what went wrong and making debugging easier.

Passing Variables to Built-in Exceptions

You can pass variables directly to built-in exceptions like ValueError, TypeError, etc. The variable becomes part of the exception message ?

value = "abc123"
try:
    raise ValueError(f"Invalid input: {value}")
except ValueError as e:
    print("Caught exception:", e)

Caught exception: Invalid input: abc123

Custom Exceptions with Single Variable

For custom exceptions, store variables as instance attributes to access them later. This provides more flexibility than just including them in the message ?

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

error_msg = "Something went wrong."
try:
    raise MyError(error_msg)
except MyError as e:
    print("Caught custom exception:", e.message)

Caught custom exception: Something went wrong.

Passing Multiple Variables

You can pass multiple variables to create more descriptive error messages and store each variable separately ?

class LoginError(Exception):
    def __init__(self, user, reason):
        self.user = user
        self.reason = reason
        super().__init__(f"User '{user}' failed to login: {reason}")

username = "john_doe"
reason = "Invalid password"
try:
    raise LoginError(username, reason)
except LoginError as e:
    print("Caught exception:", e)
    print("Failed user:", e.user)
    print("Reason:", e.reason)

Caught exception: User 'john_doe' failed to login: Invalid password
Failed user: john_doe
Reason: Invalid password

Accessing Variables After Catching

When you store variables as instance attributes, you can access them individually after catching the exception. This is useful for error handling logic ?

class DataMissingError(Exception):
    def __init__(self, missing_field, data_type="required"):
        self.missing_field = missing_field
        self.data_type = data_type
        super().__init__(f"Missing {data_type} data: {missing_field}")

try:
    field = "email"
    raise DataMissingError(field, "contact")
except DataMissingError as e:
    print("Exception:", e)
    print("Missing field:", e.missing_field)
    print("Data type:", e.data_type)

Exception: Missing contact data: email
Missing field: email
Data type: contact

Using Variables for Exception Handling Logic

You can use the stored variables to implement specific error handling based on the exception data ?

class ValidationError(Exception):
    def __init__(self, field, value, expected_type):
        self.field = field
        self.value = value
        self.expected_type = expected_type
        super().__init__(f"Field '{field}' expected {expected_type}, got {type(value).__name__}")

try:
    age = "25"  # Should be int
    raise ValidationError("age", age, "int")
except ValidationError as e:
    print("Validation failed:", e)
    # Handle based on field type
    if e.field == "age":
        print("Converting age to integer...")
        converted_value = int(e.value)
        print(f"Converted value: {converted_value}")

Validation failed: Field 'age' expected int, got str
Converting age to integer...
Converted value: 25

Conclusion

Pass variables to exceptions by including them as arguments when raising the exception. For custom exceptions, store variables as instance attributes to access them later for specific error handling logic.