深入解析Python中delattr函数的使用方法和应用场景

class User:
    def __init__(self, name, email, temp_token):
        self.name = name
        self.email = email
        self.temp_token = temp_token

user = User("Alice", "alice@example.com", "x192838")

# 基础删除操作
delattr(user, 'temp_token')
print(hasattr(user, 'temp_token'))  # 输出: False

class UserResponse:
    def __init__(self, uid, name, password_hash, ssn, salary):
        self.uid = uid
        self.name = name
        self.password_hash = password_hash
        self.ssn = ssn  # 社保号
        self.salary = salary # 薪资

    def get_cleaned_data(self, role):
        """
        根据角色动态清理属性
        """
        # 定义不同角色的权限映射
        restrictions = {
            'guest': ['name', 'password_hash', 'ssn', 'salary'],
            'user': ['password_hash', 'ssn', 'salary'],
            'admin': [] # 管理员无限制
        }
        
        # 获取需要删除的属性列表
        # 如果角色不存在，默认限制所有敏感信息
        fields_to_remove = restrictions.get(role, ['password_hash', 'ssn', 'salary'])
        
        # 核心逻辑：利用 delattr 进行动态删除
        for field in fields_to_remove:
            # 必须先检查属性是否存在，防止报错
            if hasattr(self, field):
                delattr(self, field)
        
        # 转换为字典返回
        return self.__dict__

# 测试
user = UserResponse(1, "Bob", "hashed_123", "123-45-6789", 50000)

print("Guest View:", user.get_cleaned_data('guest'))
# 重置对象（因为原对象属性已被删）
user = UserResponse(1, "Bob", "hashed_123", "123-45-6789", 50000)
print("Admin View:", user.get_cleaned_data('admin'))

class DataProcessor:
    def __init__(self, raw_data):
        self.raw_data = raw_data  # 假设这是一个占用 1GB 的巨大列表
        self.is_processed = False

    def extract_features(self):
        print("开始特征提取...")
        # 模拟特征提取逻辑
        self.features = [x * 2 for x in self.raw_data]
        self.is_processed = True
        print("特征提取完成。")

    def cleanup(self):
        """
        条件判断：仅在处理完成后，且不再需要原始数据时进行清理
        """
        if self.is_processed and hasattr(self, 'raw_data'):
            print("正在释放原始数据内存...")
            delattr(self, 'raw_data')
        elif not self.is_processed:
            print("警告：尚未处理完成，不能清理原始数据。")
        else:
            print("原始数据已清理或不存在。")

# 模拟使用
processor = DataProcessor(list(range(1000000))) # 模拟大对象
processor.extract_features()
processor.cleanup() # 成功清理
processor.cleanup() # 重复清理提示

def create_model_class(class_name, allow_delete=False):
    # 基础属性
    attrs = {
        'id': None,
        'save': lambda self: print(f"保存 {class_name} 实例..."),
        '__init__': lambda self, id: setattr(self, 'id', id)
    }

    # 条件判断：动态添加或移除 delete 方法
    if allow_delete:
        attrs['delete'] = lambda self: print(f"删除 {class_name} 实例...")
    
    # 使用 type 动态创建类
    ModelClass = type(class_name, (object,), attrs)
    
    # 如果不允许删除，我们甚至可以从类定义中物理移除该方法（虽然上面的逻辑已经不添加了）
    # 但假设我们是先定义好了一个通用类，现在需要根据参数“阉割”它：
    if not allow_delete:
        # 这里的 delattr 作用于类本身，而不是实例
        if hasattr(ModelClass, 'delete'):
            delattr(ModelClass, 'delete')
            
    return ModelClass

# 创建一个不允许删除的模型
ReadOnlyUser = create_model_class('ReadOnlyUser', allow_delete=False)
user_instance = ReadOnlyUser(1)
user_instance.save()
try:
    user_instance.delete()
except AttributeError as e:
    print(f"错误: {e}") # 报错，因为方法不存在

print("-" * 20)

# 创建一个允许删除的模型
FullAccessUser = create_model_class('FullAccessUser', allow_delete=True)
admin_instance = FullAccessUser(99)
admin_instance.delete()

# 不推荐
try:
    delattr(obj, 'maybe_exists')
except AttributeError:
    pass

# 推荐
if hasattr(obj, 'maybe_exists'):
    delattr(obj, 'maybe_exists')

obj = "Hello"
# delattr(obj, '__class__') # 这可能会导致解释器崩溃或严重错误

class SlotClass:
    __slots__ = ['a']

s = SlotClass()
s.a = 10
delattr(s, 'a') # 正常工作
# print(s.a) # 抛出 AttributeError
s.a = 20 # 依然可以重新赋值