Python模块与类的高级定制：探索装饰器与工厂模式实现模板化

# my_module.py
propA = "value"
propB = "value"

def funA():
    pass

def funB():
    global propA, propB # 修改模块级变量需要使用global
    propA = "new_value"
    pass

import types

def all_decorated_with(decorator):
    """
    一个类装饰器工厂，用于将指定的装饰器应用于类中的所有可调用成员。
    """
    def _decorator(cls):
        for name, obj in vars(cls).items():
            # 检查对象是否为可调用（函数、方法等），并且不是特殊方法（如__init__）
            if callable(obj) and not (name.startswith('__') and name.endswith('__')):
                # 如果是函数，直接应用装饰器
                if isinstance(obj, (types.FunctionType, types.MethodType)):
                    setattr(cls, name, decorator(obj))
                # 如果是静态方法或类方法，需要特殊处理，因为它们本身就是装饰器应用后的结果
                # 这里为了简化，我们假设decorator可以直接作用于原始函数或已有的方法对象
                # 更健壮的实现可能需要检查并提取原始函数
                elif isinstance(obj, (staticmethod, classmethod)):
                    # 对于已是staticmethod或classmethod的，通常不再重复应用
                    # 如果需要替换其内部的函数，则需要更复杂的逻辑
                    pass # 示例中不再对已装饰的进行处理
        return cls
    return _decorator

# 示例应用：将所有方法转换为类方法
@all_decorated_with(classmethod)
class Foo:
    a = None # 类属性

    def set(cls, value):
        """将类属性a设置为给定值。"""
        cls.a = value

    def get(cls):
        """获取类属性a的值。"""
        return cls.a

# 使用转换后的类方法
Foo.set(1)
print(f"Foo.a 的当前值: {Foo.get()}") # 输出: Foo.a 的当前值: 1

# 创建另一个实例，验证类属性共享
Foo.set(2)
print(f"Foo.a 的新值: {Foo.get()}") # 输出: Foo.a 的新值: 2

def foo_factory(v):
    """
    一个类工厂函数，根据传入的参数v动态创建并返回一个新类。
    """
    class _Foo:
        # 类属性a的值由工厂函数参数v决定
        a = v

        def __init__(self, name):
            self.name = name

        def get_value(self):
            return self.a

        def get_name(self):
            return self.name

    return _Foo

# 使用工厂函数创建两个不同的类
Foo1 = foo_factory(1)
Foo2 = foo_factory(2)

# 验证不同类实例的类属性值
print(f"Foo1.a 的值: {Foo1.a}") # 输出: Foo1.a 的值: 1
print(f"Foo2.a 的值: {Foo2.a}") # 输出: Foo2.a 的值: 2

# 也可以创建这些类的实例
instance1 = Foo1("Instance One")
instance2 = Foo2("Instance Two")

print(f"实例1的值: {instance1.get_value()}, 名字: {instance1.get_name()}")
print(f"实例2的值: {instance2.get_value()}, 名字: {instance2.get_name()}")

def create_table_dao(table_name):
    """
    创建一个数据访问对象（DAO）类，用于特定表的SQL操作。
    """
    class TableDAO:
        def __init__(self, db_connection):
            self.conn = db_connection
            self.table = table_name

        def insert(self, data):
            # 示例：生成插入SQL语句
            columns = ', '.join(data.keys())
            placeholders = ', '.join(['%s'] * len(data))
            sql = f"INSERT INTO {self.table} ({columns}) VALUES ({placeholders})"
            print(f"Executing: {sql} with {list(data.values())}")
            # self.conn.execute(sql, list(data.values()))

        def select_all(self):
            # 示例：生成查询所有记录的SQL语句
            sql = f"SELECT * FROM {self.table}"
            print(f"Executing: {sql}")
            # cursor = self.conn.cursor()
            # cursor.execute(sql)
            # return cursor.fetchall()

        def update(self, condition, new_data):
            # 示例：生成更新SQL语句
            set_clause = ', '.join([f"{k} = %s" for k in new_data.keys()])
            sql = f"UPDATE {self.table} SET {set_clause} WHERE {condition}"
            print(f"Executing: {sql} with {list(new_data.values())}")
            # self.conn.execute(sql, list(new_data.values()))

    return TableDAO

# 为不同的表创建特定的DAO类
UsersDAO = create_table_dao("users")
ProductsDAO = create_table_dao("products")

# 使用这些DAO类
# 假设有一个数据库连接对象 db_conn
# db_conn = ...

users_dao = UsersDAO(None) # 实际应传入数据库连接
users_dao.insert({"name": "Alice", "email": "alice@example.com"})
users_dao.select_all()

products_dao = ProductsDAO(None) # 实际应传入数据库连接
products_dao.insert({"item": "Laptop", "price": 1200})
products_dao.select_all()