1

在Swift中，您可以定义@dynamicMemberLookup（参见文档）以直接访问嵌套在另一种类型中的属性。有没有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（来源）中的示例：

按成员名称动态查找成员

@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所有嵌套属性直接传递给外部类。

4

2 回答 2

2

我建议不要将类相互嵌套，但如果你必须这样做，试试这个：

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）。

于 2019-11-14T21:03:49.267 回答
1

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

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

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

ic.member1 = "5"
于 2019-11-14T23:40:06.443 回答