Pythonic属性与异常运用：Divider类属性篡改问题的优化问询

Great question! The problem you're hitting is super common with mutable Python classes—even if you lock down validation during initialization, users (or future you!) can still tweak attributes later and break the divide() method. Let's go through a few clean, Pythonic ways to fix this.

1. Use @property Decorators for Validated Attribute Access #

This is the most flexible approach: wrap your numerator and denominator with property getters and setters, so every time someone tries to set the attribute, validation runs automatically. Here's how to refactor your Divider2 class:

class Divider:
    def __init__(self, numerator=0, denominator=1):
        # Use the setters during initialization to reuse validation logic
        self._numerator = None
        self._denominator = None
        self.numerator = numerator
        self.denominator = denominator

    @property
    def numerator(self):
        return self._numerator

    @numerator.setter
    def numerator(self, value):
        try:
            self._numerator = float(value)
        except ValueError:
            raise ValueError("Numerator must be numeric!")

    @property
    def denominator(self):
        return self._denominator

    @denominator.setter
    def denominator(self, value):
        try:
            val = float(value)
        except ValueError:
            raise ValueError("Denominator must be numeric!")
        if val == 0:
            raise ValueError("Denominator must be non-zero!")
        self._denominator = val

    def divide(self):
        return self.numerator / self.denominator

How it works: #

• We use "private" underscore-prefixed attributes (_numerator, _denominator) to store the actual values (this is a Python convention, not strict enforcement, but it signals to users they shouldn't modify these directly).
• The public numerator and denominator properties use setters that run your validation logic every time the attribute is set—whether during __init__ or later.
• Now if someone tries to set x.numerator = 'hello', the setter immediately throws an error instead of waiting for divide() to fail:

  >>> x = Divider(10,5)
  >>> x.numerator = 'hello'
  ValueError: Numerator must be numeric!
  

2. Create an Immutable Class with dataclasses #

If you don't need to modify attributes after initialization at all, making your class immutable is a clean solution. Python's dataclasses module makes this easy with frozen=True:

from dataclasses import dataclass

@dataclass(frozen=True)
class ImmutableDivider:
    numerator: float = 0.0
    denominator: float = 1.0

    def __post_init__(self):
        # Run validation after the dataclass initializes attributes
        if self.denominator == 0:
            raise ValueError("Denominator must be non-zero!")
        # Add string-to-float conversion if needed
        try:
            object.__setattr__(self, 'numerator', float(self.numerator))
            object.__setattr__(self, 'denominator', float(self.denominator))
        except ValueError as e:
            raise ValueError("Numerator and denominator must be numeric!") from e

    def divide(self):
        return self.numerator / self.denominator

How it works: #

• frozen=True makes all attributes immutable—any attempt to modify them after initialization will throw a dataclasses.FrozenInstanceError.
• We use __post_init__ to add validation and type conversion (since frozen classes block direct attribute assignment, we use object.__setattr__ to bypass the freeze temporarily for initialization).
• Example behavior:

  >>> x = ImmutableDivider(10,5)
  >>> x.numerator = 'hello'
  dataclasses.FrozenInstanceError: cannot assign to field 'numerator'
  

3. Override __setattr__ to Validate All Attribute Assignments #

For a more heavy-handed approach (good if you want to enforce validation for all attributes), you can override the __setattr__ method to check values before they're assigned:

class StrictDivider:
    def __init__(self, numerator=0, denominator=1):
        self.numerator = numerator
        self.denominator = denominator

    def __setattr__(self, name, value):
        if name == 'numerator':
            try:
                value = float(value)
            except ValueError:
                raise ValueError("Numerator must be numeric!")
        elif name == 'denominator':
            try:
                val = float(value)
            except ValueError:
                raise ValueError("Denominator must be numeric!")
            if val == 0:
                raise ValueError("Denominator must be non-zero!")
            value = val
        # Call the parent class's __setattr__ to actually set the value
        super().__setattr__(name, value)

    def divide(self):
        return self.numerator / self.denominator

How it works: #

• Every time any attribute is set (including during __init__), __setattr__ runs first.
• We add validation logic specifically for numerator and denominator, then pass valid values to the parent class's __setattr__ to complete the assignment.
• This prevents invalid values from ever being stored, no matter when the assignment happens.

Which Should You Choose? #

• Use properties if you want attributes to be mutable but always validated. This is the most Pythonic and flexible option for most cases.
• Use immutable dataclasses if your divider shouldn't change after creation—this makes your code more predictable and thread-safe.
• Use __setattr__ override only if you need strict control over all attribute assignments (it's less readable than properties for simple cases).

内容的提问来源于stack exchange，提问作者Ashley