跟老齐学Python之关于循环的小伎俩

概述不是说while就不用，比如前面所列举而得那个猜数字游戏，在业务逻辑上，用while就更容易理解（当然是限于那个游戏的业务需要而言）。另外，在某些情况下，for也不是简单地把对象中的元素遍历一遍，比如有有隔一个取一

不是说while就不用，比如前面所列举而得那个猜数字游戏，在业务逻辑上，用while就更容易理解（当然是限于那个游戏的业务需要而言）。另外，在某些情况下，for也不是简单地把对象中的元素遍历一遍，比如有有隔一个取一个的要求，等等。

在编写代码的实践中，为了对付循环中的某些要求，需要用一些其它的函数，比如前面已经介绍过的range就是一个被看做循环中的计数器的好东西。

range

在《有容乃大的List(4)》中，专门对range()这个内置函数做了详细介绍，看官可以回到那节教程复习一番。这里重点是复习并展示一下它的for循环中，做为计数器的使用。

还记得曾经在教程中有一个问题：列出100以内被3整除的数。下面引用那个问题的代码和运行结果。

复制代码 代码如下:
#! /usr/bin/env python
#Coding:utf-8

aliquot = []

for n in range(1,100):
    if n%3 == 0:
        aliquot.append(n)

print aliquot

代码运行结果：

复制代码 代码如下:
[3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99]

这个问题，如果改写一下（也有网友在博客中提出了改写方法）

复制代码 代码如下:
>>> aliquot = [ x for x in range(1,100) if x%3==0 ] #用List解析，本质上跟上面无太大差异
>>> aliquot
[3,99]

>>> aliquot = range(3,100,3)    #这种方法更简单。这是博客中一网友提供。
>>> aliquot
[3,99]

如果有一个由字母组成的字符串，只想隔一个从字符串中取一个字母。可以这样来实现，这是range()的一个重要用途。

复制代码 代码如下:
>>> one = "Ilikepython"
>>> new_List = [ one[i] for i in range(0,len(one),2) ]
>>> new_List
['I','i','e','y','h','n']

当然，间隔的举例，是可以任意指定的。还是前面那个问题，还可以通过下面的方式，选出所有能够被3整除的数。

复制代码 代码如下:
>>> all_int = range(1,100)
>>> all_int
[1,2,3,4,5,7,8,10,11,13,14,16,17,19,20,22,23,25,26,28,29,31,32,34,35,37,38,40,41,43,44,46,47,49,50,52,53,55,56,58,59,61,62,64,65,67,68,70,71,73,74,76,77,79,80,82,83,85,86,88,89,91,92,94,95,97,98,99]
>>> aliquot = [ all_int[i] for i in range(len(all_int)) if all_int[i]%3==0 ]
>>> aliquot
[3,99]

通过上述实例，主要是让看官理解range()在for循环中计数器的作用。

zip

在《难以想象的for》中，已经对zip进行了介绍，此处还要提到这个函数，不仅仅是复习，还能深入一下，更主要是它也会常常被用到循环之中。

zip是用于并行遍历的函数。

比如有两个List，元素是由整数组成，如果计算对应位置元素的和。一种方法是通过循环，分别从两个List中取出元素，然后求和。

复制代码 代码如下:
>>> List1 = range(2,2)
>>> List1
[2,8]
>>> List2 = range(11,2)
>>> List2
[11,19]
>>> result = [ List1[i]+List2[i] for i in range(len(List1)) ]
>>> result
[13,25]

正如在《for循环语句》中讲述的那样，上面的方法不是很完美，在上一讲中有比较完美一点的代码，请看官欣赏。

zip完成上面的任务，是这么做的：

复制代码 代码如下:
>>> List1
[2,8]
>>> List2
[11,19]
>>> for a,b in zip(List1,List2):
...     print a+b,
...
13 17 21 25

zip()的作用就是把List1和List2两个对象中的对应元素放到一个元组(a,b)中，然后对这两个元素进行 *** 作。

复制代码 代码如下:
>>> List1
[2,19]
>>> zip(List1,List2)
[(2,11),(4,13),(6,15),(8,17)]

对这个功能，看官可以理解为，将两个List压缩成为(zip)一个List，只不过找不到配对的就丢掉了。

能够压缩，也能够解压缩，用下面的方式就是反过来了。

复制代码 代码如下:
>>> result = zip(List1,List2)
>>> result
[(2,17)]
>>> zip(*result)
[(2,8),(11,17)]

列位注意观察，解压缩得到的结果，跟前面压缩前的结果相比，第二项就少了一个元素19，因为在压缩的时候就丢掉了。

这似乎跟for没有什么关系呀。别着急，思考一个问题，看看如何求解：

问题描述：有一个dictionary，myinfor = {"name":"qiwsir","site":"qiwsir.github.io","lang":"python"},将这个字典变换成：infor = {"qiwsir":"name","qiwsir.github.io":"site","python":"lang"}

解法有几个，如果用for循环，可以这样做（当然，看官如果有方法，欢迎贴出来）。

复制代码 代码如下:
>>> infor = {}
>>> for k,v in myinfor.items():
...     infor[v]=k
...
>>> infor
{'python': 'lang','qiwsir.github.io': 'site','qiwsir': 'name'}

下面用zip()来试试：

复制代码 代码如下:
>>> dict(zip(myinfor.values(),myinfor.keys()))
{'python': 'lang','qiwsir': 'name'}

呜呼，这是什么情况？原来这个zip()还能这样用。是的，本质上是这么回事情。如果将上面这一行分解开来，看官就明白其中的奥妙了。

复制代码 代码如下:
>>> myinfor.values()    #得到两个List
['python','qiwsir','qiwsir.github.io']
>>> myinfor.keys()
['lang','name','site']
>>> temp = zip(myinfor.values(),myinfor.keys())     #压缩成一个List，每个元素是一个tuple
>>> temp
[('python','lang'),('qiwsir','name'),('qiwsir.github.io','site')]

>>> dict(temp)                          #这是函数dict()的功能，将上述列表转化为dictionary
{'python': 'lang','qiwsir': 'name'}

至此，是不是明白zip()和循环的关系了呢？有了它可以让某些循环简化。特别是在用python读取数据库的时候（比如MysqL），zip()的作用更会显现。

enumerate

enumerate的详细解释，在《再深点，更懂List》中已经有解释，这里姑且复习。

如果要对一个列表，想得到其中每个元素的偏移量（就是那个脚标）和对应的元素，怎么办呢？可以这样：

复制代码 代码如下:
>>> myList = ["qiwsir",703,"python"]
>>> new_List = []
>>> for i in range(len(myList)):
...     new_List.append((i,myList[i]))
...
>>> new_List
[(0,'qiwsir'),(1,703),(2,'python')]

enumerate的作用就是简化上述 *** 作：

复制代码 代码如下:
>>> enumerate(myList)
<enumerate object at 0xb74a63c4>    #出现这个结果，用List就能显示内容.类似的会在后面课程出现，意味着可迭代。
>>> List(enumerate(myList))
[(0,'python')]

对enumerate()的深刻阐述，还得看这个官方文档：

复制代码 代码如下:
class enumerate(object)
| enumerate(iterable[,start]) -> iterator for index,value of iterable
|
| Return an enumerate object. iterable must be another object that supports
| iteration. The enumerate object yIElds pairs containing a count (from
| start,which defaults to zero) and a value yIElded by the iterable argument.
| enumerate is useful for obtaining an indexed List:
| (0,seq[0]),seq[1]),seq[2]),...
|
| Methods defined here:
|
| getattribute(...)
| x.getattribute('name') <==> x.name
|
| iter(...)
| x.iter() <==> iter(x)
|
| next(...)
| x.next() -> the next value,or raise stopiteration

Data and other attributes defined here:
new =
T.new(S,...) -> a new object with type S,a subtype of T

对官方文档，有的朋友可能看起来有点迷糊，不要紧，至少浏览一下，看个大概。因为随着个人实践的越来越多，对文档的含义理解会越来越深刻。这就好比令狐冲，刚刚学习了独孤九剑的口诀和招式后，理解不是很深刻，只有在不断的打打杀杀实践中，特别跟东方不败等高手过招之后，才能越来越体会到独孤九剑中的奥妙。

总结

以上是内存溢出为你收集整理的跟老齐学Python之关于循环的小伎俩全部内容，希望文章能够帮你解决跟老齐学Python之关于循环的小伎俩所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。