python列表相邻元素压缩器

请问各位以下代码中:

group_adjacent = lambda a, k: zip(*([iter(a)] * k))

这句是表达了什么内容呢？

>>> a = [1, 2, 3, 4, 5, 6]
>>> zip(*([iter(a)] * 2))
[(1, 2), (3, 4), (5, 6)]

>>> group_adjacent = lambda a, k: zip(*([iter(a)] * k))
>>> group_adjacent(a, 3)
[(1, 2, 3), (4, 5, 6)]

理解这个问题主要由三个点

迭代器

先说第一个 python 的迭代器。iter() 能把一个序列生成为一个和迭代器，迭代器的特点是可以用 for in 语句迭代，原理是迭代器对象有一个next方法，可以每次移动迭代的指针，一旦迭代完，没有下一个元素的时候，会应发一个 StopIteration 异常。例如下面的代码

>>> a
[1, 2, 3, 4, 5, 6]
>>> x = iter(a)
>>> x
<listiterator object at 0x101015090>
>>> x.next()
1
>>> x.next()
2
>>> x.next()
3
>>> x.next()
4
>>> x.next()
5
>>> x.next()
6
>>> x.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

迭代器的特点就是，迭代了一次之后，指针就移动了，不会自动回溯。例如可以用 for in 列表 a 无数次，却只能for in 迭代器 x 一次。

>>> x = iter(a)
>>> for i in x:
...     print i
... 
1
2
3
4
5
6
>>> for i in x:
...     print i   # x 已经被迭代过了，是迭代的指针没有回去，理解为被清空了。
... 
>>>

zip 函数

zip 可以将两个序列对应着打包。例如

>>> a1 = [1, 3, 5]
>>> a2 = [2, 4, 6]
>>> zip(a1, a2)
[(1, 2), (3, 4), (5, 6)]
>>>

提问中的 * 是python函数可变参数的一种表示方式，加 * 的表示传入一个元祖对象进行解包。例如：

>>> t = (a1, a2)
>>> zip(t)                   # 不加 * 号，zip 只有一个参数 t
[([1, 3, 5],), ([2, 4, 6],)]
>>> zip(*t)                  # 加 * 号的作用就是将元祖t，解包成a1, a2 为 zip的两个函数参数
[(1, 2), (3, 4), (5, 6)]
>>>

下一步就是，为何要用迭代器呢？如果不用迭代器？

>>> a = [1, 2, 3, 4, 5, 6]
>>> x = iter(a)
>>> t = [a, a]
>>> zip(*t)                 # 1
[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]  
>>> tx = [x, x]                                   
>>> zip(*tx)                # 2
[(1, 2), (3, 4), (5, 6)]
>>>

#1 这里的含义表示zip 传了两个参数a，a1 a2 都是a，所以就打包了这两个序列。
#2 这里面因为 x 是迭代器对象，迭代就调用 next 方法，之后就不会有了。也就是 zip 执行打包的过程先调用第一个参数的 x 的 next 方法得 1，然后调用第二个参数的 x 的next，因为这两个x对象实际上是一样的，调用第二个 x 的 next 方法的时候，迭代的指针已经移动，实际得到的时2，以次类推，过程模拟如下表示

    1 x.next -> 1
    2 x.next -> 2
    3 zip(x.next(), x.next()) ---> zip(1, 2)
    4 x.next -> 3
    5 x.next -> 4
    6 zip(x.next(), x.next()) ---> zip(3, 4)
    ....

等价于下面的方式

zip([1, 3, 5], [2, 4, 6])

lambda 匿名函数

lambda express: express  返回一个可以调用的对象，可以理解为函数
double = lambda x : return x * 2

等价于

def double(x):
    retrun x * 2

最后

group_adjacent = lambda a, k: zip(*([iter(a)] * k))

表示定义一个匿名函数，参数是 a和k，并绑定变量 group_adjacent。匿名函数的主体内容是，用iter将序列迭代化，然后用zip打包这个迭代器对象。

理解上面三个东西的用法，还是比较简单的，貌似被我解释得很复杂，有很多操作和术语按照个人的理解解释，说得不准确的希望海涵，并指出错误啦。

【热门文章】