Python 2.7中如何捕获类定义抛出的异常？

Great question! Let's break this down clearly.

First, understand when that code runs: the line foo_const = function_which_throws_something() executes when the class Foo is being defined (not when you create an instance of Foo). So the exception will pop up immediately as your script parses the class Foo block, not later when you do Foo() or access Foo.foo_const.

Now, can you catch this exception? Absolutely—here are the most common and practical ways:

1. Embed a try-except directly inside the class body #

This is the simplest approach. Since the class body is just a regular code block, you can wrap the problematic assignment in a try-except right there:

def function_which_throws_something():
    raise ValueError("Oops, something went wrong!")

class Foo:
    try:
        foo_const = function_which_throws_something()
    except ValueError as e:
        # Handle the exception—set a default value, log it, etc.
        print(f"Failed to initialize foo_const: {e}")
        foo_const = "default_fallback_value"

# Now Foo.foo_const will be "default_fallback_value" instead of crashing the program
print(Foo.foo_const)

Pros: Straightforward, handles the exception at the exact point it occurs, and the class is fully defined once the script runs. If the exception is caught, foo_const gets a valid value; if not, the exception will still bubble up as usual.

2. Wrap the entire class definition in a try-except #

If you need to handle cases where the exception might prevent the class from being defined at all (and want to provide a fallback class), wrap the whole class Foo block:

def function_which_throws_something():
    raise ValueError("Oops, something went wrong!")

try:
    class Foo:
        foo_const = function_which_throws_something()
except ValueError as e:
    print(f"Failed to create Foo class: {e}")
    # Define a fallback version of Foo with a safe default
    class Foo:
        foo_const = "safe_default"

# Now Foo exists regardless of the initial error
print(Foo.foo_const)

Pros: Ensures Foo is always defined (even if the original initialization fails). Cons: A bit clunkier, and you have to duplicate the class definition (or refactor to avoid duplication if needed).

3. Lazy-load the class attribute #

If you don't want the class definition to depend on the success of function_which_throws_something(), delay the initialization until the first time the attribute is accessed. Use a class method or a property:

def function_which_throws_something():
    raise ValueError("Oops, something went wrong!")

class Foo:
    _foo_const = None  # Private placeholder

    @classmethod
    def get_foo_const(cls):
        if cls._foo_const is None:
            try:
                cls._foo_const = function_which_throws_something()
            except ValueError as e:
                print(f"Failed to load foo_const: {e}")
                cls._foo_const = "lazy_fallback"
        return cls._foo_const

    # Optional: Make it act like a regular attribute with a property
    @property
    def foo_const(self):
        return self.__class__.get_foo_const()

# The exception is only caught when you first access the attribute
print(Foo.get_foo_const())  # Prints the fallback
print(Foo().foo_const)      # Same result

Pros: The class definition never fails, even if function_which_throws_something() is broken. The exception is only handled when the attribute is actually needed. Cons: Requires extra code to set up the lazy loading, and the attribute isn't available immediately on the class (unless you call the method upfront).

Key takeaway #

Yes, you absolutely can catch exceptions from class-level attribute initializations. The best approach depends on whether you want to handle the error during class definition, ensure the class always exists, or delay initialization until use.

内容的提问来源于stack exchange，提问作者Maciej Wawrzyńczuk