Python 内置函数系列:v开头系列函数

vars()：对象属性的"字典视图"

1. 基础用法：获取对象的属性字典

vars()函数返回对象的__dict__属性，提供了对对象内部属性的字典式访问。

# 创建简单类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 创建实例
person = Person("张三", 25)

# 使用vars()获取属性字典
attributes = vars(person)
print(f"对象属性字典: {attributes}")  # 输出: {'name': '张三', 'age': 25}

# 修改属性字典会影响原对象
attributes['age'] = 30
print(f"修改后年龄: {person.age}")  # 输出: 30

# 添加新属性
attributes['city'] = '北京'
print(f"新属性城市: {person.city}")  # 输出: 北京

# 直接访问__dict__属性
print(f"直接访问: {person.__dict__}")  # 与vars()相同

2. 无参数调用：类似locals()的行为

def demonstrate_vars():
    """演示函数内无参数调用vars()"""
    x = 10
    y = 20
    z = "hello"

    # 无参数调用，类似locals()
    local_vars = vars()  # 等同于 locals()
    print(f"局部变量: {local_vars}")

    # 动态添加变量
    local_vars['new_var'] = "动态添加"
    print(f"新变量: {new_var}")  # 可以访问

    return local_vars

# 函数调用
result = demonstrate_vars()
print(f"函数返回的变量: {result}")

# 模块级别的vars()
import math
module_vars = vars(math)
print(f"math模块的部分属性: {list(module_vars.keys())[:5]}")

实际应用：动态属性管理和调试

1. 属性序列化和配置管理

class ConfigObject:
    """使用vars()进行配置管理"""
    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

    def to_dict(self):
        """转换为字典（使用vars()）"""
        return dict(vars(self))

    def update_from_dict(self, config_dict):
        """从字典更新配置"""
        for key, value in config_dict.items():
            setattr(self, key, value)

    def filter_attributes(self, prefix=None):
        """过滤特定前缀的属性"""
        all_attrs = vars(self)
        if prefix:
            return {k: v for k, v in all_attrs.items() if k.startswith(prefix)}
        return all_attrs

    def __repr__(self):
        """使用vars()生成表示字符串"""
        attrs = ', '.join(f"{k}={v!r}" for k, v in vars(self).items())
        return f"{self.__class__.__name__}({attrs})"

# 使用示例
config = ConfigObject(debug=True, host="localhost", port=8080, log_level="INFO")
print(f"配置对象: {config}")

# 转换为字典
config_dict = config.to_dict()
print(f"配置字典: {config_dict}")

# 过滤属性
debug_attrs = config.filter_attributes('debug')
print(f"调试相关属性: {debug_attrs}")

# 动态更新
config.update_from_dict({'timeout': 30, 'max_connections': 100})
print(f"更新后配置: {config}")

2. 高级调试和对象检查

class ObjectInspector:
    """使用vars()进行对象检查"""

    @staticmethod
    def inspect_object(obj, include_private=False):
        """检查对象的所有属性"""
        try:
            obj_vars = vars(obj)
        except TypeError:
            return "该对象没有__dict__属性（可能使用了__slots__）"

        inspection = {
            'type': type(obj).__name__,
            'module': getattr(obj, '__module__', 'Unknown'),
            'attributes': {}
        }

        for attr_name, attr_value in obj_vars.items():
            # 过滤私有属性
            if not include_private and attr_name.startswith('_'):
                continue

            inspection['attributes'][attr_name] = {
                'value': attr_value,
                'type': type(attr_value).__name__,
                'id': id(attr_value)
            }

        return inspection

    @staticmethod
    def compare_objects(obj1, obj2):
        """比较两个对象的属性差异"""
        try:
            vars1 = vars(obj1)
            vars2 = vars(obj2)
        except TypeError as e:
            return f"比较失败: {e}"

        common_keys = set(vars1.keys()) & set(vars2.keys())
        unique_to_obj1 = set(vars1.keys()) - set(vars2.keys())
        unique_to_obj2 = set(vars2.keys()) - set(vars1.keys())

        differences = {}
        for key in common_keys:
            if vars1[key] != vars2[key]:
                differences[key] = {
                    'obj1_value': vars1[key],
                    'obj2_value': vars2[key]
                }

        return {
            'common_attributes': list(common_keys),
            'unique_to_obj1': list(unique_to_obj1),
            'unique_to_obj2': list(unique_to_obj2),
            'value_differences': differences
        }

    @staticmethod
    def create_snapshot(obj):
        """创建对象状态快照"""
        try:
            return {
                'timestamp': __import__('time').time(),
                'vars': dict(vars(obj)),
                'type': type(obj).__name__
            }
        except TypeError:
            return None

# 使用示例
inspector = ObjectInspector()

# 创建测试对象
class TestClass:
    def __init__(self):
        self.public_attr = "公开属性"
        self._protected_attr = "受保护属性"
        self.__private_attr = "私有属性"
        self.value = 42

test_obj = TestClass()

# 对象检查
inspection = inspector.inspect_object(test_obj)
print("对象检查结果:")
for key, value in inspection.items():
    print(f"  {key}: {value}")

# 包含私有属性的检查
full_inspection = inspector.inspect_object(test_obj, include_private=True)
print(f"包含私有属性的属性数量: {len(full_inspection['attributes'])}")

# 对象比较
obj1 = TestClass()
obj2 = TestClass()
obj2.value = 100  # 修改一个属性

comparison = inspector.compare_objects(obj1, obj2)
print("对象比较结果:")
for key, value in comparison.items():
    print(f"  {key}: {value}")

总结

本文的详细解析了Python中重要的内置函数vars()：

核心功能总结：

• • vars([object])返回对象的__dict__属性
• • 无参数调用时，在Python 3.13+中与locals()行为类似
• • 提供对对象内部属性的字典式访问和修改

关键特性：

• • 支持模块、类实例等有__dict__属性的对象
• • 对于使用__slots__的类会抛出TypeError
• • 返回的字典是实时的，修改会影响原对象
• • 是Python自省和元编程的重要工具

实用场景推荐：

• • 调试分析：快速查看对象的所有属性
• • 动态编程：运行时检查和修改对象结构
• • 序列化准备：获取可序列化的属性字典
• • 配置管理：统一管理对象配置属性
• • 测试验证：验证对象状态和属性值

vars()函数虽然简单，但它是理解Python对象模型和进行高级编程的重要工具。从简单的调试到复杂的元编程，掌握vars()能够帮助你更深入地理解Python的面向对象特性，编写出更加强大和灵活的程序。