Python 内置函数：enumerate()、eval()和 exec()

二、eval()：动态表达式求值的"计算器"

2.1 基础用法：执行字符串表达式

eval() 函数用于执行一个字符串表达式，并返回表达式的值。可以指定全局和局部命名空间来控制执行环境。

# 基本数学表达式
x = 1
result = eval('x + 1')
print(f"eval('x + 1') = {result}")
# 输出：2

# 使用自定义命名空间
globals_dict = {'x': 10, 'y': 20}
locals_dict = {'z': 30}
result = eval('x + y + z', globals_dict, locals_dict)
print(f"自定义命名空间：{result}")
# 输出：60

# 安全警告：避免执行用户输入
# eval("__import__('os').system('rm -rf /')") # 危险操作！

2.2 实际应用：配置解析和动态计算

class ExpressionEvaluator:
    def __init__(self):
        self.safe_globals = {'__builtins__': {}, 'abs': abs, 'max': max, 'min': min, 'sum': sum}

    def safe_eval(self, expression, variables=None):
        """安全求值，限制可用函数"""
        if variables:
            env = self.safe_globals.copy()
            env.update(variables)
        else:
            env = self.safe_globals
        try:
            return eval(expression, env)
        except Exception as e:
            return f"错误：{e}"

    def calculate_from_config(self, config_str, values):
        """从配置字符串计算值"""
        try:
            return eval(config_str, {'values': values})
        except:
            return None

# 使用示例
evaluator = ExpressionEvaluator()
# 安全求值
print(f"安全计算：{evaluator.safe_eval('2 * 3 + 4')}")
print(f"带变量计算：{evaluator.safe_eval('a + b', {'a': 5, 'b': 3})}")

# 配置解析
config = "sum(values) / len(values)"
result = evaluator.calculate_from_config(config, [1, 2, 3, 4, 5])
print(f"配置计算结果：{result}")

三、exec()：动态代码执行的"解释器"

3.1 基础用法：执行 Python 代码块

exec() 函数用于动态执行 Python 代码（字符串或代码对象），适合执行语句而非表达式。返回值始终为 None。

# 执行简单代码
exec('x = 10; y = 20; z = x + y')
print(f"执行后 z = {z}")
# 输出：30

# 使用命名空间控制执行环境
my_globals = {}
my_locals = {}
exec('''
def greet(name):
    return f"Hello, {name}!"
result = greet("World")
''', my_globals, my_locals)
print(f"函数执行：{my_locals['result']}")
# 输出：Hello, World!

# 安全警告：exec() 可执行任意代码，需谨慎使用

3.2 实际应用：动态模块加载和插件系统

class DynamicCodeManager:
    def __init__(self):
        self.environment = {'__builtins__': {}}

    def execute_safely(self, code_string, allowed_globals=None):
        """安全执行代码，限制访问"""
        env = self.environment.copy()
        if allowed_globals:
            env.update(allowed_globals)
        try:
            exec(code_string, env)
            return env
        except Exception as e:
            print(f"执行错误：{e}")
            return None

    def create_dynamic_class(self, class_code):
        """动态创建类"""
        env = {}
        exec(class_code, env)
        # 返回第一个定义的类
        for obj in env.values():
            if isinstance(obj, type) and obj.__module__ == '__main__':
                return obj
        return None

# 使用示例
manager = DynamicCodeManager()
# 动态创建函数
code = '''
def calculate_area(radius):
    return 3.14159 * radius ** 2
area = calculate_area(5)
'''
result_env = manager.execute_safely(code)
if result_env:
    print(f"动态函数结果：{result_env.get('area')}")

# 动态创建类
class_code = '''
class DynamicCalculator:
    def add(self, a, b):
        return a + b
    def multiply(self, a, b):
        return a * b
'''
dynamic_class = manager.create_dynamic_class(class_code)
if dynamic_class:
    calc = dynamic_class()
    print(f"动态类方法：{calc.add(2, 3)}")

四、高级技巧与最佳实践

4.1 安全使用 eval() 和 exec()

class SecureEvaluator:
    def __init__(self):
        self.allowed_functions = {'abs': abs, 'len': len, 'max': max, 'min': min, 'round': round, 'sum': sum}
        self.safe_globals = {'__builtins__': None, **self.allowed_functions}

    def ultra_safe_eval(self, expression, variables=None):
        """超安全求值，仅允许白名单函数"""
        env = self.safe_globals.copy()
        if variables:
            env.update(variables)
        try:
            return eval(expression, env)
        except Exception as e:
            return f"安全错误：{e}"

    def validate_code(self, code_string):
        """简单代码验证"""
        forbidden = ['import', 'os.', 'sys.', '__', 'open(']
        return not any(keyword in code_string for keyword in forbidden)

# 使用示例
secure_eval = SecureEvaluator()
print(f"安全计算：{secure_eval.ultra_safe_eval('abs(-5)')}")
print(f"代码验证：{secure_eval.validate_code('import os')}")
# False

4.2 组合使用枚举和求值

def analyze_data_structure(data):
    """综合分析数据结构"""
    analysis = {}
    # 使用 enumerate 获取索引信息
    if isinstance(data, (list, tuple)):
        analysis['indexed_items'] = list(enumerate(data))
        analysis['length'] = len(data)
    # 使用 eval 动态分析（安全范围内）
    safe_globals = {'data': data, 'len': len}
    try:
        analysis['size_info'] = eval('len(data)', safe_globals)
    except:
        analysis['size_info'] = '无法计算'
    return analysis

# 测试
sample_data = ['a', 'b', 'c']
result = analyze_data_structure(sample_data)
print(f"分析结果：{result}")

五、总结与实用建议

通过整理，我们系统了解了三个重要的内置函数：

1. enumerate() - 迭代计数的索引器
2. eval() - 动态表达式求值的计算器
3. exec() - 动态代码执行的解释器

关键知识点总结：

• enumerate(iterable, start=0) 返回 (索引，元素) 元组序列
• eval(expression) 执行表达式并返回值，exec(code) 执行代码块返回 None
• 两者都支持全局和局部命名空间参数

安全使用建议：

1. 绝对避免直接执行用户输入：eval() 和 exec() 可执行任意代码，存在安全风险
2. 使用限制环境：通过自定义 globals 参数控制可访问的函数和变量
3. 优先考虑替代方案：如 ast.literal_eval() 用于安全求值字面量
4. 明确需求区别：表达式求值用 eval()，代码块执行用 exec()

实用场景推荐：

• enumerate()：遍历需要索引的场景（如日志记录、批量处理）
• eval()：数学表达式计算、简单配置解析
• exec()：插件系统、动态代码生成

进阶学习方向：

• 深入学习 Python 的 ast 模块进行代码分析
• 研究命名空间和作用域的工作原理
• 了解代码对象（code object）和编译过程