# 基本示例
print("range()函數(shù)生成序列的基本用法：")
# 創(chuàng)建一個range對象
r = range(5)
print(f"range(5) = {r}")
print(f"類型: {type(r)}")
# 轉換為列表查看具體值
print(f"轉換為列表: {list(r)}")
print(f"轉換為元組: {tuple(r)}")

print("range()函數(shù)的三種調用形式：")
# 1. 一個參數(shù)：range(stop)
print("\n1. range(stop)形式：")
r1 = range(5)
print(f"range(5) = {list(r1)}")  # 0, 1, 2, 3, 4
# 2. 兩個參數(shù)：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. 三個參數(shù)：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函數(shù)的參數(shù)"""
    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"生成的數(shù)字序列: {list(range(start, stop, step))}")
    # 顯示數(shù)學公式
    if length > 0:
        print(f"數(shù)學表示: {{start + i * step | i = 0, 1, ..., {length-1}}}")
        print(f"具體元素: {[start + i * step for i in range(length)]}")
# 演示不同參數(shù)組合
print("range()函數(shù)參數(shù)詳解：")
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()函數(shù)的邊界條件和特殊情況：")
# 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. 小數(shù)參數(shù)（會被截斷）
print("\n3. 小數(shù)參數(shù)情況（自動轉換為整數(shù)）：")
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. 大數(shù)字范圍
print("\n4. 大數(shù)字范圍：")
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__()} 字節(jié)")

print("range()在for循環(huán)中的基本應用：")
# 1. 遍歷固定次數(shù)
print("\n1. 遍歷固定次數(shù)：")
for i in range(5):
    print(f"  第{i}次循環(huán)")
# 2. 遍歷特定范圍
print("\n2. 遍歷特定范圍：")
start = 3
end = 8
for i in range(start, end):
    print(f"  當前值: {i}, 平方: {i**2}")
# 3. 帶步長的遍歷
print("\n3. 帶步長的遍歷（打印偶數(shù)）：")
for i in range(0, 11, 2):
    print(f"  偶數(shù): {i}")
# 4. 反向遍歷
print("\n4. 反向遍歷：")
for i in range(10, 0, -1):
    print(f"  倒計時: {i}")
print("  發(fā)射！")
# 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()在嵌套循環(huán)中的應用：")
# 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. 更高效的嵌套循環(huán)寫法
print("\n4. 使用product簡化嵌套循環(huán)（需要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對象的方法和屬性：")
# 創(chuàng)建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}")
# 但可以創(chuàng)建新的range對象
print("\n可以創(chuàng)建新的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中有兩個類似函數(shù)：
1. range(): 立即生成完整列表，內存消耗大
2. xrange(): 惰性生成值，類似Python 3的range()
Python 3中：
1. range(): 就是Python 2的xrange()，惰性求值
2. 移除了xrange()函數(shù)
"""
# 模擬展示兩種行為
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):,} 字節(jié)")
# Python 3風格（range對象）
big_range = range(10**6)
print(f"Python 3 range對象占用內存: {sys.getsizeof(big_range):,} 字節(jié)")
memory_ratio = sys.getsizeof(big_list) / sys.getsizeof(big_range)
print(f"內存使用比例: {memory_ratio:.0f}:1")

print("range()函數(shù)的內存效率：")
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} 字節(jié), "
              f"列表={list_memory:7d} 字節(jié), "
              f"節(jié)省 {(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():
    """測試創(chuàng)建時間"""
    print("\n3. 創(chuàng)建時間比較：")
    test_size = 10000000
    # 測試創(chuàng)建range
    start_time = time.time()
    r = range(test_size)
    range_creation_time = time.time() - start_time
    # 測試創(chuàng)建列表
    start_time = time.time()
    lst = list(range(test_size))
    list_creation_time = time.time() - start_time
    print(f"  創(chuàng)建 {test_size:,} 個元素：")
    print(f"  創(chuàng)建range時間: {range_creation_time:.6f} 秒")
    print(f"  創(chuàng)建列表時間: {list_creation_time:.4f} 秒")
    print(f"  創(chuàng)建時間差異: {list_creation_time/range_creation_time:.0f} 倍")
# 運行測試
test_memory_efficiency()
test_performance()
test_creation_time()

print("range()在實際應用中的優(yōu)化技巧：")
# 1. 避免不必要的列表轉換
print("\n1. 避免不必要的列表轉換：")
def sum_of_squares_bad(n):
    """不好的實現(xiàn)：先轉換為列表"""
    numbers = list(range(1, n+1))
    return sum(x**2 for x in numbers)
def sum_of_squares_good(n):
    """好的實現(xiàn)：直接使用range"""
    return sum(x**2 for x in range(1, n+1))
n = 1000000
print(f"  計算1到{n}的平方和：")
print(f"  好的實現(xiàn): {sum_of_squares_good(10)} (示例)")
# 實際大數(shù)據(jù)測試可能會耗費時間，這里只展示方法
# 2. 使用range進行切片式操作
print("\n2. 使用range進行切片式操作：")
def get_even_indices(data):
    """獲取偶數(shù)索引的元素"""
    # 傳統(tǒng)方法
    # result = []
    # for i in range(len(data)):
    #     if i % 2 == 0:
    #         result.append(data[i])
    # return result
    # 使用range的步長參數(shù)
    return [data[i] for i in range(0, len(data), 2)]
data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
print(f"  原始數(shù)據(jù): {data}")
print(f"  偶數(shù)索引元素: {get_even_indices(data)}")
# 3. 批量處理
print("\n3. 批量處理數(shù)據(jù)：")
def process_in_batches(data, batch_size=3):
    """分批處理數(shù)據(jù)"""
    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"  總頁數(shù): {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)
# 篩選偶數(shù)
evens = filter(lambda x: x % 2 == 0, numbers)
print(f"  1-10的偶數(shù): {list(evens)}")
# 更簡潔的方式
evens = [x for x in range(1, 11) if x % 2 == 0]
print(f"  列表推導式: {evens}")
# 4. 綜合應用
print("\n4. 綜合應用示例：")
def process_data(n):
    """處理數(shù)據(jù)：生成、轉換、篩選"""
    # 生成1到n的數(shù)字
    numbers = range(1, n+1)
    # 轉換為字符串并添加前綴
    strings = map(lambda x: f"Item_{x:03d}", numbers)
    # 篩選特定項（例如只保留奇數(shù)項）
    filtered = filter(lambda s: int(s.split('_')[1]) % 2 == 1, strings)
    return list(filtered)
print(f"  綜合處理結果 (n=10): {process_data(10)}")

print("range()在數(shù)據(jù)科學和數(shù)值計算中的應用：")
import math
# 1. 生成等差數(shù)列
print("\n1. 生成等差數(shù)列：")
def arithmetic_sequence(start, diff, n):
    """生成等差數(shù)列"""
    return [start + i * diff for i in range(n)]
print(f"  等差數(shù)列 (首項=2, 公差=3, 項數(shù)=5): {arithmetic_sequence(2, 3, 5)}")
# 2. 數(shù)值積分（矩形法）
print("\n2. 數(shù)值積分（矩形法）：")
def integrate(f, a, b, n=1000):
    """數(shù)值積分：∫[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):
    """創(chuàng)建二維網格"""
    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. 數(shù)據(jù)采樣
print("\n4. 數(shù)據(jù)采樣：")
def sample_data(data, sample_rate=0.1):
    """按采樣率采樣數(shù)據(jù)"""
    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"  原始數(shù)據(jù)大小: {len(data)}")
print(f"  采樣后大小: {len(sampled)}")
print(f"  采樣結果: {sampled[:10]}...")  # 顯示前10個

"""
range()函數(shù)的工作流程圖：
開始
  ↓
接收參數(shù) (start, stop, step)
  ↓
參數(shù)驗證和處理
  │
  ├── 如果只有一個參數(shù) → stop = 參數(shù), start = 0, step = 1
  │
  ├── 如果有兩個參數(shù) → start, stop = 參數(shù), step = 1
  │
  └── 如果有三個參數(shù) → 使用所有參數(shù)
  ↓
檢查step是否為0 → 是 → 拋出ValueError
  ↓
否
  ↓
創(chuàng)建range對象（惰性序列）
  ↓
              ┌──────────────────────┐
              │                      │
              ↓                      │
        需要獲取元素時             │
              │                      │
              ↓                      │
    根據(jù)索引計算元素值：          │
    element = start + index * step   │
              │                      │
              ↓                      │
    檢查元素是否在有效范圍內      │
    (step > 0 且 element < stop) 或  │
    (step < 0 且 element > stop)     │
              │                      │
              ↓                      │
        返回元素值                │
              │                      │
              └──────────────────────┘
  ↓
可以進行的操作：
  ├── 迭代（for循環(huán)）
  ├── 索引訪問（range_obj[index]）
  ├── 切片（range_obj[start:stop:step]）
  ├── 長度計算（len(range_obj)）
  ├── 成員檢查（element in range_obj）
  └── 轉換為其他類型（list(), tuple()）
  ↓
結束
"""

flowchart TD
    A[開始調用range函數(shù)] --> B{參數(shù)個數(shù)?}
    B -->|一個參數(shù)| C[stop=參數(shù), start=0, step=1]
    B -->|兩個參數(shù)| D[start=參數(shù)1, stop=參數(shù)2, step=1]
    B -->|三個參數(shù)| E[使用所有參數(shù) start, stop, step]
    C --> F
    D --> F
    E --> F
    F[參數(shù)驗證] --> G{step == 0?}
    G -->|是| H[拋出ValueError異常]
    G -->|否| I[創(chuàng)建range對象
（惰性序列）]
    I --> J{操作類型?}
    J -->|迭代/for循環(huán)| 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實現(xiàn)分頁系統(tǒng)：")
class PaginationSystem:
    """完整的分頁系統(tǒng)"""
    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):
        """驗證參數(shù)"""
        if self.total_items < 0:
            raise ValueError("總項目數(shù)不能為負")
        if self.items_per_page <= 0:
            raise ValueError("每頁項目數(shù)必須大于0")
        if self.current_page < 1:
            raise ValueError("當前頁碼必須大于等于1")
    @property
    def total_pages(self):
        """總頁數(shù)"""
        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:
            # 總頁數(shù)少，顯示所有頁碼
            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)
        # 調整起始頁碼，確保顯示足夠數(shù)量的頁碼
        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):
        """獲取當前頁的數(shù)據(jù)"""
        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"總項目數(shù): {self.total_items}")
        print(f"總頁數(shù): {self.total_pages}")
        print(f"當前頁: {self.current_page}")
        print(f"每頁項目數(shù): {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)}")
        # 顯示當前頁數(shù)據(jù)
        page_items = self.get_page_items(data)
        print(f"當前頁數(shù)據(jù) ({len(page_items)} 項): {page_items}")
# 測試分頁系統(tǒng)
print("測試分頁系統(tǒng):")
data = list(range(1, 101))  # 1到100的數(shù)據(jù)
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),    # 無數(shù)據(jù)
    (100, 20, 5),  # 最后一頁
]
print("\n不同情況的測試:")
for total, per_page, current in test_cases:
    print(f"\n總項目數(shù): {total}, 每頁: {per_page}, 當前頁: {current}")
    try:
        p = PaginationSystem(total, per_page, current)
        print(f"總頁數(shù): {p.total_pages}, 顯示頁碼: {list(p.get_page_range())}")
    except Exception as e:
        print(f"錯誤: {e}")

print("\n使用range實現(xiàn)數(shù)據(jù)批處理框架：")
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)
# 示例：處理大量數(shù)據(jù)
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個數(shù)據(jù)
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}")
# 注意：在實際環(huán)境中測試并行處理
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}")
""")