例子：

井字游戏，有时也被称为“进攻和防守”，是一个两人玩家（X和O）轮流标志着3×3的网格的空间的连珠游戏。最先在任意一条直线（水平线，垂直线或对角线）上成功连接三个标记的一方获胜。

但我们不去玩这个游戏。你将是这个游戏的裁判。你被赋予游戏的结果，以及你必须判断游戏是平局还是有人胜出，以及谁将会成为最后的赢家。如果X玩家获胜，返回“X”。如果O玩家获胜，返回“O”。如果比赛是平局，返回“D”。

x-o-referee

游戏的结果是作为字符串形式的列表，其中“X”和“O”是玩家的标志，“.”是空格。

输入: 游戏结果作为字符串形式的列表(Unicode)。

输出: “X”，“O”或“D”作为字符串形式。

范例:

checkio([
“X.O”,
“XX.”,
“XOO”]) == “X”
checkio([
“OO.”,
“XOX”,
“XOX”]) == “O”
checkio([
“OOX”,
“XXO”,
“OXX”]) == “D”

如何使用： 此任务中的概念将有助于您遍历数据类型。这还可以用在游戏的算法上，让你知道如何去检查结果。

最多推荐的解法：

def checkio(result):rows = resultcols = map(''.join, zip(*rows))diags = map(''.join, zip(*[(r[i], r[2 - i]) for i, r in enumerate(rows)]))lines = rows + list(cols) + list(diags)
​return 'X' if ('XXX' in lines) else 'O' if ('OOO' in lines) else 'D'

上面的最多推荐的解法，步骤是：
1.将列表result中的3个元素拆开成3个tuple（tuple是列的元素组合）

>>> result = [
… “OOX”,
… “XXO”,
… “OXX”]
>>> rows = result
>>> for i in zip(*rows):
… print(i)
…
(‘O’, ‘X’, ‘O’)
(‘O’, ‘X’, ‘X’)
(‘X’, ‘O’, ‘X’)
>>>

2.获取对角线上的元素组合
3.行上的元素组合+列上的元素组合+对角线元素组合，然后判断胜利方

zip的用法：

>>> help(zip)
Help on class zip in module builtins:
class zip(object)
| zip(iter1 [,iter2 […]]) –> zip object
|
| Return a zip object whose .next() method returns a tuple where
| the i-th element comes from the i-th iterable argument. The .next()
| method continues until the shortest iterable in the argument sequence
| is exhausted and then it raises StopIteration.
|
| Methods defined here:
|
| getattribute(self, name, /)
| Return getattr(self, name).
|
| iter(self, /)
| Implement iter(self).
|
| new(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| next(self, /)
| Implement next(self).
|
| reduce(…)
| Return state information for pickling.

zip输入参数是一些迭代器，执行完成之后返回zip object（迭代器 ,tuple list）。

zip用法中需要注意的是：
1.zip是将每个可迭代对象的对应位置元素打包成一个tuple组，例如：

二维矩阵变换（矩阵的行列互换）
比如我们有一个由列表描述的二维矩阵
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
利用zip函数：
>>> a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> zip(*a)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> map(list,zip(*a))
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

2.(*)操作符与zip函数配合可以实现与zip相反的功能,即将合并的序列拆成多个tuple，如解法中的zip(*rows)。如：

>>>x=[1,2,3],y=[‘a’,’b’,’c’]
>>>zip(*zip(x,y))
[(1,2,3),(‘a’,’b’,’c’)]

3.新的序列的长度以参数中最短的序列为准.

>>>x=[1,2],y=[‘a’,’b’,’c’]
>>>zip(x,y)
[(1,’a’),(2,’b’)]

zip另有一些高级用法：
1.python列表相邻元素压缩：

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

强烈推荐阅读：https://segmentfault.com/q/1010000000612945

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

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

如果不用迭代器？

>>> 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，以次类推，过程模拟如下表示
x.next -> 1
x.next -> 2
zip(x.next(), x.next()) —> zip(1, 2)
x.next -> 3
x.next -> 4
zip(x.next(), x.next()) —> zip(3, 4)
….

等价于下面的方式

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

所以代码：

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

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

2.使用zip反转字典
>>> m = {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4}
>>> m.items()
[(‘a’, 1), (‘c’, 3), (‘b’, 2), (‘d’, 4)]
>>> zip(m.values(), m.keys())
[(1, ‘a’), (3, ‘c’), (2, ‘b’), (4, ‘d’)]
>>> mi = dict(zip(m.values(), m.keys()))
>>> mi
{1: ‘a’, 2: ‘b’, 3: ‘c’, 4: ‘d’}

3.使用zip和iterators生成滑动窗口 (n -grams)

>>> from itertools import islice
>>> def n_grams(a, n):
… z = (islice(a, i, None) for i in range(n))
… return zip(*z)
…
>>> a = [1, 2, 3, 4, 5, 6]
>>> n_grams(a, 3)
[(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]
>>> n_grams(a, 2)
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
>>> n_grams(a, 4)
[(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]
#
islice的用法：

islice() seq, [start,] stop [, step] elements from seq[start:stop:step] islice(‘ABCDEFG’, 2, None) –> C D E F G
测试islice：
>>> a = [1, 2, 3, 4, 5, 6]
>>> for x in islice(a,0,None):
… print(x)
…
1
2
3
4
5
6
>>> a = [1, 2, 3, 4, 5, 6]
>>> for x in islice(a,1,None):
… print(x)
…
2
3
4
5
6
>>> a = [1, 2, 3, 4, 5, 6]
>>> for x in islice(a,2,None):
… print(x)
…
3
4
5
6
>>>

注：例题解法来自 https://checkio.org/
我在 https://checkio.org/user/penn201500/ ：）

---

参考：

PYTHON-进阶-ITERTOOLS模块小结

Python零碎知识(2):强大的zip

python列表相邻元素压缩器