深入理解Python中的range()函数用法、原理与实战指南

# 基本示例
print("range()函数生成序列的基本用法：")
# 创建一个range对象
r = range(5)
print(f"range(5) = {r}")
print(f"类型: {type(r)}")
# 转换为列表查看具体值
print(f"转换为列表: {list(r)}")
print(f"转换为元组: {tuple(r)}")

print("range()函数的三种调用形式：")
# 1. 一个参数：range(stop)
print("\n1. range(stop)形式：")
r1 = range(5)
print(f"range(5) = {list(r1)}")  # 0, 1, 2, 3, 4
# 2. 两个参数：range(start, stop)
print("\n2. range(start, stop)形式：")
r2 = range(2, 7)
print(f"range(2, 7) = {list(r2)}")  # 2, 3, 4, 5, 6
# 3. 三个参数：range(start, stop, step)
print("\n3. range(start, stop, step)形式：")
r3 = range(1, 10, 2)
print(f"range(1, 10, 2) = {list(r3)}")  # 1, 3, 5, 7, 9
# 负步长示例
r4 = range(10, 0, -2)
print(f"range(10, 0, -2) = {list(r4)}")  # 10, 8, 6, 4, 2

def explain_range(start, stop=none, step=1):
    """详细解释range函数的参数"""
    if stop is none:
        stop = start
        start = 0
    print(f"\nrange({start}, {stop}, {step}):")
    print(f"起点(start): {start}")
    print(f"终点(stop): {stop} (不包含)")
    print(f"步长(step): {step}")
    if step == 0:
        print("错误：步长不能为0")
        return
    # 计算序列长度
    if (step > 0 and start >= stop) or (step < 0 and start <= stop):
        length = 0
    else:
        length = (stop - start + step - (1 if step > 0 else -1)) // step
    print(f"序列长度: {length}")
    print(f"生成的数字序列: {list(range(start, stop, step))}")
    # 显示数学公式
    if length > 0:
        print(f"数学表示: {{start + i * step | i = 0, 1, ..., {length-1}}}")
        print(f"具体元素: {[start + i * step for i in range(length)]}")
# 演示不同参数组合
print("range()函数参数详解：")
explain_range(5)            # range(5)
explain_range(2, 8)         # range(2, 8)
explain_range(2, 8, 2)      # range(2, 8, 2)
explain_range(10, 0, -1)    # range(10, 0, -1)
explain_range(0, -10, -2)   # range(0, -10, -2)
explain_range(1, 1)         # range(1, 1) - 空序列

print("range()函数的边界条件和特殊情况：")
# 1. 空序列
print("\n1. 空序列情况：")
empty_cases = [
    range(0),          # range(0, 0)
    range(5, 5),       # start == stop
    range(5, 1),       # start > stop, step=1
    range(1, 10, -1),  # step为负但start < stop
]
for i, r in enumerate(empty_cases, 1):
    print(f"  情况{i}: {r} -> 列表: {list(r)}")
# 2. 负步长
print("\n2. 负步长情况：")
negative_step_cases = [
    range(10, 0, -1),
    range(5, -5, -2),
    range(0, -10, -3),
]
for i, r in enumerate(negative_step_cases, 1):
    print(f"  情况{i}: {r} -> 列表: {list(r)}")
# 3. 小数参数（会被截断）
print("\n3. 小数参数情况（自动转换为整数）：")
float_cases = [
    range(int(3.14)),      # 3
    range(1, int(5.9)),    # 1到5
    range(0, int(7.2), 2), # 0到7，步长2
]
for i, r in enumerate(float_cases, 1):
    print(f"  情况{i}: {r} -> 列表: {list(r)}")
# 4. 大数字范围
print("\n4. 大数字范围：")
big_range = range(10**6, 10**6 + 10)
print(f"  range(1,000,000, 1,000,010) 前5个元素: {[next(iter(big_range)) for _ in range(5)]}")
print(f"  占用内存大小: {big_range.__sizeof__()} 字节")

print("range()在for循环中的基本应用：")
# 1. 遍历固定次数
print("\n1. 遍历固定次数：")
for i in range(5):
    print(f"  第{i}次循环")
# 2. 遍历特定范围
print("\n2. 遍历特定范围：")
start = 3
end = 8
for i in range(start, end):
    print(f"  当前值: {i}, 平方: {i**2}")
# 3. 带步长的遍历
print("\n3. 带步长的遍历（打印偶数）：")
for i in range(0, 11, 2):
    print(f"  偶数: {i}")
# 4. 反向遍历
print("\n4. 反向遍历：")
for i in range(10, 0, -1):
    print(f"  倒计时: {i}")
print("  发射！")
# 5. 结合enumerate的替代方案
print("\n5. 模拟enumerate功能：")
fruits = ['apple', 'banana', 'cherry', 'date']
for i in range(len(fruits)):
    print(f"  索引{i}: {fruits[i]}")
# 实际更推荐使用enumerate
print("\n实际更推荐使用enumerate：")
for i, fruit in enumerate(fruits):
    print(f"  索引{i}: {fruit}")

print("range()在嵌套循环中的应用：")
# 1. 打印乘法表
print("\n1. 9×9乘法表：")
for i in range(1, 10):
    for j in range(1, 10):
        print(f"{i}×{j}={i*j:2d}", end=" ")
    print()  # 换行
# 2. 打印三角形
print("\n2. 打印星号三角形：")
height = 5
for i in range(1, height + 1):
    # 打印空格
    for _ in range(height - i):
        print(" ", end="")
    # 打印星号
    for _ in range(2 * i - 1):
        print("*", end="")
    print()
# 3. 二维网格坐标
print("\n3. 生成二维网格坐标：")
rows = 3
cols = 4
grid = []
for i in range(rows):
    row = []
    for j in range(cols):
        row.append((i, j))
    grid.append(row)
print("网格坐标：")
for row in grid:
    print(f"  {row}")
# 4. 更高效的嵌套循环写法
print("\n4. 使用product简化嵌套循环（需要itertools）：")
from itertools import product
for i, j in product(range(rows), range(cols)):
    print(f"  坐标({i}, {j})", end=" ")
    if j == cols - 1:
        print()  # 每行结束后换行

print("range对象的方法和属性：")
# 创建range对象
r = range(10, 50, 5)
print(f"range对象: {r}")
print(f"起始值 (start): {r.start}")
print(f"结束值 (stop): {r.stop}")
print(f"步长 (step): {r.step}")
# 使用索引和切片
print("\n索引和切片操作：")
print(f"r[0] = {r[0]}")
print(f"r[3] = {r[3]}")
print(f"r[-1] = {r[-1]}")  # 最后一个元素
print(f"r[2:5] = {r[2:5]}")  # 切片操作
print(f"r[::-1] = {r[::-1]}")  # 反转
# 检查成员关系
print("\n成员关系检查：")
print(f"20 in r: {20 in r}")
print(f"22 in r: {22 in r}")
print(f"55 in r: {55 in r}")
# 其他操作
print("\n其他操作：")
print(f"长度: {len(r)}")
print(f"最小值: {min(r)}")
print(f"最大值: {max(r)}")
print(f"转换为列表: {list(r)}")
print(f"转换为元组: {tuple(r)}")
print(f"字符串表示: {str(r)}")
print(f"哈希值: {hash(r)}")  # range对象是可哈希的
# 迭代器
print("\n迭代器操作：")
r_iter = iter(r)
print(f"迭代器: {r_iter}")
print(f"第一个元素: {next(r_iter)}")
print(f"第二个元素: {next(r_iter)}")
print(f"接下来的3个元素: {[next(r_iter) for _ in range(3)]}")

print("range对象的不可变性演示：")
r = range(1, 6)
print(f"原始range: {list(r)}")
# range对象是不可变的
print("\n尝试修改range对象会失败：")
try:
    r[0] = 100
except typeerror as e:
    print(f"错误: {e}")
try:
    r.start = 0
except attributeerror as e:
    print(f"错误: {e}")
# 但可以创建新的range对象
print("\n可以创建新的range对象：")
r2 = range(r.start + 1, r.stop + 1, r.step)
print(f"新range: {list(r2)}")
# range对象的相等比较
print("\nrange对象的相等比较：")
r1 = range(0, 10, 2)
r2 = range(0, 10, 2)
r3 = range(0, 11, 2)
print(f"r1 == r2: {r1 == r2}")  # true
print(f"r1 == r3: {r1 == r3}")  # false
print(f"hash(r1) == hash(r2): {hash(r1) == hash(r2)}")  # true
print(f"hash(r1) == hash(r3): {hash(r1) == hash(r3)}")  # false

print("python 2的xrange() vs python 3的range()：")
"""
python 2中有两个类似函数：
1. range(): 立即生成完整列表，内存消耗大
2. xrange(): 惰性生成值，类似python 3的range()
python 3中：
1. range(): 就是python 2的xrange()，惰性求值
2. 移除了xrange()函数
"""
# 模拟展示两种行为
print("\n模拟python 2的range()行为（立即生成列表）：")
def python2_range(start, stop=none, step=1):
    """模拟python 2的range()，立即生成列表"""
    if stop is none:
        stop = start
        start = 0
    result = []
    current = start
    if step > 0:
        while current < stop:
            result.append(current)
            current += step
    else:
        while current > stop:
            result.append(current)
            current += step
    return result
print(f"python2_range(0, 10, 2): {python2_range(0, 10, 2)}")
print(f"类型: {type(python2_range(0, 10, 2))}")
print("\npython 3的range()行为（惰性求值）：")
r = range(0, 10, 2)
print(f"range(0, 10, 2): {r}")
print(f"类型: {type(r)}")
print(f"按需生成值: {[r[i] for i in range(3)]}")
# 内存使用对比
print("\n内存使用对比（大范围）：")
import sys
# python 2风格（立即生成列表）
big_list = python2_range(10**6)
print(f"python 2风格列表占用内存: {sys.getsizeof(big_list):,} 字节")
# python 3风格（range对象）
big_range = range(10**6)
print(f"python 3 range对象占用内存: {sys.getsizeof(big_range):,} 字节")
memory_ratio = sys.getsizeof(big_list) / sys.getsizeof(big_range)
print(f"内存使用比例: {memory_ratio:.0f}:1")

print("range()函数的内存效率：")
import sys
import time
def test_memory_efficiency():
    """测试range和列表的内存效率"""
    print("\n1. 内存占用比较：")
    sizes = [10, 100, 1000, 10000, 100000]
    for size in sizes:
        # 使用range
        r = range(size)
        range_memory = sys.getsizeof(r)
        # 使用列表
        lst = list(range(size))
        list_memory = sys.getsizeof(lst)
        print(f"  大小 {size:7d}: range={range_memory:7d} 字节, "
              f"列表={list_memory:7d} 字节, "
              f"节省 {(list_memory-range_memory)/list_memory*100:.1f}%")
def test_performance():
    """测试range和列表的性能"""
    print("\n2. 性能比较：")
    test_size = 1000000
    # 测试range迭代
    start_time = time.time()
    total = 0
    for i in range(test_size):
        total += i
    range_time = time.time() - start_time
    # 测试列表迭代
    start_time = time.time()
    total = 0
    lst = list(range(test_size))
    for i in lst:
        total += i
    list_time = time.time() - start_time
    print(f"  迭代 {test_size:,} 个元素：")
    print(f"  range迭代时间: {range_time:.4f} 秒")
    print(f"  列表迭代时间: {list_time:.4f} 秒")
    print(f"  性能差异: {list_time/range_time:.2f} 倍")
def test_creation_time():
    """测试创建时间"""
    print("\n3. 创建时间比较：")
    test_size = 10000000
    # 测试创建range
    start_time = time.time()
    r = range(test_size)
    range_creation_time = time.time() - start_time
    # 测试创建列表
    start_time = time.time()
    lst = list(range(test_size))
    list_creation_time = time.time() - start_time
    print(f"  创建 {test_size:,} 个元素：")
    print(f"  创建range时间: {range_creation_time:.6f} 秒")
    print(f"  创建列表时间: {list_creation_time:.4f} 秒")
    print(f"  创建时间差异: {list_creation_time/range_creation_time:.0f} 倍")
# 运行测试
test_memory_efficiency()
test_performance()
test_creation_time()

print("range()在实际应用中的优化技巧：")
# 1. 避免不必要的列表转换
print("\n1. 避免不必要的列表转换：")
def sum_of_squares_bad(n):
    """不好的实现：先转换为列表"""
    numbers = list(range(1, n+1))
    return sum(x**2 for x in numbers)
def sum_of_squares_good(n):
    """好的实现：直接使用range"""
    return sum(x**2 for x in range(1, n+1))
n = 1000000
print(f"  计算1到{n}的平方和：")
print(f"  好的实现: {sum_of_squares_good(10)} (示例)")
# 实际大数据测试可能会耗费时间，这里只展示方法
# 2. 使用range进行切片式操作
print("\n2. 使用range进行切片式操作：")
def get_even_indices(data):
    """获取偶数索引的元素"""
    # 传统方法
    # result = []
    # for i in range(len(data)):
    #     if i % 2 == 0:
    #         result.append(data[i])
    # return result
    # 使用range的步长参数
    return [data[i] for i in range(0, len(data), 2)]
data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
print(f"  原始数据: {data}")
print(f"  偶数索引元素: {get_even_indices(data)}")
# 3. 批量处理
print("\n3. 批量处理数据：")
def process_in_batches(data, batch_size=3):
    """分批处理数据"""
    results = []
    for i in range(0, len(data), batch_size):
        batch = data[i:i+batch_size]
        results.append(f"批次{i//batch_size}: {batch}")
    return results
print(f"  分批处理: {process_in_batches(data, 3)}")
# 4. 预计算范围
print("\n4. 预计算range对象：")
class paginator:
    """分页器，使用预计算的range"""
    def __init__(self, total_items, items_per_page):
        self.total_items = total_items
        self.items_per_page = items_per_page
        self.total_pages = (total_items + items_per_page - 1) // items_per_page
        self.page_range = range(1, self.total_pages + 1)
    def get_page_indices(self, page):
        """获取指定页的索引范围"""
        if page not in self.page_range:
            raise valueerror(f"页码 {page} 超出范围")
        start_index = (page - 1) * self.items_per_page
        end_index = min(start_index + self.items_per_page, self.total_items)
        return range(start_index, end_index)
# 使用示例
paginator = paginator(total_items=23, items_per_page=5)
print(f"  总页数: {paginator.total_pages}")
print(f"  页码范围: {list(paginator.page_range)}")
print(f"  第2页的索引: {list(paginator.get_page_indices(2))}")

print("range()与zip()、map()、filter()结合使用：")
# 1. 与zip()结合
print("\n1. 与zip()结合使用：")
names = ['alice', 'bob', 'charlie', 'diana']
scores = [85, 92, 78, 95]
print("  使用enumerate:")
for i, (name, score) in enumerate(zip(names, scores)):
    print(f"    {i}. {name}: {score}")
print("\n  使用range:")
for i in range(len(names)):
    print(f"    {i}. {names[i]}: {scores[i]}")
# 2. 与map()结合
print("\n2. 与map()结合使用：")
numbers = range(1, 6)
# 计算平方
squares = map(lambda x: x**2, numbers)
print(f"  1-5的平方: {list(squares)}")
# 更简洁的方式
squares = [x**2 for x in range(1, 6)]
print(f"  列表推导式: {squares}")
# 3. 与filter()结合
print("\n3. 与filter()结合使用：")
numbers = range(1, 11)
# 筛选偶数
evens = filter(lambda x: x % 2 == 0, numbers)
print(f"  1-10的偶数: {list(evens)}")
# 更简洁的方式
evens = [x for x in range(1, 11) if x % 2 == 0]
print(f"  列表推导式: {evens}")
# 4. 综合应用
print("\n4. 综合应用示例：")
def process_data(n):
    """处理数据：生成、转换、筛选"""
    # 生成1到n的数字
    numbers = range(1, n+1)
    # 转换为字符串并添加前缀
    strings = map(lambda x: f"item_{x:03d}", numbers)
    # 筛选特定项（例如只保留奇数项）
    filtered = filter(lambda s: int(s.split('_')[1]) % 2 == 1, strings)
    return list(filtered)
print(f"  综合处理结果 (n=10): {process_data(10)}")

print("range()在数据科学和数值计算中的应用：")
import math
# 1. 生成等差数列
print("\n1. 生成等差数列：")
def arithmetic_sequence(start, diff, n):
    """生成等差数列"""
    return [start + i * diff for i in range(n)]
print(f"  等差数列 (首项=2, 公差=3, 项数=5): {arithmetic_sequence(2, 3, 5)}")
# 2. 数值积分（矩形法）
print("\n2. 数值积分（矩形法）：")
def integrate(f, a, b, n=1000):
    """数值积分：∫[a,b] f(x) dx"""
    dx = (b - a) / n
    total = 0
    for i in range(n):
        x = a + i * dx
        total += f(x) * dx
    return total
# 计算 ∫[0, π] sin(x) dx = 2
result = integrate(math.sin, 0, math.pi, 10000)
print(f"  ∫[0,π] sin(x) dx ≈ {result:.6f} (理论值: 2.000000)")
print(f"  误差: {abs(result - 2):.6f}")
# 3. 生成网格点
print("\n3. 生成二维网格点：")
def create_grid(x_range, y_range, step=1):
    """创建二维网格"""
    x_points = range(x_range[0], x_range[1] + 1, step)
    y_points = range(y_range[0], y_range[1] + 1, step)
    grid = []
    for x in x_points:
        for y in y_points:
            grid.append((x, y))
    return grid
grid = create_grid((0, 2), (0, 2))
print(f"  2x2网格点: {grid}")
# 4. 数据采样
print("\n4. 数据采样：")
def sample_data(data, sample_rate=0.1):
    """按采样率采样数据"""
    n = len(data)
    sample_size = int(n * sample_rate)
    step = max(1, n // sample_size)
    # 使用range进行等间隔采样
    indices = range(0, n, step)
    return [data[i] for i in indices]
data = list(range(100))
sampled = sample_data(data, 0.2)
print(f"  原始数据大小: {len(data)}")
print(f"  采样后大小: {len(sampled)}")
print(f"  采样结果: {sampled[:10]}...")  # 显示前10个

"""
range()函数的工作流程图：
开始
  ↓
接收参数 (start, stop, step)
  ↓
参数验证和处理
  │
  ├── 如果只有一个参数 → stop = 参数, start = 0, step = 1
  │
  ├── 如果有两个参数 → start, stop = 参数, step = 1
  │
  └── 如果有三个参数 → 使用所有参数
  ↓
检查step是否为0 → 是 → 抛出valueerror
  ↓
否
  ↓
创建range对象（惰性序列）
  ↓
              ┌──────────────────────┐
              │                      │
              ↓                      │
        需要获取元素时             │
              │                      │
              ↓                      │
    根据索引计算元素值：          │
    element = start + index * step   │
              │                      │
              ↓                      │
    检查元素是否在有效范围内      │
    (step > 0 且 element < stop) 或  │
    (step < 0 且 element > stop)     │
              │                      │
              ↓                      │
        返回元素值                │
              │                      │
              └──────────────────────┘
  ↓
可以进行的操作：
  ├── 迭代（for循环）
  ├── 索引访问（range_obj[index]）
  ├── 切片（range_obj[start:stop:step]）
  ├── 长度计算（len(range_obj)）
  ├── 成员检查（element in range_obj）
  └── 转换为其他类型（list(), tuple()）
  ↓
结束
"""

flowchart td
    a[开始调用range函数] --> b{参数个数?}
    b -->|一个参数| c[stop=参数, start=0, step=1]
    b -->|两个参数| d[start=参数1, stop=参数2, step=1]
    b -->|三个参数| e[使用所有参数 start, stop, step]
    c --> f
    d --> f
    e --> f
    f[参数验证] --> g{step == 0?}
    g -->|是| h[抛出valueerror异常]
    g -->|否| i[创建range对象
（惰性序列）]
    i --> j{操作类型?}
    j -->|迭代/for循环| k[按需生成序列值]
    j -->|索引访问| l[即时计算: start + index * step]
    j -->|切片操作| m[生成新的range对象]
    j -->|长度计算| n[计算公式:
max(0, (stop-start+step-1)//step)]
    j -->|成员检查| o[检查值是否在序列中]
    j -->|类型转换| p[生成完整列表/元组]
    k --> q[结束]
    l --> q
    m --> q
    n --> q
    o --> q
    p --> q
    h --> q

print("使用range实现分页系统：")
class paginationsystem:
    """完整的分页系统"""
    def __init__(self, total_items, items_per_page=10, current_page=1):
        self.total_items = total_items
        self.items_per_page = items_per_page
        self.current_page = current_page
        self._validate()
    def _validate(self):
        """验证参数"""
        if self.total_items < 0:
            raise valueerror("总项目数不能为负")
        if self.items_per_page <= 0:
            raise valueerror("每页项目数必须大于0")
        if self.current_page < 1:
            raise valueerror("当前页码必须大于等于1")
    @property
    def total_pages(self):
        """总页数"""
        if self.total_items == 0:
            return 1
        return (self.total_items + self.items_per_page - 1) // self.items_per_page
    @property
    def has_prev(self):
        """是否有上一页"""
        return self.current_page > 1
    @property
    def has_next(self):
        """是否有下一页"""
        return self.current_page < self.total_pages
    def get_page_range(self, display_pages=5):
        """获取显示的页码范围"""
        if self.total_pages <= display_pages:
            # 总页数少，显示所有页码
            return range(1, self.total_pages + 1)
        half_display = display_pages // 2
        # 计算起始和结束页码
        start_page = max(1, self.current_page - half_display)
        end_page = min(self.total_pages, start_page + display_pages - 1)
        # 调整起始页码，确保显示足够数量的页码
        if end_page - start_page + 1 < display_pages:
            start_page = max(1, end_page - display_pages + 1)
        return range(start_page, end_page + 1)
    def get_page_items(self, data):
        """获取当前页的数据"""
        start_idx = (self.current_page - 1) * self.items_per_page
        end_idx = min(start_idx + self.items_per_page, self.total_items)
        if start_idx >= len(data):
            return []
        return data[start_idx:end_idx]
    def display(self, data):
        """显示分页信息"""
        print(f"\n分页信息:")
        print(f"总项目数: {self.total_items}")
        print(f"总页数: {self.total_pages}")
        print(f"当前页: {self.current_page}")
        print(f"每页项目数: {self.items_per_page}")
        # 显示页码导航
        pages = list(self.get_page_range())
        page_nav = []
        for page in pages:
            if page == self.current_page:
                page_nav.append(f"[{page}]")
            else:
                page_nav.append(str(page))
        # 添加上一页/下一页指示
        if self.has_prev:
            page_nav.insert(0, "<<")
        if self.has_next:
            page_nav.append(">>")
        print(f"页码导航: {' '.join(page_nav)}")
        # 显示当前页数据
        page_items = self.get_page_items(data)
        print(f"当前页数据 ({len(page_items)} 项): {page_items}")
# 测试分页系统
print("测试分页系统:")
data = list(range(1, 101))  # 1到100的数据
paginator = paginationsystem(total_items=len(data), items_per_page=7, current_page=3)
paginator.display(data)
# 测试不同情况
test_cases = [
    (50, 10, 1),   # 正常情况
    (15, 5, 2),    # 刚好整除
    (0, 10, 1),    # 无数据
    (100, 20, 5),  # 最后一页
]
print("\n不同情况的测试:")
for total, per_page, current in test_cases:
    print(f"\n总项目数: {total}, 每页: {per_page}, 当前页: {current}")
    try:
        p = paginationsystem(total, per_page, current)
        print(f"总页数: {p.total_pages}, 显示页码: {list(p.get_page_range())}")
    except exception as e:
        print(f"错误: {e}")

print("\n使用range实现数据批处理框架：")
class batchprocessor:
    """通用的批处理器"""
    def __init__(self, data, batch_size=100):
        self.data = data
        self.batch_size = batch_size
        self.total_batches = (len(data) + batch_size - 1) // batch_size
    def process_batches(self, process_func):
        """处理所有批次"""
        results = []
        for batch_num in range(self.total_batches):
            start_idx = batch_num * self.batch_size
            end_idx = min(start_idx + self.batch_size, len(self.data))
            batch = self.data[start_idx:end_idx]
            print(f"处理批次 {batch_num + 1}/{self.total_batches} "
                  f"(项目 {start_idx}-{end_idx-1})")
            result = process_func(batch, batch_num)
            results.append(result)
        return results
    def parallel_process(self, process_func, max_workers=none):
        """并行处理批次（需要concurrent.futures）"""
        try:
            from concurrent.futures import threadpoolexecutor, as_completed
            if max_workers is none:
                import os
                max_workers = min(32, (os.cpu_count() or 1) * 4)
            with threadpoolexecutor(max_workers=max_workers) as executor:
                futures = []
                # 提交所有批次任务
                for batch_num in range(self.total_batches):
                    start_idx = batch_num * self.batch_size
                    end_idx = min(start_idx + self.batch_size, len(self.data))
                    batch = self.data[start_idx:end_idx]
                    future = executor.submit(process_func, batch, batch_num)
                    futures.append((batch_num, future))
                # 收集结果
                results = []
                for batch_num, future in futures:
                    result = future.result()
                    print(f"完成批次 {batch_num + 1}/{self.total_batches}")
                    results.append(result)
                return results
        except importerror:
            print("警告：concurrent.futures不可用，使用顺序处理")
            return self.process_batches(process_func)
# 示例：处理大量数据
def expensive_operation(batch, batch_num):
    """模拟耗时操作"""
    import time
    import random
    # 模拟处理时间
    process_time = 0.1 + random.random() * 0.2
    time.sleep(process_time)
    # 模拟处理：计算批次中元素的平方和
    result = sum(x**2 for x in batch)
    return {"batch": batch_num, "sum_of_squares": result, "size": len(batch)}
# 测试批处理器
print("测试批处理器：")
large_data = list(range(1, 1001))  # 1000个数据
processor = batchprocessor(large_data, batch_size=150)
print("顺序处理:")
sequential_results = processor.process_batches(expensive_operation)
total_sum = sum(r["sum_of_squares"] for r in sequential_results)
print(f"顺序处理完成，总平方和: {total_sum}")
# 注意：在实际环境中测试并行处理
print("\n注意：并行处理代码已准备，但在演示中不实际运行")
print("要测试并行处理，请取消注释以下代码：")
print("""
print("并行处理:")
parallel_results = processor.parallel_process(expensive_operation, max_workers=4)
parallel_total = sum(r["sum_of_squares"] for r in parallel_results)
print(f"并行处理完成，总平方和: {parallel_total}")
""")