如何简洁定义含大量属性的类：属性设值调用带不同参数的统一Setter

Hey there! Let's break down practical solutions for both of your questions about streamlining repetitive getter/setter code in Python classes.

When you've got multiple properties sharing nearly identical getter/setter logic, repeating the same code over and over is unnecessary. Here are two reliable approaches:

1. 复用@property逻辑（适合少量属性） #

If you only have a handful of properties, wrap the shared logic in helper functions and call them from each property's getter/setter. For example:

class MyClass:
    def _get_shared_value(self, attr_name):
        # Shared getter logic (e.g., default value handling)
        return getattr(self, f"_{attr_name}", 0)
    
    def _set_shared_value(self, attr_name, value):
        # Shared setter logic (e.g., validation, logging)
        if not isinstance(value, int):
            raise ValueError("Value must be an integer")
        setattr(self, f"_{attr_name}", value)
    
    @property
    def red_LED(self):
        return self._get_shared_value("red_LED")
    
    @red_LED.setter
    def red_LED(self, value):
        self._set_shared_value("red_LED", value)
    
    # Repeat for other properties like green_LED, blue_LED...

2. 使用描述符（适合大量属性） #

For a scalable, clean solution—especially if you have dozens of properties—Python descriptors are your best bet. A descriptor encapsulates shared get/set logic into a single class, which you can reuse for every property. This eliminates all repetitive code entirely, and we'll dive deeper into this for your second question since it's perfect for that use case.

Your current approach works, but it's verbose and error-prone—totally understand why you want a better way. Descriptors are ideal here because they let you define the hardware interaction logic once, then attach it to each property with a single line of code.

Here's how to implement it:

Step 1: Create a Descriptor Class #

This class handles all shared getter/setter logic, including calling TalkToHardware() with the correct address:

class HardwareProperty:
    def __init__(self, address):
        self.address = address
        # Use a unique internal attribute name to avoid conflicts between properties
        self._internal_attr = f"_hardware_prop_{address}"

    def __get__(self, instance, owner):
        # Return the stored value, or a default if it doesn't exist yet
        if instance is None:
            return self
        return getattr(instance, self._internal_attr, 0)

    def __set__(self, instance, value):
        # Trigger the hardware call with the pre-defined address
        instance.TalkToHardware(self.address, value)
        # Save the value to the instance for future getter calls
        setattr(instance, self._internal_attr, value)

Step 2: Define Your Controller Class #

Now you can define each LED property in one line, passing its specific address to the descriptor:

class Hardware_Controller(object):
    def TalkToHardware(self, address, value):
        # Replace this with your actual hardware interaction code
        print(f"Sent value {value} to hardware address {hex(address)}")

    # Define each property with its unique hardware address
    red_LED = HardwareProperty(address=0x00)
    green_LED = HardwareProperty(address=0x01)
    blue_LED = HardwareProperty(address=0x02)
    # Add as many more properties as you need—one line each!

Step 3: Test It Out #

Using the class is straightforward, and the hardware call happens automatically when you set a property:

controller = Hardware_Controller()
controller.red_LED = 1  # Output: Sent value 1 to hardware address 0x0
print(controller.red_LED)  # Output: 1

controller.green_LED = 0  # Output: Sent value 0 to hardware address 0x1

Why This Works So Well #

• No repetition: All get/set logic lives in HardwareProperty—update it once, and every property uses the new logic.
• Clean, readable class definition: Each property is a single line, making it easy to add/remove properties or adjust addresses.
• Less error-prone: No typos in repeated setter code, since you're reusing the same descriptor logic every time.

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