Python中如何避免多层嵌套对象？有哪些优化处理方法？

针对嵌套对象属性访问过于啰嗦的问题，下面是几个实用的解决思路，从便捷访问到架构重构都覆盖到：

1. 给顶层类添加代理属性 #

最直接的方式是在顶层类（比如ClassOne）里用@property定义快捷属性，直接映射到深层的目标值，访问时一步到位。

class ClassOne: 
    def __init__(self):
        self.object_two = ClassTwo()
    
    @property
    def some_value(self):
        return self.object_two.object_three.object_four.some_value

class ClassTwo: 
    def __init__(self):
        self.object_three = ClassThree()

class ClassThree: 
    def __init__(self):
        self.object_four = ClassFour()

class ClassFour: 
    def __init__(self):
        self.some_value = 5

object_one = ClassOne()
print(object_one.some_value)  # 输出: 5

2. 用__getattr__实现自动属性转发 #

如果有多个深层属性需要访问，可以在各层类里实现__getattr__魔术方法，当访问当前类没有的属性时，自动向下转发到嵌套对象，批量解决多层访问问题。

class ClassOne: 
    def __init__(self):
        self.object_two = ClassTwo()
    
    def __getattr__(self, name):
        return getattr(self.object_two, name)

class ClassTwo: 
    def __init__(self):
        self.object_three = ClassThree()
    
    def __getattr__(self, name):
        return getattr(self.object_three, name)

class ClassThree: 
    def __init__(self):
        self.object_four = ClassFour()
    
    def __getattr__(self, name):
        return getattr(self.object_four, name)

class ClassFour: 
    def __init__(self):
        self.some_value = 5

object_one = ClassOne()
print(object_one.some_value)  # 输出: 5

3. 重构架构，减少嵌套层级（从根源避免） #

如果嵌套不是业务必须的，直接重构类结构，把相关属性或逻辑向上整合，避免不必要的层层嵌套：

# 重构后：简化层级
class ClassOne: 
    def __init__(self):
        # 直接持有底层对象或整合属性
        self.object_four = ClassFour()
        self.some_value = self.object_four.some_value

class ClassFour: 
    def __init__(self):
        self.some_value = 5

object_one = ClassOne()
print(object_one.some_value)  # 输出: 5

如果业务确实需要分层，也可以合并部分非必要的中间层，比如让ClassOne直接持有ClassFour，跳过ClassTwo和ClassThree的嵌套。

4. 写通用的嵌套属性访问函数 #

不想修改原有类的话，可以写一个通用函数，接收对象和属性路径字符串（点分隔），自动遍历获取深层属性：

def get_nested_attr(obj, attr_path):
    for attr in attr_path.split('.'):
        obj = getattr(obj, attr)
    return obj

# 原类结构不变
object_one = ClassOne()
print(get_nested_attr(object_one, "object_two.object_three.object_four.some_value"))  # 输出:5

这个方法适合临时访问多个不同路径的深层属性，不用改动原有代码。

5. 使用数据类简化嵌套定义（Python 3.7+） #

用Python 3.7+的dataclasses可以更简洁地定义嵌套类，再结合代理属性简化访问：

from dataclasses import dataclass

@dataclass
class ClassFour:
    some_value: int = 5

@dataclass
class ClassThree:
    object_four: ClassFour = ClassFour()

@dataclass
class ClassTwo:
    object_three: ClassThree = ClassThree()

@dataclass
class ClassOne:
    object_two: ClassTwo = ClassTwo()
    
    @property
    def some_value(self):
        return self.object_two.object_three.object_four.some_value

object_one = ClassOne()
print(object_one.some_value)  # 输出:5

数据类让嵌套类的定义更简洁，同时保留原有结构，配合代理属性就能轻松访问深层值。

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