反射和元编程是Python中两种强大且高级的编程技术。反射允许程序在运行时检查和修改自身结构和行为，而元编程则是编写可以操作其他代码的代码，通常通过使用元类、装饰器等技术来实现。

1. 反射

反射是指程序在运行时检查和操作自身结构的能力。Python通过内置的inspect模块以及一些内置函数提供了反射功能。

1.1 type()和id()

这两个函数用于获取对象的类型和唯一标识。

a = 42
print(type(a))  # <class 'int'>
print(id(a))    # 140731011254336

1.2 getattr(), setattr(), hasattr(), delattr()

这些函数允许动态获取、设置、检查和删除对象的属性。

class MyClass:
    def __init__(self):
        self.value = 42

obj = MyClass()

# 获取属性
print(getattr(obj, 'value'))  # 42

# 设置属性
setattr(obj, 'value', 100)
print(obj.value)  # 100

# 检查属性
print(hasattr(obj, 'value'))  # True

# 删除属性
delattr(obj, 'value')
print(hasattr(obj, 'value'))  # False

1.3 dir()

dir()函数用于列出对象的所有属性和方法。

print(dir(obj))  # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', ...]

1.4 inspect模块

inspect模块提供了更为详细的反射功能。

import inspect

def my_function():
    pass

# 检查对象是否为函数
print(inspect.isfunction(my_function))  # True

# 获取函数的源代码
print(inspect.getsource(my_function))  # 'def my_function():\n    pass\n'

2. 元编程

元编程是指编写可以操作其他代码的代码。Python中的元编程主要包括元类、装饰器和类装饰器等技术。

2.1 元类

元类是用来创建类的类。通过自定义元类，我们可以在类创建时动态地修改类的行为。

# 自定义元类
class MyMeta(type):
    def __new__(cls, name, bases, dct):
        print(f'Creating class {name}')
        return super().__new__(cls, name, bases, dct)

# 使用元类创建类
class MyClass(metaclass=MyMeta):
    def __init__(self):
        self.value = 42

# 创建对象
obj = MyClass()  # 输出：Creating class MyClass

元类的主要方法包括：

• __new__：控制类的创建过程。
• __init__：初始化类。

2.2 装饰器

装饰器是修改函数或方法行为的函数。它们通常用于日志记录、权限检查、性能计数等。

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print('Before function call')
        result = func(*args, **kwargs)
        print('After function call')
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f'Hello, {name}!')

say_hello('World')  # 输出：Before function call, Hello, World!, After function call

2.3 类装饰器

类装饰器是修改类行为的函数。

def my_class_decorator(cls):
    class Wrapped(cls):
        def new_method(self):
            return 'This is a new method'
    return Wrapped

@my_class_decorator
class MyClass:
    def __init__(self):
        self.value = 42

obj = MyClass()
print(obj.new_method())  # 输出：This is a new method

3. 综合实例

我们将通过一个综合实例来演示反射和元编程的结合使用。假设我们需要一个记录日志的功能，当调用类的方法时，自动记录调用信息。

3.1 定义元类

首先，我们定义一个元类，在创建类时为每个方法添加日志记录功能。

class LoggingMeta(type):
    def __new__(cls, name, bases, dct):
        for key, value in dct.items():
            if callable(value):
                dct[key] = cls.log_decorator(value)
        return super().__new__(cls, name, bases, dct)

    @staticmethod
    def log_decorator(func):
        def wrapper(*args, **kwargs):
            print(f'Calling {func.__name__} with args: {args}, kwargs: {kwargs}')
            return func(*args, **kwargs)
        return wrapper

3.2 定义使用元类的类

接着，我们定义一个类使用LoggingMeta元类。

class MyClass(metaclass=LoggingMeta):
    def method1(self, x):
        return x * 2

    def method2(self, y):
        return y + 100

# 创建对象并调用方法
obj = MyClass()
print(obj.method1(10))  # 输出：Calling method1 with args: (<__main__.MyClass object at 0x000001>, 10)
                        #        20
print(obj.method2(20))  # 输出：Calling method2 with args: (<__main__.MyClass object at 0x000001>, 20)
                        #        120

4. 更进一步的元编程

元编程不仅限于上述的元类和装饰器，还包括创建DSL（领域特定语言）、AST（抽象语法树）操作等更高级的技术。

4.1 创建DSL

通过Python的灵活性，我们可以创建小型的DSL，用于特定的任务。例如，创建一个简单的计算器DSL：

class Calculator:
    def __init__(self):
        self.value = 0

    def add(self, x):
        self.value += x
        return self

    def subtract(self, x):
        self.value -= x
        return self

    def multiply(self, x):
        self.value *= x
        return self

    def divide(self, x):
        if x != 0:
            self.value /= x
        return self

    def result(self):
        return self.value

# 使用DSL
calc = Calculator()
result = calc.add(5).multiply(2).subtract(3).divide(4).result()
print(result)  # 输出：2.0

4.2 操作AST

Python的ast模块允许我们操作Python代码的抽象语法树，从而动态地生成和修改代码。

import ast

# 解析Python代码为AST
code = "a = 1 + 2"
tree = ast.parse(code, mode='exec')

# 遍历AST节点
class CodeTransformer(ast.NodeTransformer):
    def visit_BinOp(self, node):
        if isinstance(node.op, ast.Add):
            node.op = ast.Sub()
        return node

transformer = CodeTransformer()
new_tree = transformer.visit(tree)

# 将AST转回Python代码
new_code = compile(new_tree, filename="<ast>", mode="exec")
exec(new_code)
print(a)  # 输出：-1

反射和元编程是Python中强大且灵活的编程技术。通过反射，我们可以动态地检查和操作对象；通过元编程，可以编写能够修改和生成代码的代码。这些技术不仅增强了代码的灵活性和可重用性，还为创建DSL和操作AST等高级应用提供了可能性。在实际开发中，合理使用这些技术可以极大地提升程序的扩展性和维护性。