range() 是 Python 里和 for 循环绑定最紧的内置函数,凡是“重复 N 次”“遍历一段连续整数”“按下标跳步访问”的需求,基本都会落到它身上。很多人只记住了 range(10) 这种最简写法,却忽略了它在参数组合、内存占用、成员判断和切片上的实现细节;另一部分人则反过来滥用 range(len(...)),写出不如 enumerate()/zip() 直观的代码。下面按“参数怎么给、为什么高效、什么场景该用、什么场景不该用”的顺序,把 range() 的可用细节整理成一份可直接对照的实践笔记。
一、三种参数形式与边界规则
range 的完整签名是 range(start, stop[, step]),stop 是开区间端点,永远不会被包含。单参数时默认 start=0、step=1;双参数时默认 step=1。
- # 单参数:range(stop),等价于 [0, stop)
- for i in range(5):
- print(i, end=' ') # 0 1 2 3 4
- print(list(range(5))) # [0, 1, 2, 3, 4]
- print(list(range(1))) # [0]
- print(list(range(0))) # [] stop=0 生成空 range
- print(list(range(-5))) # [] 负数 stop 同样是空
- # 双参数:range(start, stop),等价于 [start, stop)
- print(list(range(3, 8))) # [3, 4, 5, 6, 7]
- print(list(range(-3, 3))) # [-3, -2, -1, 0, 1, 2]
- print(list(range(10, 5))) # [] start > stop 且步长为正,为空
- print(len(range(5, 10))) # 5 长度可 O(1) 直接算出
- print(len(range(-3, 3))) # 6
复制代码
三参数形式 range(start, stop, step) 决定递增或递减的跨度。关键结论只有一条:方向由 step 的符号决定,而不是由 start 与 stop 的大小关系决定。step 为正时要求 start < stop 才可能产生元素,step 为负时要求 start > stop 才可能产生元素,方向不匹配时结果就是空序列而不是报错。
- print(list(range(0, 10, 2))) # [0, 2, 4, 6, 8] 偶数
- print(list(range(1, 10, 2))) # [1, 3, 5, 7, 9] 奇数
- print(list(range(0, 100, 10))) # [0, 10, 20, ..., 90]
- # 负步长实现倒序
- print(list(range(10, 0, -1))) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
- print(list(range(10, 0, -2))) # [10, 8, 6, 4, 2]
- print(list(range(5, -5, -1))) # [5, 4, 3, 2, 1, 0, -1, -2, -3, -4]
- # 方向与步长符号不匹配:结果为空,不抛异常
- print(list(range(10, 0, 2))) # []
- print(list(range(10, 0, -2))) # [10, 8, 6, 4, 2]
- # step 不能为 0
- # list(range(0, 10, 0)) # ValueError: range() arg 3 must not be zero
复制代码
参数也支持关键字写法,例如 range(stop=5)、range(start=2, stop=8)、range(start=10, stop=0, step=-2)。但位置参数不能出现在关键字参数之后,range(start=0, 10) 会直接触发 SyntaxError。日常写法建议统一使用位置参数,更短也更符合惯例。
二、range 对象为什么省内存:惰性计算
range() 返回的不是列表,而是一个序列对象。它只保存 start、stop、step 三个值,迭代时才按公式算出“下一个值”,因此元素个数增长并不会让对象变大。
- import sys
- r = range(1000000)
- lst = list(range(1000000))
- print(f"range对象大小: {sys.getsizeof(r):,} bytes") # 约 48 bytes
- print(f"列表对象大小: {sys.getsizeof(lst):,} bytes") # 约 8,000,000 bytes
复制代码
这也是 for i in range(10000000) 可以放心写、而 for i in list(range(10000000)) 会让你多占几十 MB 内存的原因。后者完全没必要,因为循环体只需要当前值。
三、索引、切片与比较:全部是 O(1)
range 支持下标访问,并且不需要遍历,直接用公式算出第 n 个元素;负索引同样有效,越界抛 IndexError。切片返回的是一个新 range 对象而不是列表,代价同样是常数级。
- r = range(0, 100, 3) # 0, 3, 6, ..., 99
- print(r[0]) # 0
- print(r[1]) # 3
- print(r[10]) # 30
- print(r[-1]) # 99 支持负索引
- # print(r[100]) # IndexError
- print(r[5:15]) # range(15, 45, 3)
- print(r[:5]) # range(0, 15, 3)
- print(r[::2]) # range(0, 100, 6) 切片步长与原有步长相乘
- print(list(r[5:15])) # [15, 18, 21, 24, 27, 30, 33, 36, 39, 42]
- print(list(r[:5])) # [0, 3, 6, 9, 12]
- print(list(r[::2])) # [0, 6, 12, 18, ...]
- print(list(reversed(r))[:5]) # [99, 96, 93, 90, 87] reversed 可直接作用于 range
- # 相等比较按参数判断,不逐个元素比对
- print(range(0, 10, 2) == range(0, 10, 2)) # True
- print(range(0, 10, 2) == range(0, 9, 2)) # False
复制代码
四、成员检查为什么是 O(1)
这是 range 最容易被忽略的一项能力:in 判断不是遍历,而是用数学条件直接算出来。对 range(0, 1000000, 2) 判断 500000 是否在其中,耗时不随长度增长。
- r = range(0, 1000000, 2)
- print(500000 in r) # True
- print(500001 in r) # False
- import timeit
- lst = list(r)
- t_range = timeit.timeit(lambda: 999998 in r, number=10000)
- t_list = timeit.timeit(lambda: 999998 in lst, number=10000)
- print(f"range in: {t_range:.4f}s")
- print(f"list in: {t_list:.4f}s")
复制代码
其判定逻辑可以还原为下面这段等价实现:先判断 x 是否落在区间的有效一侧(正步长判断 start <= x < stop,负步长判断 stop < x <= start),再判断 x 与 start 的差是否为 step 的整数倍。两点同时满足才返回 True。
- def explain_range_contains(r, x):
- """还原 range 的成员检查逻辑"""
- start, stop, step = r.start, r.stop, r.step
- if step > 0:
- in_range = start <= x < stop
- if in_range:
- return (x - start) % step == 0
- else:
- in_range = stop < x <= start
- if in_range:
- return (x - start) % step == 0
- return False
复制代码
这个特性适合判断“某个编号/时间步/采样点是否落在等差数列里”,而不必先构造出完整列表。
五、range(len()) 该用与不该用
只取值时直接迭代对象,需要下标和值时用 enumerate(),需要倒序用 reversed(),多个序列并行遍历用 zip()。这几个写法比 range(len()) 更短、更不易出错:
- names = ["张三", "李四", "王五"]
- scores = [85, 92, 78]
- # 不推荐
- for i in range(len(names)):
- print(f"{names[i]}: {scores[i]}")
- # 推荐
- for name, score in zip(names, scores):
- print(f"{name}: {score}")
复制代码
但 range(len()) 并非一律错误。以下四类场景确实需要下标,此时它是合理甚至必要的写法:
- # 场景1:原地修改列表元素
- numbers = [1, 2, 3, 4, 5]
- for i in range(len(numbers)):
- numbers[i] = numbers[i] ** 2
- print(numbers) # [1, 4, 9, 16, 25]
- # 场景2:访问相邻元素
- data = [3, 1, 4, 1, 5, 9, 2, 6]
- for i in range(len(data) - 1):
- if data[i] > data[i + 1]:
- print(f"下降: {data[i]} → {data[i+1]} at index {i}")
- # 场景3:从后往前按下标处理
- stack = ['a', 'b', 'c', 'd', 'e']
- for i in range(len(stack) - 1, -1, -1):
- print(f"弹出: {stack[i]}")
- # 场景4:按固定间隔跳跃取值
- data = list(range(20))
- for i in range(0, len(data), 3):
- print(data[i], end=' ') # 0 3 6 9 12 15 18
复制代码
如果只是跳跃取值而不需要下标,data[::2] 这样的切片再直接迭代往往更清爽。
六、把 range 用在数值与分页逻辑上
range 的步长天然对应等差数列,也可以用来控制固定次数迭代。下面是几个常见的小工具写法。
- # 生成等差数列(注意终点需要补一个步长,保证 end 被包含)
- def arithmetic_sequence(start, end, step):
- return list(range(start, end + (1 if step > 0 else -1), step))
- print(arithmetic_sequence(1, 10, 2)) # [1, 3, 5, 7, 9]
- print(arithmetic_sequence(10, 1, -3)) # [10, 7, 4, 1]
- # 九九乘法表:外层控制行,内层控制列
- for i in range(1, 10):
- for j in range(1, i + 1):
- print(f"{j}×{i}={i*j}", end='\t')
- print()
- # 斐波那契:range 只负责迭代次数
- def fibonacci(n):
- result = []
- a, b = 0, 1
- for _ in range(n):
- result.append(a)
- a, b = b, a + b
- return result
- print(fibonacci(10)) # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
- # 分页:以 page_size 为步长切分列表
- def paginate(items, page_size):
- pages = []
- for i in range(0, len(items), page_size):
- pages.append(items[i:i + page_size])
- return pages
- pages = paginate(list(range(25)), 10)
- for i, page in enumerate(pages, 1):
- print(f"第{i}页: {page}")
复制代码
七、两个实战片段
第一个是命令行进度条。range(total + 1) 保证最后能打印到 100%,填充块数量由百分比换算得出,配合 \r 覆盖同一行输出。
- import time
- def simulate_progress(total, desc="处理中"):
- bar_length = 30
- for i in range(total + 1):
- percent = i / total
- filled = int(bar_length * percent)
- bar = '█' * filled + '░' * (bar_length - filled)
- print(f'\r{desc} |{bar}| {percent:.0%} ({i}/{total})', end='')
- time.sleep(0.05)
- print()
- # simulate_progress(50, "下载中")
复制代码
第二个是批量任务分批处理。批次数用 (total + batch_size - 1) // batch_size 向上取整,再以批次下标乘 batch_size 得到每批的起始位置,末端用 min() 兜住最后一批不足 batch_size 的情况。
- class BatchProcessor:
- """按固定批次大小分批处理元素"""
- def __init__(self, items, batch_size=100):
- self.items = items
- self.batch_size = batch_size
- self.results = []
- def process(self, worker_func):
- total = len(self.items)
- batches = (total + self.batch_size - 1) // self.batch_size
- for batch_idx in range(batches):
- start = batch_idx * self.batch_size
- end = min(start + self.batch_size, total)
- batch = self.items[start:end]
- print(f"处理批次 {batch_idx + 1}/{batches} "
- f"(元素 {start}-{end-1}, 共{len(batch)}个)")
- batch_results = [worker_func(item) for item in batch]
- self.results.extend(batch_results)
- time.sleep(0.1)
- print(f"\n✅ 全部处理完成: {len(self.results)} 个结果")
- return self.results
- # processor = BatchProcessor(range(1000), batch_size=150)
- # results = processor.process(lambda x: x ** 2)
复制代码
八、小结与常见报错对照
range(stop) 从 0 数到 stop-1;range(start, stop) 从 start 数到 stop-1;range(start, stop, step) 按步长推进,方向由 step 符号决定。range 对象是惰性的、内存占用极小(约 48 字节),索引、切片、reversed() 和 in 判断都为 O(1)。重复 N 次用 for _ in range(n),倒序用 reversed(range(n)) 或 range(n-1, -1, -1),跳步交给 step 参数;只有在需要原地改列表、访问相邻元素、按下标跳跃或反向遍历时,range(len(...)) 才是合适选择。
排查时优先看三类报错:ValueError: range() arg 3 must not be zero 表示步长写了 0;SyntaxError 出现在位置参数排在关键字参数之后;IndexError 表示下标超出了 range 的元素个数(可直接用 len(r) 核对长度)。另外,若循环体拿到的是空序列,先检查 start 与 stop 的大小关系和 step 的符号是否一致,这是 range 最常见的“静默失败”。
- import sys
- sizes = [100, 10000, 1000000]
- for n in sizes:
- r = range(n)
- l = list(r)
- print(f"n={n:>10,}: range={sys.getsizeof(r):>6} bytes, "
- f"list={sys.getsizeof(l):>12,} bytes")
复制代码 |