Python面向对象最佳构造选择：将字典转为带方法的对象

Great question! Let's break down your options and land on the best practice for your scenario—where you want to add specific print methods to a dictionary generated by an existing class, without touching its dict-creation logic.

First, Let's Rule Out Inheritance #

You could create a subclass of dict that adds printKey1() and printKey2() methods, like this:

class DictWithPrints(dict):
    def printKey1(self):
        print(self.get('Key1', []))
    
    def printKey2(self):
        print(self.get('Key2', []))

# Usage
a = A(file_path="your/path")
generated_dict = a.create_dict("your_string")
custom_obj = DictWithPrints(generated_dict)
custom_obj.printKey1()

But this has two big downsides:

• It copies the entire generated dictionary into the subclass instance, which wastes memory if the dict is large.
• You're inheriting all of dict's methods, even though you only need the two print functions. This violates the Interface Segregation Principle—no need to expose unnecessary functionality.

Why Composition (Class Containment) Is the Best Fit #

Composition means creating a new class that holds a reference to the generated dictionary, rather than inheriting from it. This lets you wrap the dict with exactly the functionality you need, without messing with the original dict-creation logic.

Here's a clean implementation:

class DictPrinter:
    def __init__(self, data_dict):
        # Hold a reference to the original dictionary
        self._data = data_dict
    
    def printKey1(self):
        # Access the dict's Key1 safely (fallback to empty list if missing)
        print(self._data.get('Key1', []))
    
    def printKey2(self):
        print(self._data.get('Key2', []))

# How to use it
a = A(file_path="your/path")
generated_dict = a.create_dict("your_string")
# Wrap the existing dict with our printer class
printer = DictPrinter(generated_dict)

# Call your custom methods
printer.printKey1()
printer.printKey2()

The Perks of This Approach: #

1. Zero impact on existing code: You don't modify class A or its create_dict method at all—perfect for preserving existing logic.
2. Memory efficient: No copying of the dictionary; we just reference the original. If the original dict gets updated later, those changes will show up in DictPrinter automatically.
3. Clean and focused: The DictPrinter class only does one thing—add print functionality. It doesn't carry around the baggage of all dict methods.
4. Extensible: If you need more print methods later, just add them to DictPrinter without touching any other code.

Bonus: Access the Raw Dict If Needed #

If you ever need to get back to the original dictionary, add a property to DictPrinter:

class DictPrinter:
    # ... existing code ...
    @property
    def raw_dict(self):
        return self._data

# Now you can do this:
original_dict = printer.raw_dict

When Would You Use Inheritance? #

Only if you need your custom object to behave exactly like a dictionary (support all dict operations like keys(), items(), bracket access) while adding the print methods. But based on your description, that's not necessary—you just need the print functions. So composition is the clear winner here.

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