解密 __getattr__ 和 __getattribute__ 的用法与区别

class A:
    pass
a = A()
a.xxx
"""
AttributeError: 'A' object has no attribute 'xxx'
"""

class Girl:
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
    def get_info(self):
        return f"name: {self.name}, age: {self.age}"
    def __getattr__(self, item):
        return f"你访问了 {item} 属性"
girl = Girl()
print(girl.name, girl.age)  # 古明地觉 17
print(girl.get_info)  # <bound method Girl.get_info...>
print(girl.get_info())  # name: 古明地觉, age: 17
print(girl.xxx)  # 你访问了 xxx 属性
print(girl.yyy)  # 你访问了 yyy 属性
print(girl.zzz)  # 你访问了 zzz 属性

def __getattr__(name):
    return f"{__name__} 中不存在 {name}"
name = "古明地觉"
age = 17

from tools import name, age, xxx, yyy
print(name, age)  # 古明地觉 17
print(xxx)  # tools 中不存在 xxx
print(yyy)  # tools 中不存在 yyy
import tools
print(tools.zzz)  # tools 中不存在 zzz

class Girl:
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
    def __getattribute__(self, item):
        return f"获取属性: {item}"
girl = Girl()
print(girl.name)  # 获取属性: name
print(girl.age)  # 获取属性: age
print(girl.xxx)  # 获取属性: xxx
# 即便你想通过属性字典获取也是没有用的
# 因为不管什么属性，都会执行 __getattribute__
print(girl.__dict__)  # 获取属性: __dict__

class Girl:
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
    def __getattribute__(self, item):
        return getattr(self, item)
girl = Girl()
print(girl.name)
# 显然上面的代码会陷入无限递归
# 因为 girl.name 会调用 __getattribute__
# 而在里面又执行了 getattr(self, item)，还是在获取属性
# 所以又会调用 __getattribute__，于是会无限递归
# 可能有人说，那我换一种方式
# 我将 getattr(self, item) 改成 self.__dict__[item] 可以吗
# 答案也是不行的，因为 self.__dict__ 仍是在获取属性
# 只要获取属性，就会触发 __getattribute__，依旧会陷入无限递归

class Girl:
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
    def __getattribute__(self, item):
        return super().__getattribute__(item)
girl = Girl()
print(girl.name)
print(girl.age)
try:
    girl.xxx
except AttributeError:
    print("属性 xxx 不存在")
"""
古明地觉
17
属性 xxx 不存在
"""

class Girl:
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
    def __getattr__(self, item):
        print(f"__getattr__ {item}")
        return f"获取属性 {item}"
    def __getattribute__(self, item):
        print(f"__getattribute__ {item}")
        return super().__getattribute__(item)
girl = Girl()
# 不管属性是否存在，一律调用 __getattribute__
# 然后在里面我们又调用了父类的 __getattribute__
# 那么会检测属性是否存在，存在则直接获取对应的值，然后返回
print(girl.name)
"""
__getattribute__ name
古明地觉
"""
# age 也是相同的逻辑，和 name 一样，这两个属性都是存在的
print(girl.age)
"""
__getattribute__ age
17
"""
# 依旧执行 __getattribute__，然后调用父类的 __getattribute__
# 由于属性 xxx 不存在，于是会执行 __getattr__
print(girl.xxx)
"""
__getattribute__ xxx
__getattr__ xxx
获取属性 xxx
"""

class Girl:
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
    def __getattr__(self, item):
        return f"属性 {item} 不存在"
    def __getattribute__(self, item):
        if item == "age":
            return "女人芳龄不可泄露，别问，问就是还不到 18 岁"
        return super().__getattribute__(item)
girl = Girl()
# name 属性存在，所以在 __getattribute__ 中直接返回
print(girl.name)
"""
古明地觉
"""
# age 也是如此，也是在 __getattribute__ 中直接返回
# 只不过它相当于被拦截了
print(girl.age)
"""
女人芳龄不可泄露，别问，问就是还不到 18 岁
"""
# 父类在执行 __getattribute__ 的时候，发现 xxx 属性不存在
# 于是会触发 __getattr__ 的执行（如果没定义则抛出 AttributeError）
print(girl.xxx)
"""
属性 xxx 不存在
"""

class Girl:
    def __init__(self):
        self.name = "古明地觉"
        self.age = 17
    def get_info(self):
        return f"name: {self.name}, age: {self.age}"
    def __getattribute__(self, item):
        if item == "get_info":
            return "此方法禁止获取"
        return super().__getattribute__(item)
girl = Girl()
print(girl.get_info)
"""
此方法禁止获取
"""
# 默认情况下 girl.get_info 拿到的是一个方法
# 然后再加上小括号就会执行该方法
# 但在 __getattribute__ 中我们将其拦截了，并返回一个字符串
# 所以此时 girl.get_info() 就会报错，因为字符串无法被调用