系统介绍了 Python 内置函数 enumerate()、eval() 和 exec() 的基础用法与实际应用。enumerate() 用于遍历获取索引与值；eval() 执行字符串表达式并返回值；exec() 执行代码块语句。文章提供了数据处理、配置解析、动态模块加载等场景的代码示例，并重点强调了 eval() 和 exec() 的安全风险，建议使用受限命名空间、白名单函数或 ast.literal_eval 等替代方案以确保安全。
enumerate() 函数用于将一个可迭代对象（如列表、元组等）组合为一个索引序列，同时返回索引和对应的元素值。默认计数从 0 开始，但可通过 start 参数自定义起始值。
# 基本示例
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
# 输出：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
# 自定义起始值
print(list(enumerate(seasons, start=1)))
# 输出：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
# 等价于手动实现
def enumerate(iterable, start=0):
n = start
for elem in iterable:
yield n, elem
n += 1
class DataProcessor:
@staticmethod
def process_with_index(data_list):
"""带索引处理数据"""
processed = []
for index, value in enumerate(data_list, start=1):
processed.append(f"{index}: {value.upper()}")
return processed
@staticmethod
def find_element_positions(data, target):
"""查找元素所有出现的位置"""
positions = [index for index, value in enumerate(data) if value == target]
return positions
@staticmethod
def batch_processing(items, batch_size=3):
"""分批次处理数据并标记批次号"""
batches = []
for batch_num, i in enumerate(range(0, len(items), batch_size)):
batch = items[i:i + batch_size]
batches.append((batch_num + 1, batch))
return batches
# 使用示例
processor = DataProcessor()
# 处理数据带索引
data = ['apple', 'banana', 'cherry']
result = processor.process_with_index(data)
print(f"带索引处理：{result}")
# 查找元素位置
positions = processor.find_element_positions(['a', 'b', 'a', 'c'], 'a')
print(f"元素位置：{positions}")
# 分批次处理
items = list(range(10))
batches = processor.batch_processing(items, batch_size=3)
print(f"分批次：{batches}")
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 /')") # 危险操作！
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() 函数用于动态执行 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() 可执行任意代码，需谨慎使用
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)}")
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
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}")
通过整理，我们系统了解了三个重要的内置函数：
关键知识点总结：
enumerate(iterable, start=0) 返回 (索引，元素) 元组序列eval(expression) 执行表达式并返回值，exec(code) 执行代码块返回 None安全使用建议：
实用场景推荐：
进阶学习方向：
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online