查看: 1476|回复: 3

Python range()三参数用法与O(1)成员检查、内存优化

[复制链接]
发表于 昨天 05:00 | 显示全部楼层 |阅读模式
range() 是 Python 里和 for 循环绑定最紧的内置函数,凡是“重复 N 次”“遍历一段连续整数”“按下标跳步访问”的需求,基本都会落到它身上。很多人只记住了 range(10) 这种最简写法,却忽略了它在参数组合、内存占用、成员判断和切片上的实现细节;另一部分人则反过来滥用 range(len(...)),写出不如 enumerate()/zip() 直观的代码。下面按“参数怎么给、为什么高效、什么场景该用、什么场景不该用”的顺序,把 range() 的可用细节整理成一份可直接对照的实践笔记。

一、三种参数形式与边界规则

range 的完整签名是 range(start, stop[, step]),stop 是开区间端点,永远不会被包含。单参数时默认 start=0、step=1;双参数时默认 step=1。
  1. # 单参数:range(stop),等价于 [0, stop)
  2. for i in range(5):
  3.     print(i, end=' ')          # 0 1 2 3 4
  4. print(list(range(5)))          # [0, 1, 2, 3, 4]
  5. print(list(range(1)))          # [0]
  6. print(list(range(0)))          # []  stop=0 生成空 range
  7. print(list(range(-5)))         # []  负数 stop 同样是空
  8. # 双参数:range(start, stop),等价于 [start, stop)
  9. print(list(range(3, 8)))       # [3, 4, 5, 6, 7]
  10. print(list(range(-3, 3)))      # [-3, -2, -1, 0, 1, 2]
  11. print(list(range(10, 5)))      # []  start > stop 且步长为正,为空
  12. print(len(range(5, 10)))       # 5  长度可 O(1) 直接算出
  13. print(len(range(-3, 3)))       # 6
复制代码

三参数形式 range(start, stop, step) 决定递增或递减的跨度。关键结论只有一条:方向由 step 的符号决定,而不是由 start 与 stop 的大小关系决定。step 为正时要求 start < stop 才可能产生元素,step 为负时要求 start > stop 才可能产生元素,方向不匹配时结果就是空序列而不是报错。
  1. print(list(range(0, 10, 2)))    # [0, 2, 4, 6, 8]      偶数
  2. print(list(range(1, 10, 2)))    # [1, 3, 5, 7, 9]      奇数
  3. print(list(range(0, 100, 10)))  # [0, 10, 20, ..., 90]
  4. # 负步长实现倒序
  5. print(list(range(10, 0, -1)))   # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
  6. print(list(range(10, 0, -2)))   # [10, 8, 6, 4, 2]
  7. print(list(range(5, -5, -1)))   # [5, 4, 3, 2, 1, 0, -1, -2, -3, -4]
  8. # 方向与步长符号不匹配:结果为空,不抛异常
  9. print(list(range(10, 0, 2)))    # []
  10. print(list(range(10, 0, -2)))   # [10, 8, 6, 4, 2]
  11. # step 不能为 0
  12. # 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 三个值,迭代时才按公式算出“下一个值”,因此元素个数增长并不会让对象变大。
  1. import sys
  2. r = range(1000000)
  3. lst = list(range(1000000))
  4. print(f"range对象大小: {sys.getsizeof(r):,} bytes")   # 约 48 bytes
  5. 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 对象而不是列表,代价同样是常数级。
  1. r = range(0, 100, 3)      # 0, 3, 6, ..., 99
  2. print(r[0])               # 0
  3. print(r[1])               # 3
  4. print(r[10])              # 30
  5. print(r[-1])              # 99  支持负索引
  6. # print(r[100])           # IndexError
  7. print(r[5:15])            # range(15, 45, 3)
  8. print(r[:5])              # range(0, 15, 3)
  9. print(r[::2])             # range(0, 100, 6)  切片步长与原有步长相乘
  10. print(list(r[5:15]))      # [15, 18, 21, 24, 27, 30, 33, 36, 39, 42]
  11. print(list(r[:5]))        # [0, 3, 6, 9, 12]
  12. print(list(r[::2]))       # [0, 6, 12, 18, ...]
  13. print(list(reversed(r))[:5])  # [99, 96, 93, 90, 87]  reversed 可直接作用于 range
  14. # 相等比较按参数判断,不逐个元素比对
  15. print(range(0, 10, 2) == range(0, 10, 2))  # True
  16. print(range(0, 10, 2) == range(0, 9, 2))   # False
复制代码

四、成员检查为什么是 O(1)

这是 range 最容易被忽略的一项能力:in 判断不是遍历,而是用数学条件直接算出来。对 range(0, 1000000, 2) 判断 500000 是否在其中,耗时不随长度增长。
  1. r = range(0, 1000000, 2)
  2. print(500000 in r)   # True
  3. print(500001 in r)   # False
  4. import timeit
  5. lst = list(r)
  6. t_range = timeit.timeit(lambda: 999998 in r, number=10000)
  7. t_list = timeit.timeit(lambda: 999998 in lst, number=10000)
  8. print(f"range in: {t_range:.4f}s")
  9. print(f"list in: {t_list:.4f}s")
复制代码

其判定逻辑可以还原为下面这段等价实现:先判断 x 是否落在区间的有效一侧(正步长判断 start <= x < stop,负步长判断 stop < x <= start),再判断 x 与 start 的差是否为 step 的整数倍。两点同时满足才返回 True。
  1. def explain_range_contains(r, x):
  2.     """还原 range 的成员检查逻辑"""
  3.     start, stop, step = r.start, r.stop, r.step
  4.     if step > 0:
  5.         in_range = start <= x < stop
  6.         if in_range:
  7.             return (x - start) % step == 0
  8.     else:
  9.         in_range = stop < x <= start
  10.         if in_range:
  11.             return (x - start) % step == 0
  12.     return False
复制代码

这个特性适合判断“某个编号/时间步/采样点是否落在等差数列里”,而不必先构造出完整列表。

五、range(len()) 该用与不该用

只取值时直接迭代对象,需要下标和值时用 enumerate(),需要倒序用 reversed(),多个序列并行遍历用 zip()。这几个写法比 range(len()) 更短、更不易出错:
  1. names = ["张三", "李四", "王五"]
  2. scores = [85, 92, 78]
  3. # 不推荐
  4. for i in range(len(names)):
  5.     print(f"{names[i]}: {scores[i]}")
  6. # 推荐
  7. for name, score in zip(names, scores):
  8.     print(f"{name}: {score}")
复制代码

但 range(len()) 并非一律错误。以下四类场景确实需要下标,此时它是合理甚至必要的写法:
  1. # 场景1:原地修改列表元素
  2. numbers = [1, 2, 3, 4, 5]
  3. for i in range(len(numbers)):
  4.     numbers[i] = numbers[i] ** 2
  5. print(numbers)                    # [1, 4, 9, 16, 25]
  6. # 场景2:访问相邻元素
  7. data = [3, 1, 4, 1, 5, 9, 2, 6]
  8. for i in range(len(data) - 1):
  9.     if data[i] > data[i + 1]:
  10.         print(f"下降: {data[i]} → {data[i+1]} at index {i}")
  11. # 场景3:从后往前按下标处理
  12. stack = ['a', 'b', 'c', 'd', 'e']
  13. for i in range(len(stack) - 1, -1, -1):
  14.     print(f"弹出: {stack[i]}")
  15. # 场景4:按固定间隔跳跃取值
  16. data = list(range(20))
  17. for i in range(0, len(data), 3):
  18.     print(data[i], end=' ')       # 0 3 6 9 12 15 18
复制代码

如果只是跳跃取值而不需要下标,data[::2] 这样的切片再直接迭代往往更清爽。

六、把 range 用在数值与分页逻辑上

range 的步长天然对应等差数列,也可以用来控制固定次数迭代。下面是几个常见的小工具写法。
  1. # 生成等差数列(注意终点需要补一个步长,保证 end 被包含)
  2. def arithmetic_sequence(start, end, step):
  3.     return list(range(start, end + (1 if step > 0 else -1), step))
  4. print(arithmetic_sequence(1, 10, 2))     # [1, 3, 5, 7, 9]
  5. print(arithmetic_sequence(10, 1, -3))    # [10, 7, 4, 1]
  6. # 九九乘法表:外层控制行,内层控制列
  7. for i in range(1, 10):
  8.     for j in range(1, i + 1):
  9.         print(f"{j}×{i}={i*j}", end='\t')
  10.     print()
  11. # 斐波那契:range 只负责迭代次数
  12. def fibonacci(n):
  13.     result = []
  14.     a, b = 0, 1
  15.     for _ in range(n):
  16.         result.append(a)
  17.         a, b = b, a + b
  18.     return result
  19. print(fibonacci(10))    # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
  20. # 分页:以 page_size 为步长切分列表
  21. def paginate(items, page_size):
  22.     pages = []
  23.     for i in range(0, len(items), page_size):
  24.         pages.append(items[i:i + page_size])
  25.     return pages
  26. pages = paginate(list(range(25)), 10)
  27. for i, page in enumerate(pages, 1):
  28.     print(f"第{i}页: {page}")
复制代码

七、两个实战片段

第一个是命令行进度条。range(total + 1) 保证最后能打印到 100%,填充块数量由百分比换算得出,配合 \r 覆盖同一行输出。
  1. import time
  2. def simulate_progress(total, desc="处理中"):
  3.     bar_length = 30
  4.     for i in range(total + 1):
  5.         percent = i / total
  6.         filled = int(bar_length * percent)
  7.         bar = '█' * filled + '░' * (bar_length - filled)
  8.         print(f'\r{desc} |{bar}| {percent:.0%} ({i}/{total})', end='')
  9.         time.sleep(0.05)
  10.     print()
  11. # simulate_progress(50, "下载中")
复制代码

第二个是批量任务分批处理。批次数用 (total + batch_size - 1) // batch_size 向上取整,再以批次下标乘 batch_size 得到每批的起始位置,末端用 min() 兜住最后一批不足 batch_size 的情况。
  1. class BatchProcessor:
  2.     """按固定批次大小分批处理元素"""
  3.     def __init__(self, items, batch_size=100):
  4.         self.items = items
  5.         self.batch_size = batch_size
  6.         self.results = []
  7.     def process(self, worker_func):
  8.         total = len(self.items)
  9.         batches = (total + self.batch_size - 1) // self.batch_size
  10.         for batch_idx in range(batches):
  11.             start = batch_idx * self.batch_size
  12.             end = min(start + self.batch_size, total)
  13.             batch = self.items[start:end]
  14.             print(f"处理批次 {batch_idx + 1}/{batches} "
  15.                   f"(元素 {start}-{end-1}, 共{len(batch)}个)")
  16.             batch_results = [worker_func(item) for item in batch]
  17.             self.results.extend(batch_results)
  18.             time.sleep(0.1)
  19.         print(f"\n✅ 全部处理完成: {len(self.results)} 个结果")
  20.         return self.results
  21. # processor = BatchProcessor(range(1000), batch_size=150)
  22. # 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 最常见的“静默失败”。
  1. import sys
  2. sizes = [100, 10000, 1000000]
  3. for n in sizes:
  4.     r = range(n)
  5.     l = list(r)
  6.     print(f"n={n:>10,}: range={sys.getsizeof(r):>6} bytes, "
  7.           f"list={sys.getsizeof(l):>12,} bytes")
复制代码
回复

使用道具 举报

发表于 昨天 05:05 | 显示全部楼层

Re: Python range()三参数用法与O(1)成员检查、内存优化

这篇整理挺实用的,尤其是把 step 符号决定遍历方向、方向不匹配时返回空序列而不是报错讲得很清楚。range 对象只保存 start、stop、step,切片返回的也还是 range 对象,这些细节对日常写循环时避免不必要地 list 化很有帮助。关于用 enumerate 替代 range(len(...)) 的提醒也很到位。感谢分享,后面如果继续补充成员判断那部分,会更有参考价值。
回复 支持 反对

使用道具 举报

发表于 昨天 05:05 | 显示全部楼层

Re: Python range()三参数用法与O(1)成员检查、内存优化

这篇整理得很系统,参数边界、负步长和空 range 的规则都讲得很清楚,尤其是“方向由 step 符号决定、方向不匹配返回空而不是报错”这一点,很容易踩坑。range 对象只保存三个值、索引和切片是常数级这些实践点也很实用。一个小建议:负步长那组示例里 range(10, 0, -2) 其实是方向匹配的正常结果,放在“方向与步长符号不匹配”的注释下容易让人看混,可以单独标一下。整体很适合当对照笔记。
回复 支持 反对

使用道具 举报

发表于 昨天 05:05 | 显示全部楼层

Re: Python range()三参数用法与O(1)成员检查、内存优化

整理得很细,尤其是步长符号决定方向、方向不匹配时返回空而不是报错,以及切片返回新 range、切片步长会和原步长相乘这几个点,平时确实容易忽略。range 对象只保存三个值所以内存占用很小,这个对比很直观,以后大数量循环也没必要先 list 一下。标题里提到的 O(1) 成员检查正文目前还没展开,如果后面能补一下 in 的判断和边界例子就更完整了。整体这份笔记很适合直接对照查。
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则

指导单位

江苏省公安厅

江苏省通信管理局

浙江省台州刑侦支队

DEFCON GROUP 86025

Hacking Group 021A

旗下站点

态势感知中心

应急响应中心

红盟安全

联系我们

官方QQ群:112851260

官方邮箱:security#ihonker.org(#改成@)

官方核心成员

关注微信公众号

Archiver|手机版|小黑屋| ( 沪ICP备2021026908号 )

GMT+8, 2026-11-22 04:43 , Processed in 0.023428 second(s), 17 queries , Gzip On, Redis On.

Powered by ihonker.com

Copyright © 2015-现在.

  • 返回顶部