Python迭代器单次遍历特性及其在多进程编程中的影响

x = (0, 1, 2)
y = "ABC"
zipper = zip(x, y)

print(f"原始zipper对象: {zipper}") # 输出: <zip object at ...>

# 第一次遍历：通过list()函数完全消费迭代器
first_pass_list = list(zipper)
print(f"第一次遍历（通过list()）后的结果: {first_pass_list}") # 输出: [(0, 'A'), (1, 'B'), (2, 'C')]

# 尝试第二次遍历：迭代器已耗尽
second_pass_list = list(zipper)
print(f"第二次遍历后的结果: {second_pass_list}") # 输出: [] (空列表)

# 尝试通过for循环遍历一个已耗尽的迭代器
print("尝试通过for循环遍历已耗尽的zipper:")
for n, s in zipper:
    print(n, s) # 不会输出任何内容

from itertools import repeat
import multiprocessing

# 辅助函数：将args和kwargs应用于目标函数
def apply_args_and_kwargs(fn, args, kwargs):
    return fn(*args, **kwargs)

# 实际执行任务的函数，存在潜在的TypeError
def func(path, dictArg, **kwargs):
    # 这里的循环和索引访问方式会导致TypeError
    # 因为dictArg是字典，for i in dictArg会遍历其键（字符串）
    # 随后 i['a'] 尝试对字符串进行字符串索引，导致TypeError
    for i in dictArg:
        print(i['a']) # TypeError: string indices must be integers
        print(kwargs['yes'])

# 包装函数，设置并启动多进程任务
def funcWrapper(path, dictList, **kwargs):
    args_iter = zip(repeat(path), dictList)
    kwargs_iter = repeat(kwargs)

    # 关键行：如果取消注释，args_iter将被提前耗尽
    # list(args_iter) 

    pool = multiprocessing.Pool()
    # 为starmap准备参数：(func, args, kwargs)
    args_for_starmap = zip(repeat(func), args_iter, kwargs_iter)
    pool.starmap(apply_args_and_kwargs, args_for_starmap)
    pool.close()
    pool.join()

# 测试数据
dictList = [{'a: 2'}, {'a': 65}, {'a': 213}, {'a': 3218}] # 注意：这些是字典，键是'a: 2'等
path = 'some/path/to/something'

print("--- 场景一：不提前耗尽迭代器 ---")
try:
    funcWrapper(path, dictList, yes=1)
except TypeError as e:
    print(f"捕获到预期TypeError: {e}")
# 预期输出类似：
# TypeError: string indices must be integers
# ... (追溯信息)

print("\n--- 场景二：提前耗尽迭代器 ---")
# 重新准备数据，确保迭代器是新的
dictList_case2 = [{'a: 2'}, {'a': 65}, {'a': 213}, {'a: 3218}]
path_case2 = 'some/path/to/something'

# 模拟用户在调用funcWrapper前，意外地耗尽了迭代器
temp_args_iter = zip(repeat(path_case2), dictList_case2)
_ = list(temp_args_iter) # 这一行将temp_args_iter完全耗尽
print("temp_args_iter 已被 list() 调用耗尽。")

# 现在调用funcWrapper，即使内部会重新创建zip，但由于dictList_case2是可迭代的，
# 这里的模拟方式需要更精确。更直接的模拟是修改funcWrapper，让它接收一个已耗尽的迭代器。