备案号:蜀ICP备2026035467号-3|网址:www.xservx.com

Python中range()函数的用法详解

全面解析range()函数语法、参数、使用技巧与常见误区,附大量实战示例

⚡ range()函数概述

range()是Python内置函数之一,用于生成一个不可变的整数序列对象,常用于for循环中作为计数器。其核心特点是:惰性求值、内存占用极小、支持切片与索引。

在Python 2中,range()返回列表,而xrange()返回惰性序列;Python 3中range()直接实现了惰性序列行为,因此不再需要xrange()。这一设计变革显著提升了内存效率。

典型应用场景包括:

  • 循环遍历固定次数
  • 生成索引序列用于列表/元组遍历
  • 配合enumerate()实现带索引遍历
  • 生成等差数列用于数学计算

从算法角度看,range()底层以C实现,仅存储start、stop、step三个值及长度信息,不存储具体元素,因此无论序列多长,内存占用恒定。

⚙️ range()函数语法

range()函数有三种调用形式:

  • range(stop):从0开始,步长为1,到stop前结束(不包含stop)
  • range(start, stop):从start开始,步长为1,到stop前结束
  • range(start, stop, step):从start开始,以step为步长,到stop前结束

所有参数必须为整数(int类型),step不能为0,否则抛出ValueError异常。

函数返回一个range对象,该对象是collections.abc.Sequence的子类,因此支持序列协议(索引、切片、长度、成员检测等)。

注意:range对象是不可变的,创建后无法修改;其长度固定为max(0, (stop - start + step - sign(step)) // step)。

〔参数〕详细说明

stop:终止值(不包含)。例如range(5)生成0,1,2,3,4。

start:起始值(默认为0)。例如range(2, 6)生成2,3,4,5。

step:步长(默认为1)。可为负数,但此时start必须大于stop才能生成有效序列。例如range(5, 0, -1)生成5,4,3,2,1。

异常处理:

  • range(1, 10, 0) → ValueError: range() arg 3 must not be zero
  • range(1.0, 5) → TypeError: 'float' object cannot be interpreted as an integer
  • range(10, 5) → 空range对象(长度为0),因默认step=1,start>stop且步长为正

当step为负数时,序列递减。例如list(range(5, -1, -1))结果为[5, 4, 3, 2, 1, 0]。

〈示例〉实战应用

基础用法
倒序遍历
索引遍历
数学应用
FizzBuzz

基础用法

# 从0开始的5个整数
for i in range(5):
    print(i, end=' ')  # 输出: 0 1 2 3 4
# 从2开始到5(不含6)
for i in range(2, 6):
    print(i, end=' ')  # 输出: 2 3 4 5
# 步长为2的等差数列
for i in range(0, 10, 2):
    print(i, end=' ')  # 输出: 0 2 4 6 8

倒序遍历

# 倒序输出1到5
for i in range(5, 0, -1):
    print(i, end=' ')  # 输出: 5 4 3 2 1
# 倒序索引遍历列表
lst = ['a', 'b', 'c', 'd']
for i in range(len(lst)-1, -1, -1):
    print(f"索引{i}: {lst[i]}")
# 输出:
# 索引3: d
# 索引2: c
# 索引1: b
# 索引0: a

索引遍历

# 等价于enumerate()的索引部分
fruits = ['苹果', '香蕉', '橙子', '葡萄']
for i in range(len(fruits)):
    print(f"{i+1}. {fruits[i]}")
# 输出:
# 1. 苹果
# 2. 香蕉
# 3. 橙子
# 4. 葡萄
# 实际开发中推荐使用enumerate()
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

数学应用

# 计算1到100的和(高斯求和)
total = sum(range(1, 101))  # 5050
# 等差数列求和:首项2,末项20,公差2
even_sum = sum(range(2, 21, 2))  # 110
# 判断一个数是否为质数(简化版)
def is_prime(n):
    if n < 2:
        return False
    return all(n % i != 0 for i in range(2, int(n**0.5)+1))
print(is_prime(17))  # True
print(is_prime(18))  # False

FizzBuzz经典题

# 输出1到100,3的倍数输出"Fizz",5的倍数输出"Buzz",15的倍数输出"FizzBuzz"
for i in range(1, 101):
    if i % 15 == 0:
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)

⚠️ 常见误区与陷阱

误区1:认为range(10)是列表

range(10)是range对象,不是列表。虽然可迭代,但不支持列表的全部操作(如append、extend等)。

type(range(5))  # 
type([0,1,2,3,4])  # 
# 错误用法
r = range(5)
r.append(5)  # AttributeError: 'range' object has no attribute 'append'

误区2:忽略stop是开区间

很多人误以为range(1, 5)包含5,实际不包含。正确理解为:左闭右开区间。

list(range(1, 5))  # [1, 2, 3, 4]

误区3:负步长时start < stop

当step为负数时,若start < stop,则序列为空。

list(range(1, 10, -1))  # [] 空列表

误区4:与xrange混淆(Python 2残留问题)

在Python 2中:range()返回列表,xrange()返回惰性序列。Python 3中xrange()已移除,直接使用range()即可。

↔️ 与list/tuple的转换

虽然range对象可直接迭代,但有时需要显式转换为列表或元组以进行更多操作。

转换为列表

# 基本转换
r = range(1, 6)
lst = list(r)  # [1, 2, 3, 4, 5]
# 操作后转换
even_nums = list(range(2, 11, 2))  # [2, 4, 6, 8, 10]

转换为元组

r = range(0, 5)
tup = tuple(r)  # (0, 1, 2, 3, 4)

其他序列操作

# 索引访问
r = range(10, 20, 2)
r[2]  # 14
# 切片
r[1:3]  # range(12, 16, 2)
# 成员检测
14 in r  # True
15 in r  # False
# 长度
len(r)  # 5
注意:切片后返回新的range对象,而非列表!

⚡ 性能分析与优化建议

内存占用对比

import sys
r = range(10**6)
l = list(range(10**6))
sys.getsizeof(r)  # 48 字节(固定开销)
sys.getsizeof(l)  # ~8,000,000 字节(约8MB)

range对象无论序列长度,内存占用恒定(约48字节),而列表随元素数量线性增长。

时间效率对比

import timeit
# 遍历100万个元素
timeit.timeit('for i in range(10**6): pass', number=100)
# ≈ 0.03秒
timeit.timeit('for i in list(range(10**6)): pass', number=100)
# ≈ 0.08秒(含列表创建时间)
# 单纯遍历(已存在对象)
timeit.timeit('for i in r: pass', setup='r=range(10**6)', number=100)
# ≈ 0.03秒
timeit.timeit('for i in l: pass', setup='l=list(range(10**6))', number=100)
# ≈ 0.03秒(遍历阶段性能相当)

结论:当仅需遍历时,range更优;若需多次访问元素或进行修改操作,则需提前转换为列表。

最佳实践建议

  • 循环计数优先使用range
  • 避免重复创建大范围range对象(如循环内重复调用range(10**6))
  • 需要切片/索引操作时,考虑是否必须转换为列表
  • 内存敏感场景(如嵌入式)务必使用range而非列表

📅 Python 2 vs 3 差异

特性 Python 2 Python 3
range()返回类型 列表(list) range对象(惰性序列)
惰性序列函数 xrange() 已移除,统一为range()
内存效率 低(大范围消耗内存) 高(固定内存)
切片支持 仅列表支持切片 range对象支持切片
成员检测性能 O(n)(需遍历) O(1)(数学计算)
# Python 2 兼容写法(不推荐)
if sys.version_info[0] >= 3:
    r = range(1000000)
else:
    r = xrange(1000000)
# Python 3 推荐写法
r = range(1000000)

注意:Python 3中range的__contains__实现为O(1)时间复杂度,而列表为O(n)。例如999999 in range(10**6)瞬间完成。

📌 面试高频问题

Q1:range(10**100)会内存溢出吗?

不会。因为range对象只存储start、stop、step三个值,不实际创建元素。即使序列长度极大,内存占用仍为常数级。

Q2:range(10, 5)的结果是什么?

空range对象(长度为0)。因为默认step=1,start=10 > stop=5,无法生成有效序列。

Q3:如何生成5个连续整数,从3开始?

range(3, 8) → [3,4,5,6,7]

Q4:range对象支持哪些操作?

r = range(5, 15, 2)
# 支持:
len(r)      # 5
r[2]        # 9
r[1:3]      # range(7, 11, 2)
9 in r      # True
r.count(7)  # 1
r.index(11) # 3

Q5:range与numpy.arange区别?

  • range:纯Python内置,仅支持整数,内存高效
  • numpy.arange:NumPy库函数,支持浮点数,返回ndarray,适合数值计算

⏱️ range()函数发展简史

1991年:Python 0.9.0

首次引入range(),返回列表。当时计算机内存昂贵,但序列长度小,影响有限。

1999年:Python 1.5

为解决大范围内存问题,引入xrange(),实现惰性序列。成为性能敏感场景的标准选择。

2008年:Python 3.0

合并range()与xrange()功能,使range()默认惰性求值。同时移除xrange(),简化API。

2014年:Python 3.4+

优化range.__contains__,成员检测从O(n)提升至O(1),大幅提高大范围查找效率。

2021年:Python 3.10

增强range切片支持,返回新range对象而非列表,保持惰性特性。

📋 常用range()速查表

需求 代码示例 结果
0到n-1 range(n) 0, 1, ..., n-1
m到n-1 range(m, n) m, m+1, ..., n-1
0到n-1,步长k range(0, n, k) 0, k, 2k, ...,
n到1递减 range(n, 0, -1) n, n-1, ..., 1
0到n-1(转为列表) list(range(n)) [0, 1, ..., n-1]
偶数序列 range(0, 2*n, 2) 0, 2, 4, ..., 2n-2
奇数序列 range(1, 2*n, 2) 1, 3, 5, ..., 2n-1

❓ 网友还关心

Q:range和enumerate能同时用吗?
A:可以!enumerate(range(n))等价于enumerate(range(0, n)),但更推荐直接enumerate(range(n))。

Q:range对象能序列化吗?
A:可以!使用pickle模块:

import pickle
r = range(5, 10, 2)
data = pickle.dumps(r)
restored = pickle.loads(data)  # range(5, 10, 2)

Q:range在生成器表达式中效率如何?
A:极佳!生成器表达式本身惰性,配合range实现双重惰性:

sum(i*i for i in range(1000000))  # 高效计算平方和

Q:range能用于多线程吗?
A:可以!range对象是不可变的,线程安全(无状态修改)。但注意:若在循环中修改外部变量,仍需同步机制。

掌握range(),让循环更高效

从基础计数到高级优化,range()是Python程序员的日常利器。理解其惰性求值、内存效率与序列协议,能写出更优雅高效的代码。

建议:遇到循环问题,先问自己——是否必须创建列表?多数情况下,range()是更优解。

返回顶部