程序语言中的流程控制语句用于控制计算操作执行的次序. 次序分为: 顺序, 分支, 循环. 顺序, 就是字面含义, 从上至下的运行; 分支, 根据各种条件, 进入相应的程序块; 循环, 即多次进入相同的程序块.
Python语言中分支的实现, 借助于if语句, 其一般形式如下:
if <test1>:
<statements1>
elif <test2>:
<statements2>
else:
<statements3>
当if语句执行时, Python会执行测试第一个计算结果为真的代码块, 或者如果所有测试都为假时, 就执行else块.
if语句举例如下:
In [1]: x = 'killer rabbit'
In [2]: if x == 'roger':
...: print("how's jessica?")
...: elif x == 'bugs':
...: print("what's up doc?")
...: else:
...: print('Run away! Run away!')
...:
Run away! Run away!
另外, 对于下面形式的代码:
if X:
A = Y
else:
A = Z
还有个等价的形式, A = Y if X else Z, 即if/else三元表达式.
Python语言中循环的实现, 借助于while和for语句.
while语句一般形式如下:
while <test>:
<statements1>
else: # Optional else
<statements2> # Run if didn't exit loop with break
Python会一直计算开头的测试, 然后执行循环主体内的语句, 直到测试返回假值为止, 之后执行可选的else部分. 若在循环主体内遇到break语句而退出, 即使有else部分, 也不会执行.
while语句举例如下:
In [3]: x = 'spam'
In [4]: while x:
...: print(x, end=' ')
...: x = x[1:]
...:
spam pam am m
上面说到了break语句, 还有一个与之对应的continue语句, 它们都可以出现在while(还有后面要说到的for)循环主体的任何地方. break跳出最近所在的循环, continue则跳到最近所在循环的开头. 更一般的格式如下:
while <test1>:
<statements1>
if <test2>: break # Exit loop now, skip else
if <test3>: continue # Go to top of loop now, to test1
else:
<statements2> # Run if didn't hit a 'break'
下面看看for循环, 其在Python中是一个通用的序列迭代器, 可以遍历任何有序的序列对象内的元素.
一般格式如下:
for <target> in <object>: # Assign object items to target
<statements> # Repeated loop body: use target
else:
<statements2> # if didn't hit a 'break'
Python运行for循环时, 会逐个将序列对象中的元素赋值给目标, 然后为每个元素执行循环主体.
for语句举例如下:
In [5]: for x in ['spam', 'eggs', 'ham']:
...: print(x, end=' ')
...:
spam eggs ham
编写循环的技巧, 并行遍历zip, ;产生偏移和元素enumerate.
zip举例:
In [7]: L1 = [1, 2, 3, 4]
In [8]: L2 = [5, 6, 7, 8]
In [9]: for (x, y) in zip(L1, L2):
...: print(x, y, '---', x + y)
...:
1 5 --- 6
2 6 --- 8
3 7 --- 10
4 8 --- 12
enumerate举例:
In [11]: for (offset, item) in enumerate(S, 1):
...: print(item, 'appears at offset', offset)
...:
s appears at offset 1
p appears at offset 2
a appears at offset 3
m appears at offset 4
刚才介绍for循环时, 说到其是一个通用的序列迭代器, 可以遍历任何有序的序列对象内的元素, 如列表, 元组以及字符串. 实际, for循环可用于任何可迭代的对象.
可迭代对象是什么呢, 如果对象是实际保存的序列, 或可以在迭代工具环境中一次产生一个结果的对象, 就看做是可迭代的.
那迭代器又是什么呢, 先从文件迭代器来说, 已打开的文件对象有一个方法名为readline, 可以一次从一个文件中读取一行文本, 每次调用readline方法时, 就会前进到下一行. 到达文件末尾时, 就会返回空字符串, 可通过它来检测, 从而跳出循环.
In [48]: f = open('test.py')
In [49]: f.readline()
Out[49]: 'import sys\n'
In [50]: f.readline()
Out[50]: '\n'
In [51]: f.readline()
Out[51]: 'print(sys.path)\n'
In [52]: f.readline()
Out[52]: ''
文件对象还有一个方法, 名为__next__, 差不多有相同的效果, 每次调用时, 就会返回文件中的下一行. 唯一的区别在于, 到达文件末尾时, __next__会引发内置的StopIteration异常, 而不是返回空字符串.
In [53]: f = open('test.py')
In [54]: f.__next__()
Out[54]: 'import sys\n'
In [55]: f.__next__()
Out[55]: '\n'
In [56]: f.__next__()
Out[56]: 'print(sys.path)\n'
In [57]: f.__next__()
---------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-57-dcf180275632> in <module>()
----> 1 f.__next__()
StopIteration:
这个接口描述的就是Python中的迭代协议: 实现了__next__方法的对象, 会前进到下一个结果, 而到达一系列结果的末尾时, 则会引发StopIteration异常. 至此, 可以说明, 文件迭代器, 实现了迭代协议.
看下更为通用的for循环, 当for循环开始时, 会通过它将可迭代对象传递给iter内置函数, 以便从可迭代对象获得一个迭代器, 返回的对象就是迭代器了, 其实现了迭代协议.
In [60]: L = [1, 2, 3]
In [61]: I = iter(L)
In [62]: I.__next__()
Out[62]: 1
In [63]: I.__next__()
Out[63]: 2
In [64]: I.__next__()
Out[64]: 3
In [65]: I.__next__()
---------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-65-a7fa90893753> in <module>()
----> 1 I.__next__()
StopIteration:
最初的一步对于文件来说不是必需的, 文件有自己的__next__方法, 不需要再像那样返回一个对象了, 文件对象就是自己的迭代器.
In [73]: f = open('test.py')
In [74]: iter(f) is f
Out[74]: True
In [75]: f.__next__()
Out[75]: 'import sys\n'
对于列表, 以及很多其它的内置对象, 不是自身的迭代器, 必须调用iter来启动迭代.
In [76]: L = [1, 2, 3]
In [77]: iter(L) is L
Out[77]: False
In [78]: L.__next__()
---------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-78-98b0c0707a44> in <module>()
----> 1 L.__next__()
AttributeError: 'list' object has no attribute '__next__'
In [79]: I = iter(L)
In [80]: I.__next__()
Out[80]: 1
尽管Python中的迭代工具会自动调用这些函数, 也可以使用它们来手动应用迭代协议. 下面的例子展示了自动和手动迭代, 结果是等效的.
In [81]: L = [1, 2, 3]
In [82]: for X in L:
...: print(X ** 2, end=' ')
...:
1 4 9
In [83]: I = iter(L)
In [84]: while True:
...: try:
...: X = I.__next__()
...: except StopIteration:
...: break
...: print(X ** 2, end=' ')
...:
1 4 9
若感兴趣可关注订阅号”数据库最佳实践”(DBBestPractice).
原文地址：http://blog.51cto.com/coveringindex/2085326