为什么 range 不是迭代器？ range 到底是什么类型？（内有公众号宣传，不喜勿进）

[chinesehuazhou]

迭代器是 23 种设计模式中最常用的一种（之一），在 Python 中随处可见它的身影，我们经常用到它，但是却不一定意识到它的存在。在关于迭代器的系列文章中（链接见文末），我至少提到了 23 种生成迭代器的方法。有些方法是专门用于生成迭代器的，还有一些方法则是为了解决别的问题而“暗中”使用到迭代器。

在系统学习迭代器之前，我一直以为 range() 方法也是用于生成迭代器的，现在却突然发现，它生成的只是可迭代对象，而并不是迭代器！ （ PS：Python2 中 range() 生成的是列表，本文基于 Python3，生成的是可迭代对象）

于是，我有了这样的疑问：为什么 range() 不生成迭代器呢？在查找答案的过程中，我发现自己对 range 类型的认识存在一些误区。因此，本文将和大家全面地认识一下 range，期待与你共同学习进步。

1、range() 是什么？

它的语法：range(start, stop [,step]) ； start 指的是计数起始值，默认是 0 ； stop 指的是计数结束值，但不包括 stop ； step 是步长，默认为 1，不可以为 0。range() 方法生成一段左闭右开的整数范围。

>>> a = range(5)  # 即 range(0,5)
>>> a
range(0, 5)
>>> len(a)
5
>>> for x in a:
>>>     print(x,end=" ")
0 1 2 3 4

对于 range() 函数，有几个注意点：（ 1 ）它表示的是左闭右开区间；（ 2 ）它接收的参数必须是整数，可以是负数，但不能是浮点数等其它类型；（ 3 ）它是不可变的序列类型，可以进行判断元素、查找元素、切片等操作，但不能修改元素；（ 4 ）它是可迭代对象，却不是迭代器。

# （ 1 ）左闭右开
>>> for i in range(3, 6):
>>>     print(i,end=" ")
3 4 5

# （ 2 ）参数类型
>>> for i in range(-8, -2, 2):
>>>     print(i,end=" ")
-8 -6 -4
>>> range(2.2)
----------------------------
TypeError    Traceback (most recent call last)
...
TypeError: 'float' object cannot be interpreted as an integer

# （ 3 ）序列操作
>>> b = range(1,10)
>>> b[0]
1
>>> b[:-3]
range(1, 7)
>>> b[0] = 2
TypeError  Traceback (most recent call last)
...
TypeError: 'range' object does not support item assignment

# （ 4 ）不是迭代器
>>> hasattr(range(3),'__iter__')
True
>>> hasattr(range(3),'__next__')
False
>>> hasattr(iter(range(3)),'__next__')
True

2、 为什么 range()不生产迭代器？

可以获得迭代器的内置方法很多，例如 zip() 、enumerate()、map()、filter() 和 reversed() 等等，但是像 range() 这样仅仅得到的是可迭代对象的方法就绝无仅有了（若有反例，欢迎告知）。这就是我存在知识误区的地方。

在 for-循环 遍历时，可迭代对象与迭代器的性能是一样的，即它们都是惰性求值的，在空间复杂度与时间复杂度上并无差异。我曾概括过两者的差别是“一同两不同”：相同的是都可惰性迭代，不同的是可迭代对象不支持自遍历（即 next()方法），而迭代器本身不支持切片（即__getitem__() 方法）。

虽然有这些差别，但很难得出结论说它们哪个更优。现在微妙之处就在于，为什么给 5 种内置方法都设计了迭代器，偏偏给 range() 方法设计的就是可迭代对象呢？把它们都统一起来，不是更好么？

事实上，Pyhton 为了规范性就干过不少这种事，例如，Python2 中有 range() 和 xrange() 两种方法，而 Python3 就干掉了其中一种，还用了“李代桃僵”法。为什么不更规范点，令 range() 生成的是迭代器呢？

关于这个问题，我没找到官方解释，以下纯属个人观点 。

zip() 等方法都需要接收确定的可迭代对象的参数，是对它们的一种再加工的过程，因此也希望马上产出确定的结果来，所以 Python 开发者就设计了这个结果是迭代器。这样还有一个好处，即当作为参数的可迭代对象发生变化的时候，作为结果的迭代器因为是消耗型的，不会被错误地使用。

而 range() 方法就不同了，它接收的参数不是可迭代对象，本身是一种初次加工的过程，所以设计它为可迭代对象，既可以直接使用，也可以用于其它再加工用途。例如，zip() 等方法就完全可以接收 range 类型的参数。

>>> for i in zip(range(1,6,2), range(2,7,2)):
>>>    print(i, end="")
(1, 2)(3, 4)(5, 6)

也就是说，range() 方法作为一种初级生产者，它生产的原料本身就有很大用途，早早把它变为迭代器的话，无疑是一种画蛇添足的行为。

对于这种解读，你是否觉得有道理呢？欢迎就这个话题与我探讨。

3、range 类型是什么？

以上是我对“为什么 range()不产生迭代器”的一种解答。顺着这个思路，我研究了一下它产生的 range 对象，一研究就发现，这个 range 对象也并不简单。

首先奇怪的一点就是，它竟然是不可变序列！我从未注意过这一点。虽然说，我从未想过修改 range() 的值，但这一不可修改的特性还是令我惊讶。

翻看文档，官方是这样明确划分的——有三种基本的序列类型：列表、元组和范围（ range ）对象。（ There are three basic sequence types: lists, tuples, and range objects.）

这我倒一直没注意，原来 range 类型居然跟列表和元组是一样地位的基础序列！我一直记挂着字符串是不可变的序列类型，不曾想，这里还有一位不可变的序列类型呢。

那 range 序列跟其它序列类型有什么差异呢？

普通序列都支持的操作有 12 种，在《你真的知道 Python 的字符串是什么吗？》这篇文章里提到过。range 序列只支持其中的 10 种，不支持进行加法拼接与乘法重复。

>>> range(2) + range(3)
-----------------------------------------
TypeError  Traceback (most recent call last)
...
TypeError: unsupported operand type(s) for +: 'range' and 'range'

>>> range(2)*2
-----------------------------------------
TypeError  Traceback (most recent call last)
...
TypeError: unsupported operand type(s) for *: 'range' and 'int'

那么问题来了：同样是不可变序列，为什么字符串和元组就支持上述两种操作，而偏偏 range 序列不支持呢？虽然不能直接修改不可变序列，但我们可以将它们拷贝到新的序列上进行操作啊，为何 range 对象连这都不支持呢？

且看官方文档的解释：

...due to the fact that range objects can only represent sequences that follow a strict pattern and repetition and concatenation will usually violate that pattern.

原因是 range 对象仅仅表示一个遵循着严格模式的序列，而重复与拼接通常会破坏这种模式...

问题的关键就在于 range 序列的 pattern，仔细想想，其实它表示的就是一个等差数列啊（喵，高中数学知识没忘...），拼接两个等差数列，或者重复拼接一个等差数列，想想确实不妥，这就是为啥 range 类型不支持这两个操作的原因了。由此推论，其它修改动作也会破坏等差数列结构，所以统统不给修改就是了。

4、小结

回顾全文，我得到了两个偏冷门的结论：range 是可迭代对象而不是迭代器； range 对象是不可变的等差序列。

若单纯看结论的话，你也许没有感触，或许还会说这没啥了不得啊。但如果我追问，为什么 range 不是迭代器呢，为什么 range 是不可变序列呢？对这俩问题，你是否还能答出个自圆其说的设计思想呢？（ PS：我决定了，若有机会面试别人，我必要问这两个问题的嘿~）

由于 range 对象这细微而有意思的特性，我觉得这篇文章写得值了。本文是作为迭代器系列文章的一篇来写的，所以对于迭代器的基础知识介绍不多，欢迎查看之前的文章。另外，还有一种特殊的迭代器也值得单独成文，那就是生成器了，敬请期待后续推文哦~

猜你想读：

Python 进阶：迭代器与迭代器切片

Python 进阶：设计模式之迭代器模式

你真的知道 Python 的字符串是什么吗？

-----------------

本文原创并首发于微信公众号 [ Python 猫] ，后台回复“爱学习”，免费获得 20+本精选电子书。

[hv3s1]

所以节约运算的方式使用 xrange。
然后这篇文章我以前就看过，麻烦转载也留个别人的链接和转载注明行吗。

[chinesehuazhou]

@hv3s1 对于你这种张开眼睛说瞎话的本事，我很佩服！！

[welkinzh]

冲着这个标题里的括号，我也要进来赞一下，希望别的推广也能这么做

[chinesehuazhou]

@welkinzh 这是个有效的挡箭牌，可以过滤掉很多噪声

[fan2006]

学习了。语言也是需要宣传的。毕竟还有很多像我这种不是做程序员的也会用啊、

[houzhimeng]

看到掘金推送本文了

[chinesehuazhou]

@houzhimeng 没错，我同时发的

[rogwan]

楼主怎么不取名 [Python 蛇]？ 猫有点不搭介？

[chinesehuazhou]

@rogwan 因为 Python 猫是一只猫的名字，喵

[hanxiaomeng]

@rogwan 因为猫会抓蛇呀，也就是猫能搞定蛇，也就是说楼主可以搞定 Python 咯。

[chinesehuazhou]

@hanxiaomeng 确实有这个理想

[aijam]

感觉没抓住重点，其实就是 Iterable 和 Iterator 的区别。
通俗地说，
- 能把里面的内容“逐一”取的容器是 Iterable，比如 list、string、dict 等。range 属于这一类。
- 为了将 Iterable 容器里的内容“逐一”取出来，我们需要通过 Iterator （即迭代器）。通过 iter()我们可以获得一个 Iterable 对应的 Iterator。
比如，
[1,2,3]是 list，所以是 Iterable，但它本身不是 Iterator。iter([1,2,3])才是它对应的 Iterator。
同理，range(10)也是 Iterable 而不是 Iterator。iter(range(10))才是它对应的 Iterator。
在实际代码中，
Iterator 最大的特点是“一次性”，用完了就不能用第二次。
比如，range 对象是可以多次用的。
r = range(5)
for i in r: print(i) # print 0 to 4
for i in r: print(i) # print 0 to 4
而如果返回的是 Iterator，你就只能用一次。
it = iter(range(5))
for i in it: print(i) # print 0 to 4
for i in it: print(i) # print nothing
range 范围作为一个“实体”概念，设计成可复用的 Iterable 更合理，这和 map/filter/zip 这些作为一次性“操作”存在的概念略有不同。当然这一定程度上也有 py2 的历史原因，过去无论 range/map/sorted 都统一返回 list，为了性能优化 py3 才分别返回 Iterable, Iterator 和 list。

[laike9m]

我觉得你的理解是对的。说的更简洁点，为什么 range 不是 iterator，因为 range 必须是 immutable 的（毕竟没人希望每次遍历 range 得到不同的结果），而 iterator 一定含有内部状态，这和 immutable 矛盾，因此 range 不能使 iterator。

[chinesehuazhou]

@aijam 这是系列文章，之前写过很详细的文章比较了两者差别，所以这里简单提及。关键在于你说的可复用，以及
@laike9m 说的 immutable，看来我说的对了

[hanxiaomeng]

@chinesehuazhou 头像竟然是杀生丸，我微信头像是米勒法师 hiahia

[chinesehuazhou]

@hanxiaomeng 不认识米勒法师😂

[trait]

赞
年初读过一篇也是讲 range is not an iterator
https://treyhunner.com/2018/02/python-range-is-not-an-iterator/

[chinesehuazhou]

@trait 我也看到了，它写的只是结论，而我主要关心的是原因

[silkriver]

迭代器的关键在于它是一次性消耗品，不适合 range 的应用场合

[lihongjie0209]

@aijam 这个观点不错

[SingeeKing]

没有公众号二维码，差评……


AND 利用盗版电子书作为推广手段实在不是一件好的行为

[aijam]

@chinesehuazhou 较真的说，本主题和 mutability 关系不大。
@laike9m 的说法混淆了 stateful 和 mutability 的侧重点，说 iterator 是 stateful 更适合。
同样作为 Iterable，list/dict/set 是 mutable 的，而 range/tuple/fronzenset 是 immutable 的。
是否是 Iterable 只和他们能不能被“逐一”读取有关，和它们能否被修改无关。
Iterator 的出现原本是为了解决无 index 的 Iterable 如何逐一读取的问题，比如 list 你能用 index 读取元素但 set 就不行。造成的结果是，相比通过递增 index 来逐一读取，用了 iterator 反而是让修改容器变得更困难（更 immutable 了）。
这和“不用 iterator 是由于 range 必须 immutable ”这种说法逻辑上是矛盾的。

[chinesehuazhou]

@SingeeKing 电子书手段确实不好，无可辩驳。多谢指出。

[laike9m]

@aijam “ immutable ” 的确不准确。我想表达的意思是不含有关于遍历的内部状态。这和 list, dict, set 是一样的。

[laike9m]

@aijam 不过 immutable(通常意义下的） 的确是非 iterator 的充分条件，只不过不是必要条件罢了

[a226679594]

语言也是需要宣传的。毕竟还有很多像我这种不是做程序员的也会用啊、

[lrxiao]

iterable 是不是 iterator 就__iter__是不是 return self
就是不能在 self 里存状态啊。。。

[xpresslink]

我觉得作者有些基本的 Python 概念是错误的。
1、range() 是什么？
……
对于 range() 函数，有几个注意点
……
这个说法是非常明显有错误的，range 不是内置函数（ builtin method ）而是个类对象，在 python 里面不要见到用括号调用的东西就认为是函数，类似的还是有很多，如 list, set, tuple, dict 等，这些都是类, 特别是 enumerate 这个学 python 的人十有八九认为是函数而不知道是类，加了括号是实例化而不是函数调用。

python 中类的实例化和函数调用非常容易对新手有大的迷惑性，相对来说在 java 中有明确的 new 关键字加在构造方法前面概念更清楚一些。

[blackjar]

range 继承自 collections.abc.Sequence 是一个 iterable(关键在于实现了__iter__()) 所以跟 iterator 是两回事 iterable 跟 iterator 严格区分在__next__()方法 这些概念没什么可纠结的。。

[chinesehuazhou]

@xpresslink 这里有官方文档： https://docs.python.org/3/library/functions.html ；较真地说，确实和其它内置函数不同，文档里确实指出了。不过，最终还是把它归到了 Built-in Functions 里来的

[chinesehuazhou]

@blackjar 你这是一个思路，学习了。我原本以为它是迭代器，认知错误了，不是想纠结概念，而是想建立正确的认知

[chinesehuazhou]

@xpresslink 刚发现个有意思的地方。https://docs.python.org/2.7/library/functions.html#built-in-functions ； python2 里面，把 range() 和 xrange() 都称为方法，并没有 type 的区别，只是到了 3 里面，才改了说法。这可能也是很多人造成误解的原因吧