你观察到的行为是 Python 中类属性查找机制的结果，涉及到元类 (metaclass) 和类属性的优先级。我们分步骤解释代码并探讨如何让行为更加直观。

代码分析

1. MyClass 是一个元类

class MyClass(type):
    @property
    def a(self):
        return 1

• MyClass 继承自 type，是一个元类。
• 定义了一个类属性 a，使用 @property 让它变成只读属性，返回值为 1。
• 因为它是元类的属性，它会作用于所有由 MyClass 创建的类。

2. MyObject 定义

class MyObject(object):
    __metaclass__ = MyClass

    a = 2

• 在 Python 2 中，通过 __metaclass__ 指定元类（在 Python 3 中需要用 class MyObject(metaclass=MyClass):）。
• 这里的 a = 2 是一个类属性，定义在 MyObject 的类命名空间中。

MyObject 的属性 a 有两个来源：
1. 来自元类 MyClass 的属性 a。
2. 定义在类中的属性 a。

3. 属性查找机制

当访问 MyObject.a 时，属性查找遵循以下规则：
1. 先查找类 MyObject 自身的属性。
2. 如果在类中找不到，查找元类（MyClass）中的属性。

但在这个例子中，元类属性通过 @property 形式存在，因此会优先调用元类的 a 属性。

每一行的输出

print MyObject.a

• 输出: 1
MyClass 的 @property 属性 a 被优先查找到。

print object.__getattribute__(MyObject, 'a')

• 输出: 1
  显式调用 object.__getattribute__，它遵循正常的查找规则，因此优先调用元类的 a。

print type.__getattribute__(MyObject, 'a')

• 输出: 1
  使用 type.__getattribute__，同样查找到元类的 @property 属性。

print MyObject.__dict__['a']

• 输出: 2
MyObject.__dict__ 是类的命名空间字典，直接访问 MyObject 类中定义的 a 属性值，不会涉及元类。

print MyObject().a

• 输出: 2
  创建 MyObject 实例后，实例的 a 属性会直接访问类定义中的 a = 2，而不会访问元类。

为什么会让人困惑？

1. 元类的属性优先级问题:
   元类中的 @property 属性会覆盖类中直接定义的属性，这可能违反直觉。

2. 类和实例的行为差异:

3. 对类本身（MyObject），元类属性会干扰直接定义的属性。
4. 对实例（MyObject()），直接使用类中的定义属性。

让行为更直观的方法

方法 1: 避免元类中的属性干扰

可以避免在元类中定义与子类属性名称冲突的 @property，或者将 a 的逻辑封装到更直观的地方。

方法 2: 显式优先类定义

在元类中显式优先返回子类定义的属性：

class MyClass(type):
    @property
    def a(self):
        # 优先查找子类的属性
        if 'a' in self.__dict__:
            return self.__dict__['a']
        return 1

方法 3: 改写 __getattribute__

改写类的 __getattribute__ 以调整查找优先级：

class MyObject(object):
    __metaclass__ = MyClass

    a = 2

    def __getattribute__(cls, name):
        if name == 'a':
            return cls.__dict__.get(name, super(MyObject, cls).__getattribute__(name))
        return super(MyObject, cls).__getattribute__(name)

推荐的做法

• 避免过于复杂的元类设计，元类中的属性容易造成混淆。
• 如果确实需要元类的属性，确保属性名称与类中的属性不冲突。