Swift的@dynamicMemberLookup是否具有Python等效项？

Question

在Swift中，您可以定义@dynamicMemberLookup（see documentation）以直接访问嵌套在另一种类型内的属性。是否有Python个等效项？

我想用Python实现的示例

比方说我有一个成员班，例如：

c = OuterClass()
c.inner_class = ClassWithManyMembers()
c.inner_class.member1 = "1"
c.inner_class.member2 = "2"
c.inner_class.member3 = "3"

我希望能够获取/设置这些成员，而不必每次都键入inner_class：

print(c.member1)  # prints "1"
c.member1 = 3
print(c.member1)  # prints "3"

Swift（Source）中的示例：

通过成员名称进行动态成员查找

@dynamicMemberLookup
struct DynamicStruct {
    let dictionary = ["someDynamicMember": 325,
                      "someOtherMember": 787]
    subscript(dynamicMember member: String) -> Int {
        return dictionary[member] ?? 1054
    }
}
let s = DynamicStruct()

// Use dynamic member lookup.
let dynamic = s.someDynamicMember
print(dynamic)
// Prints "325"

通过关键路径查找动态成员

struct Point { var x, y: Int }

@dynamicMemberLookup
struct PassthroughWrapper<Value> {
    var value: Value
    subscript<T>(dynamicMember member: KeyPath<Value, T>) -> T {
        get { return value[keyPath: member] }
    }
}

let point = Point(x: 381, y: 431)
let wrapper = PassthroughWrapper(value: point)
print(wrapper.x)

在Python中，我唯一的想法是将所有嵌套的属性直接monkey-patch传递给外部类。

Answer 1

我建议不要互相嵌套类，但是如果必须这样做，请尝试以下操作：

class MetaOuter(type):
    def __getattr__(cls, attr):
        for member in cls.__dict__.values():
            if hasattr(member, attr):
                return getattr(member, attr)
        raise AttributeError(attr)

    def __setattr__(cls, attr, value):
        for member in cls.__dict__.values():
            if hasattr(member, attr):
                setattr(member, attr, value)
                return
        super().__setattr__(attr, value)


class Outer(metaclass=MetaOuter):
    a = 0

    class Inner:
        x = 1
        y = 2

现在Outer内嵌套类的任何属性都可以作为Outer的属性使用（并可以写入）：

>>> Outer.x, Outer.y
(1, 2)
>>> Outer.a # Accessing regular attributes still works as usual
0
>>> Outer.x = True
>>> Outer.Inner.x
True

如果您需要嵌套多个级别，请对所有内部封装类使用相同的元类：

class Outer(metaclass=MetaOuter):
    a = 0

    class Inner(metaclass=MetaOuter):
        x = 1
        y = 2

        class Innerer:
            z = 42

>>> Outer.a, Outer.x, Outer.y, Outer.z
(0, 1, 2, 42)
>>> Outer.z = -1
>>> Outer.z
-1

注意：请注意，如果尝试访问在多个嵌套类中找到的属性，则不能确定该属性来自哪个类。在这种情况下，一种更可预测的实现是处理将要查找的某种键路径，但这与Python默认情况下提供的键路径基本相同（例如Outer.Inner.Innerer.z）。

Answer 2

通常，当您要重复访问内部对象时，只需保存对内部对象的引用即可。

c = OuterClass()
c.inner_class = ClassWithManyMembers()

ic = c.inner_class
print(ic.member1)
print(ic.member2)
print(ic.member3)

ic.member1 = "5"