Python OOP类属性访问优化咨询：对`eric.privileges.privileges = eric_privileges`的改进建议

Great question! That line eric.privileges.privileges = eric_privileges feels awkward because it directly pokes at the internal attribute of the Privileges class—breaking the core OOP principle of encapsulation (we should let classes handle their own state via methods, not external code). Let's look at a few cleaner ways to implement this:

1. Add Methods to the Privileges Class #

The simplest fix is to give the Privileges class explicit methods to update its privileges. This makes the code more readable and keeps logic where it belongs:

class Privileges():
    """A class to store an admin's privileges."""
    # Fix the mutable default parameter trap first!
    def __init__(self, privileges=None):
        self.privileges = privileges if privileges is not None else []

    def show_privileges(self):
        print("\nPrivileges:")
        if self.privileges:
            for privilege in self.privileges:
                print("- " + privilege)
        else:
            print("- This user has no privileges.")
    
    # Method to replace the entire privileges list
    def set_privileges(self, new_privileges):
        """Replace current privileges with a new list."""
        # Optional: add validation here (e.g., check if it's a list)
        self.privileges = new_privileges
    
    # Optional: method to add a single privilege
    def add_privilege(self, privilege):
        """Add one privilege to the list (avoids duplicates)."""
        if privilege not in self.privileges:
            self.privileges.append(privilege)

Now you can update privileges cleanly:

eric.privileges.set_privileges(eric_privileges)
# Or add a single one later: eric.privileges.add_privilege("can delete accounts")

2. Pass Privileges Directly When Creating the Admin #

If you know an admin's privileges upfront, you can pass them during initialization to avoid post-creation assignments entirely:

class Admin(User):
    """A user with administrative privileges."""
    def __init__(self, first_name, last_name, username, email, location, privileges=None):
        """Initialize the admin with optional privileges."""
        super().__init__(first_name, last_name, username, email, location)
        # Again, avoid mutable default parameters
        self.privileges = Privileges(privileges)

Then create your admin with privileges right away:

eric_privileges = [
    'can reset passwords',
    'can moderate discussions',
    'can suspend accounts',
]
eric = Admin('eric', 'matthes', 'e_matthes', 'e_matthes@example.com', 'alaska', eric_privileges)
eric.privileges.show_privileges()  # No extra assignment needed!

3. Use @property for Controlled Attribute Access #

If you want to keep the "assignment" syntax but still enforce encapsulation, use Python's @property decorator to create a controlled setter:

class Privileges():
    """A class to store an admin's privileges."""
    def __init__(self, privileges=None):
        self._privileges = privileges if privileges is not None else []

    @property
    def privileges(self):
        """Read-only access to the privileges list (returns a copy to prevent external modification)."""
        return self._privileges.copy()
    
    @privileges.setter
    def privileges(self, new_privileges):
        """Set new privileges with basic validation."""
        if not isinstance(new_privileges, list):
            raise ValueError("Privileges must be a list!")
        self._privileges = new_privileges

    def show_privileges(self):
        print("\nPrivileges:")
        if self._privileges:
            for privilege in self._privileges:
                print("- " + privilege)
        else:
            print("- This user has no privileges.")

Now your original line eric.privileges.privileges = eric_privileges works exactly as before—but behind the scenes, it's using the setter method which can validate input, and the getter returns a copy so external code can't accidentally modify the internal list directly.

Quick Note on Mutable Default Parameters #

One critical fix I added to all examples: avoid using mutable default parameters like privileges=[] in __init__. Python reuses the same list for every instance created without explicit privileges, which leads to weird bugs where changes to one instance's privileges affect others. Using privileges=None and initializing an empty list inside the method fixes this.

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