在Python中，属性自省是一种强大的特性，它允许我们在运行时检查和操作对象的属性。在本文中，我们将探讨Python中的属性自省，并结合实际场景和代码来展示其用法。
1. 私有属性与访问限制
Python中的私有属性是指以下划线开头的变量或方法，例如 _name 或 _method()。尽管这种命名约定并非强制性的，只是一种惯例，但它用于提示该属性或方法应该只在类内部使用，而不应该在外部直接访问。
Python中的私有属性具有以下特点：
- 私有属性不能被外部直接访问，但可以通过类内部的方法间接地访问。
- 在类内部定义的方法可以访问所有属性，包括私有属性，因为它们都在同一个作用域内。
- 子类无法继承父类的私有属性，但可以通过公有方法来访问父类的私有属性。
接下来勇哥带你探讨如何访问和修改私有属性：
class YongeGe:
name= '勇哥' # 普通属性
_ager = 100 # 普通属性
__money = 109 # 私有属性
__money_empty__ = 1 # 不推荐做法
yongge = YongeGe()
print(yongge .name) # 输出: 勇哥
print(yongge ._ager ) # 输出: 100
print(yongge ._YongeGe__money ) # 输出: 109
print(yongge .__money_empty__ ) # 输出: 1
print(yongge .__money ) # 输出: AttributeError: 'YongeGe' object has no attribute '__money'很明显看到 Python 中没有真正的私有属性，实际上双下划线开头的属性被名称重整了，即将属性名转换为 _ClassName__name的形式，使其难以在外部被访问。通过_YongGe__money可以间接访问私有属性__money 。但是一般不要用，就比如你爹告诉你剩100块了，要省点花，你非要点个海底捞一把梭哈！
总之，Python的私有属性机制主要基于命名约定，其作用是限制属性的可见性和访问性，从而提高代码的封装性和安全性。然而，需要注意的是，这种机制只是一种建议性的规范，并不能完全避免私有属性被访问的可能性。
2. 属性自省与对象内部状态查看
在实际开发中，我们经常需要查看对象的属性和方法，以便理解其内部状态。Python提供了几种属性自省的方法，使我们能够方便地检查对象的属性。
(1) 使用__dict__属性
__dict__是对象的一个属性，它包含了对象的所有属性和方法。通过访问__dict__，我们可以查看对象的内部状态。
例如，我们定义了一个名为Person的类，其中包含name和age两个属性，以及一个say_hello方法。下面的代码展示了如何通过访问__dict__来查看对象的属性和方法：
class YongeGe:
def __init__(self, name, money):
self.name = name
self.money= money
def money(self):
print(f"Hello, my name is {self.name}.I have {self.money} dollar ")
yongge = YongeGe("勇哥", "10")
yongge .money= "1010"
yongge .__dict__["age"] = "18"输出结果为：
{'name': '勇哥', 'money': '1010', 'age': '18'}我们可以看到对象yongge的属性和方法，包括name、age、money以及money方法。
需要注意的是，实例对象的__dict__属性只能访问和修改其自身的属性和方法，而无法访问其所属类的属性和方法。如果需要访问类的属性和方法，可以通过类的__dict__属性来实现。
例如，我们可以通过访问Person.__dict__来查看类Person的所有属性和方法：
print(yongge .__dict__)输出结果为：
{'__module__': '__main__', '__init__': <function YongeGe.__init__ at 0x0000017E50B9C5E0>, 'money': <function YongeGe.money at 0x0000017E50BBADC0>, '__dict__': <attribute '__dict__' of 'YongeGe' objects>, '__weakref__': <attribute '__weakref__' of 'YongeGe' objects>, '__doc__': None}上述输出结果中，除了__init__、say_hello和__dict__之外，还包括其他一些特殊属性和方法。通过查看类的__dict__，我们可以获取到类的所有成员。
(2) 使用dir()函数
除了访问对象的__dict__属性外，我们还可以使用dir()函数来查看对象的属性和方法。
dir()函数返回一个包含对象所有属性和方法名称的列表。它不仅可以用于普通对象，还可以用于模块、类和内置类型等。
例如，下面的代码展示了如何使用dir()函数查看对象的属性和方法：
print(dir(p1))输出结果为：
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__
str__', '__subclasshook__', '__weakref__', 'age', 'gender', 'hometown', 'name', 'say_hello']从输出结果中，我们可以看到对象p1的属性和方法的名称列表。
(3) 使用__slots__ 属性
在默认情况下，Python 类的实例会使用一个字典来存储它们的属性。这种方式对于属性很少的对象来说可能会浪费空间。特别是在创建大量实例时，这种空间消耗会变得更明显。
为了解决这个问题，我们可以通过在类定义中使用__slots__来覆盖默认的__dict__行为。slots__是一个特殊属性，它接受一个属性名称的序列，并且在每个实例中只为这些属性保留足够的空间来存储属性值。因为没有为每个实例创建__dict，所以可以节省空间。
class YongeGe:
# 定义 __slots__属性，让类实例只能绑定 __slots__中指定的属性，且不能添加其他属性
__slots__ = ('name', 'money')
def __init__(self, name_, money_):
self.name = name_
self.money = money_
if __name__ == '__main__':
yongge = YongeGe('勇哥', 100)
print(yongge.name)
setattr(yongge, 'new_attr', 100) # 输出：AttributeError: 'YongeGe' object has no attribute 'new_attr'从上面的代码可以看到，在类中绑定了__slots__后，会限制类实例的灵活性，不能动态添加新的属性，所以在使用这玩意的时候，要仔细想想要灵活还是要内存？
(4) 自定义属性访问
还可以通过定义一些特殊方法来自定义类实例的属性访问行为。这些特殊方法可以控制属性的获取、设置和删除操作。
- __getattribute__ 方法：获取一个属性时，Python 会首先调用该方法。我们可以在这个方法中自定义属性的获取行为。例如，可以在方法中检查属性是否存在，并返回相应的值。
def __getattribute__(self, data):
value = super().__getattribute__(data)
return value- setattr 方法：设置一个属性时，Python 会调用该方法。我们可以在这个方法中自定义属性的设置行为。例如，可以在方法中对属性进行类型检查，然后使用 super().setattr() 方法设置属性的值。
def __setattr__(self, key, value):
super().__setattr__(key, value)- __delattr__ 方法：删除一个属性时，Python 会调用该方法。我们可以在这个方法中自定义属性的删除行为。例如，可以在方法中执行一些清理操作或抛出异常。
def __delattr__(self, item):
super().__delattr__(item)- __getattr__ 方法：获取一个不存在的属性时，Python 会调用该方法。我们可以在这个方法中自定义对不存在属性的处理逻辑。例如，可以返回默认值或者抛出异常。
def __getattr__(self, item):
pass以上是一些常用的自定义属性访问的方法。瞧瞧下面语句的执行顺序：
class MyClass:
def __init__(self):
self._data = {}
def __getattribute__(self, name):
# 自定义获取属性的行为
if name == 'attribute1':
return 'Custom Value'
elif name == 'attribute2':
return self._data[name] # 注意，这里会继续执行一次 __getattribute__
else:
return super().__getattribute__(name)
def __setattr__(self, name, value):
# 自定义设置属性的行为
if name == 'attribute2':
print("__setattr__", name, value)
self._data[name] = value + 10
else:
super().__setattr__(name, value)
def __delattr__(self, name):
# 自定义删除属性的行为
if name == 'attribute3':
self._data.pop(name, None)
else:
super().__delattr__(name)
def __getattr__(self, name):
# 处理不存在的属性
return f'Attribute "{name}" does not exist.'
if __name__ == '__main__':
obj = MyClass()
obj.attribute2 = 5
res = obj.attribute2
print(res) # 输出: __setattr__ attribute2 5 ；15
print(obj.attribute1) # 输出: Custom Value
del obj.attribute3
print(obj.attribute3) # 输出: Attribute "attribute3" does not exist.在上面的示例中，我们创建了一个名为 MyClass 的类，其中定义了 __getattribute__、__setattr__、
__delattr__ 和 __getattr__ 四个方法来自定义属性访问行为。通过在这些方法中编写相应的逻辑，我们可以控制属性的获取、设置和删除操作，从而实现自定义的属性访问行为。
通过自定义属性访问，我们可以更灵活地控制类实例的属性操作，满足特定的需求，并增强代码的可读性和可维护性。
(5) 使用getattr()、setattr()和hasattr()函数
除了查看对象的属性和方法外，我们还可以使用getattr()、setattr()和hasattr()函数来动态地访问和修改对象的属性。
- getattr(obj, attr)函数用于获取对象obj的属性attr的值。
- setattr(obj, attr, value)函数用于设置对象obj的属性attr的值为value。
- hasattr(obj, attr)函数用于检查对象obj是否具有属性attr，如果有返回True，否则返回False。
这些函数提供了一种灵活的方式来操作对象的属性，特别适用于需要在运行时根据条件访问或修改属性的情况。
例如，我们可以通过调用getattr()函数来获取对象的属性值：
name_value = getattr(yongge, "name")
print(name_value)输出结果为：
勇哥上述代码中，我们使用getattr(yongge, "name")来获取对象p1的name属性的值。
类似地，我们可以使用setattr()函数来设置对象的属性值：
setattr(yongge, "age", 40)
print(yongge.age)输出结果为：
40上述代码中，我们使用setattr(yongge, "age", 40)将对象yongge的age属性值设置为30，然后再次打印yongge.age，可以看到属性值已被修改。
另外，我们还可以使用hasattr()函数来检查对象是否具有某个属性：
has_money = hasattr(yongge, "money")
print(has_money)输出结果为：
True使用hasattr(yongge, "money")检查对象yongge是否具有money属性，结果为True，说明对象具有该属性。
通过上述几种方法，我们可以方便地进行属性自省，查看和修改对象的属性，从而更好地理解和操作代码。
3. 来点实际场景
假设我们正在开发一个电商网站，需要处理用户购物车的相关逻辑。购物车中的商品信息以字典的形式存储在用户对象的属性中。我们需要编写一个函数，用于计算购物车中商品的总价值。
定义一个User类，包含一个cart属性用于存储购物车中的商品信息：
class User:
def __init__(self, name):
self.name = name
self.cart = {}
def add_to_cart(self, item, price):
self.cart[item] = price定义一个calculate_cart_value()函数，用于计算购物车中商品的总价值。在函数内部，我们可以通过属性自省来获取购物车中的商品信息，并计算总价值：
def calculate_cart_value(user):
cart = user.__dict__.get("cart", {})
total_value = sum(cart.values())
return total_value在上述代码中，我们使用user.__dict__.get("cart", {})来获取购物车信息，如果用户对象中不存在cart属性，则返回一个空字典。然后，我们使用sum(cart.values())来计算购物车中商品价格的总和。
下面是使用上述代码的示例：
# 创建用户对象
user = User("勇哥")
# 添加商品到购物车
user.add_to_cart("apple", 10)
user.add_to_cart("banana", 5)
user.add_to_cart("orange", 8)
# 计算购物车总价值
total_value = calculate_cart_value(user)
print(total_value) # 输出: 23通过使用属性自省，我们可以方便地访问购物车信息，并计算总价值。属性自省还是挺重要的，面试也问得多，实在不会用也要背好飞机大炮的制作流程。但是这个玩意也不要滥用哟，频繁动态访问，会有一定的性能开销哟~
