0.说明
提及的内容为：if、while、for及与他们相搭配的else、elif、break、continue和pass语句。
1.if语句
1
2
|
if expression:
expr_true_suite
|
其中对于expression部分可以使用逻辑连接词an、or和not来实现多重判断条件。
即如果只有一个语句执行时，可以写成下面这样：
但还是建议写在不同的行。
2.else语句
1
2
3
4
|
if expression:
expr_true_suite
else:
expr_false_suite
|
像C语言这种使用括号来分隔代码块的语言会出现这种情况（即在有多个if语句蛙，else语句不知道是属于哪一个if语句的），但由于Python是强制使用缩进来使代码对齐的，因此不可能会出现这种问题。
3.elif语句
1
2
3
4
5
6
7
8
9
10
11
|
if expression1:
expr1_true_suite
elif expression2:
expr2_true_suite
elif expression3:
expr3_true_suite
……
elif expressionN:
expr1_true_suite
else:
none_of_the_above_suite
|
可以有任意数量的elif语句，但只能有一个else语句。
在C语言中有switch/case语句用于在多个选项中进行选择，Python虽然没有switch/case语句，但却有更好的解决方案来实现同样的功能：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#方案一：大量的if-elif语句
if user.cmd == 'create':
action = 'create item'
elif user.cmd == 'delete':
action = 'delete item'
elif user.cmd == 'update':
action = 'update item'
#方案二：用序列和成员关系操作符
if user.cmd in ('create', 'delete', 'update'):
action = '%s item' % user.cmd
else:
action = 'invalid choice... try again!'
#方案三：使用字典
msgs = {'create', 'create item',
'delete': 'delete item',
'update': 'update item'}
default = 'invalid choice... try again!'
action = msgs.get(user.cmd, default)
#使用映射对象（比如字典）的一个最大好处就是它的搜索操作比类似if-elif-else语句或是for循环这样的序列查询要快很多
|
可以看到，对于实现同样的功能，Python中的解决方案更加强大和简洁。
4.条件表达式（三元操作符）
使用如下：
1
2
3
4
|
>>> x, y =4, 3
>>> smaller = x if x < y else y
>>> smaller
3
|
5.while语句
1
2
|
while expression:
suite_to_repeat
|
1
2
3
4
|
count = 0
while (count < 9):
print 'the index is: ',count
count += 1
|
1
2
|
while True:
suite_to_repeat
|
无限循环主要是用在Server/Client模式中Server端的设计，用以等待来自客户端的连接，当然如果有必要的话也是可以通过break语句来结束循环的。
6.for语句
for语句提供了Python中最强大的循环结构，它可以遍历序列成员，可以用在列表解析和生成器表达式中，它会自动地调用迭代器的next()方法，捕获StopIteration异常并结束循环（这一切都是在内部发生的）。
（1）语法
1
2
|
for iter_var in iterable:
suite_to_repeat
|
每次循环，iter_var抚迭代变量被设置为可迭代对象iterable（序列、迭代器或其他支持迭代的对象）的当前元素，提供给suite_to_repeat语句使用。
（2）用于序列类型
主要是下面用于序列迭代的三种方法：
1
2
3
4
5
6
7
|
>>> nameList = ['xpleaf', 'clyyh', 'cl']
>>> for name in nameList:
... print name
...
xpleaf
clyyh
cl
|
1
2
3
4
5
6
7
|
>>> nameList = ['xpleaf', 'clyyh', 'cl']
>>> for nameIndex in range(len(nameList)):
... print nameList[nameIndex]
...
xpleaf
clyyh
cl
|
显然会比第一种方法慢很多。
1
2
3
4
5
6
7
|
>>> nameList = ['xpleaf', 'clyyh', 'cl']
>>> for nameIndex, name in enumerate(nameList):
... print nameIndex, name
...
0 xpleaf
1 clyyh
2 cl
|
（3）用于迭代器类型
for语句用于迭代器时，会自动帮我们处理很多问题（在内部调用next()并处理StopIteration异常），不过需要注意的是，迭代器并不代表循环条目的集合。
（4）range()内建函数
range()可以用来生成一个数字顺序列表，从而可以使用for来进行迭代，它主要有以下两种语法：
如下：
1
|
range(start, end, step=1)
|
即默认步长为1，举例如下：
1
2
3
4
|
>>> range(1, 10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 10, 3)
[1, 4, 7]
|
但是步长不能为0，否则会出错：
1
2
3
4
|
>>> range(1, 10, 0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: range() step argument must not be zero
|
1
2
|
range(end) #即默认start=1
range(start, end) #其实就是默认步长为1的情况
|
举例如下：
1
2
3
4
|
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
（5）xrange()内建函数
当调用range()时，会直接生成一个列表并写入内存中，但当生成的列表很大时，使用range()就不适合了，这时可以考虑可以xrange()，它返回一个可迭代的对象，而并不会生成一个完整的列表，因此它只被用于for循环中，否则是没有意义的：
1
2
3
4
5
6
7
8
|
>>> xrange(10)
xrange(10)
>>> type(xrange(10))
<type 'xrange'>
>>> for num in xrange(10):
... print num,
...
0 1 2 3 4 5 6 7 8 9
|
（6）与序列相关的内建函数
主要是：sorted()、reversed()、enumerate()、zip()
之所以说是与序列相关，是因为其中两个函数（sorted()和zip()）返回一个序列（列表），而另外两个函数（reversed()和enumerate()）返回迭代器，举例如下：
1
2
3
4
5
6
7
8
|
>>> nameTuple = ('xpleaf', 'cl')
>>> years = (1994, 1995)
>>> sorted(nameTuple)
['cl', 'xpleaf']
>>> for name in sorted(nameTuple):
... print name,
...
cl xpleaf
|
1
2
3
4
5
6
|
>>> reversed(nameTuple)
<reversed object at 0x7f2fa02df390>
>>> for name in reversed(nameTuple):
... print name,
...
cl xpleaf
|
1
2
3
4
5
6
7
|
>>> enumerate(nameTuple)
<enumerate object at 0x7f2f9e1c1d20>
>>> for nameIndex, name in enumerate(nameTuple):
... print nameIndex, name
...
0 xpleaf
1 cl
|
1
2
3
4
5
6
7
|
>>> zip(nameTuple, years)
[('xpleaf', 1994), ('cl', 1995)]
>>> for name, year in zip(nameTuple, years):
... print name, year
...
xpleaf 1994
cl 1995
|
7.break语句
break可以结束当前循环然后跳转到下一条语句（如果存在的话），可用于while和for两各循环中：
1
2
3
4
5
6
7
8
|
>>> count = 0
>>> while True:
... if count>10:
... print 'OK'
... break
... count += 1
...
OK
|
8.continue语句
continue语句的作用：当遇到ontinue语句时，程序会终止当前循环，并忽略剩余的语句，然后回到循环的顶端。在开始一次迭代前，如果是条件循环，我们将验证条件表达式；如果是迭代循环，我们将验证是否还有元素可以迭代。只有在验证成功的情况下，才会开始下一次迭代。
对在Python中，while循环是条件性的，for循环是迭代的，这就可以跟上面的两种情况对应起来，可简单举例如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
>>> count = 0
>>> while count<10:
... count += 1
... if count != 6:
... continue
... print count
...
6
>>>
>>> for count in range(10):
... if count != 6:
... continue
... print count
...
6
|
9.pass语句
主要是下面几个方面会用到pass语句：
- 有些地方在语法上要求有代码
- 标记后来要完成的代码（比如先定义个类或函数，但什么也不做）
- 在异常处理中对于影响不大的异常可以直接pass
10.再谈else语句
在Python中，除了在条件语句中使用else外，还可以在while和for循环中使用else语句。当在循环中使用时，else子句只在循环完成后执行，即如果此时循环中存在break语句就会跳过该else语句。
举例如下：寻找一个数的最大约数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#!/usr/bin/env python
def showMaxFactor(num):
count = num / 2 #从一半开始计数，这样就可以检查这个数是否可以被2整除，如果可以，那就找到了最大的约数
while count > 1:
if num % count == 0:
print 'largest factor of %d is %d' % (num, count)
break
count -= 1
else:
print num, 'is prime'
if __name__ == '__main__':
showMaxFactor(10)
showMaxFactor(31)
|
这是是一个非常好的特性，可以考虑一下，如果没有该特性，要实现上面的功能，在逻辑上就肯定没有那么清晰了。
11.迭代器和iter()函数
（1）什么是迭代器
所谓迭代器，其实就是一个有next()方法的Python对象，因为它为类序列对象提供了一个类序列的接口，所以可以使用for循环进行迭代（其实for循环在进行序列迭代时是先把序列转换为迭代器再进行迭代的，这是序列本身的功能，之所以会创建迭代器，是因为在序列中实现了__iter__()方法），所以只要是表现出序列行为的对象（可迭代对象），都可以使用迭代器进行迭代。
（2）为什么要迭代器
主要是理解下面几点：
- 对列表迭代带来了性能上的增强（节省内存空间）
- 迭代非序列集合（例如映射和文件）时，可以创建更简洁的代码
（3）如何迭代
迭代器就是一个有next()方法的对象，而不是通过索引来计数。当你或是一个循环机制（比如for）需要下一个项时，调用迭代器的next()方法就可以获得它，当全部项获取后会有一个StopIteration异常，表示迭代已经完成。前面的reversed()和enumerate()函数返回的就是一个迭代器。
当然迭代器也是有一些限制的，即不能向后移动、不能复制一个迭代器，当需要重新迭代同个对象时，就需要去创建另一个迭代对象（不过迭代器本身有seek()方法可以帮我们完成这些事情）。
（4）使用迭代器
如下：
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> nameTuple = ('xpleaf', 'clyyh', 'cl')
>>> i = iter(myTuple)
>>> i.next()
'xpleaf'
>>> i.next()
'clyyh'
>>> i.next()
'cl'
>>> i.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
|
实际上，序列会自动地创建它们自己的迭代器，所以一个for循环：
1
2
3
4
5
|
>>> nameTuple = ('xpleaf', 'clyyh', 'cl')
>>> for name in nameTuple:
... print name,
...
xpleaf clyyh cl
|
实际上是这样工作的：
1
2
3
4
5
6
7
8
9
|
>>> fetch = iter(nameTuple)
>>> while True:
... try:
... i = fetch.next()
... except StopIteration:
... break
... print i,
...
xpleaf clyyh cl
|
即会先创建该序列类型的一个迭代器，然后调用迭代器的next()方法进行迭代。因为序列本身只是为我们创建了迭代器而已，所以for循环语句为我们完成了下面两件事：
（a）自动调用迭代器的next()方法
（b）监视StopIteration异常
字典的迭代器会遍历它的键，语句for eachKey in dict.keys()就可以缩写为for eachKey in dict，如下：
1
2
3
4
5
6
7
8
9
10
|
>>> myDict = {'name': 'xpleaf', 'loving': 'cl'}
>>> for key in myDict.keys():
... print key,
...
name loving
>>>
>>> for key in myDict:
... print key,
...
name loving
|
而根据前面的理论知识，可以考虑它们是这样工作的（实际上可能不是）：
1
2
3
4
5
6
7
8
9
|
>>> fetch = iter(myDict)
>>> while True:
... try:
... i = fetch.next()
... except StopIteration:
... break
... print i,
...
name loving
|
文件对象生成的迭代器会自动调用readline()方法，这样循环就可以访问本文文件的所有行，即可以使用for eachLine in file来替换for eachLine in file.readlines，如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
>>> f = open('welcome.txt', 'r')
>>> lines = f.readlines()
>>> lines
['Welcome to GDUT!\n', "Haha, I'm xpleaf, and I love Python programming!\n", 'Also, I love cl.\n']
>>> for line in lines:
... print line,
...
Welcome to GDUT!
Haha, I'm xpleaf, and I love Python programming!
Also, I love cl.
>>>
>>> f = open('welcome.txt', 'r')
>>> for line in f:
... print line,
...
Welcome to GDUT!
Haha, I'm xpleaf, and I love Python programming!
Also, I love cl.
|
根据前面的理论知识，实际上它们是这样工作的：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> f = open('welcome.txt', 'r')
>>> fetch = iter(f.xreadlines())
>>> while True:
... try:
... i = fetch.next()
... except StopIteration:
... break
... print i,
...
Welcome to GDUT!
Haha, I'm xpleaf, and I love Python programming!
Also, I love cl.
# 猜测使用的是xreadlines()而不是readlines()，是因为readlines()返回的是一个完整的列表，这会占用
# 大量的内存空间，显然是不正确的，而xreadlines()返回的是一个迭代器。
|
当然，因为文件对象本身就是一个迭代器，可以直接调用它的next()方法来实现上面的功能：
1
2
3
4
5
6
7
8
9
10
11
|
>>> f = open('welcome.txt', 'r')
>>> while True:
... try:
... i = f.next()
... except StopIteration:
... break
... print i,
...
Welcome to GDUT!
Haha, I'm xpleaf, and I love Python programming!
Also, I love cl.
|
（5）可变对象和迭代器
不建议在迭代可变对象的时候修改它们，比如一个可变的序列列表，因为一个序列的迭代器只是记录你当前到达第几个元素，所以如果在迭代时改变了元素（或删除了元素），更新会立即反映到所迭代的条目上（序列上），如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
>>> nameList = ['xpleaf', 'clyyh', 'cl']
>>> for name in nameList:
... if name == 'xpleaf':
... nameList.remove(name)
... print name,
...
xpleaf cl
>>> nameList
['clyyh', 'cl']
# 显然一不注意，就会出现问题，因为更新是实时的，而迭代器只是记录了当前位置，所以会看到有些问题，clyyh并没有输出
>>> nameList = ['xpleaf', 'clyyh', 'cl']
>>> for name in nameList:
... if name == 'xpleaf':
... nameList[nameList.index(name)] = 'yonghaoye'
... print nameList
...
['yonghaoye', 'clyyh', 'cl']
|
需要注意的是，在迭代字典时，如果改变这个字典，就会出现问题：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
>>> myDict = {'name': 'xpleaf', 'loving': 'cl'}
>>> for key in myDict:
... print key, myDict[key]
... if key == 'name':
... myDict[key] = 'yonghaoye'
...
name xpleaf
loving cl
# 只是改变值是没有问题的
>>> myDict
{'name': 'yonghaoye', 'loving': 'cl'}
>>>
>>> for key in myDict:
... print key, myDict[key]
... if key == 'name':
... del myDict[key]
...
name yonghaoye
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
RuntimeError: dictionary changed size during iteration
# 但是如果删除字典中的一个键值对就会出现问题
|
前面在迭代列表时删除列表的元素也是可以的，但是在迭代字典时删除字典的键值对就会有问题，注意两者的迭代对象是不一样的，前者列表迭代器，而后者是字典键迭代器，考虑到字典其本身特殊的存储方式，这也是可以理解的，当然要深入研究的话，想必需要查看Python的源代码了。
所以在需要迭代时去删除字典的键值对，可以使用字典的keys()方法，因为keys()返回一个独立于字典的列表。
（6）如何创建迭代器
对一个对象调用iter()就可以得到它的迭代器，语法如下：
- iter(obj)
- iter(func, sentinel)
当传递一个参数给iter()，它会检查你传递的是不是一个序列，如果是，那么很简单：根据索引从0一直迭代到序列结束（但是字典则不一样）。当然也可以使用类的方法，一个实现了__iter__和next()方法的类可以作为迭代器使用。
如果是传递两个参数给iter()，它会重复地调用func，直到迭代器的下个值等于sentinel。
12.列表解析
列表解析（List comprehensions或list comps）可以用来动态地创建列表，它主要有以下两种语法形式：
1
|
[expr for iter_var in iterable]
|
举例如下：
1
2
|
>>> [x ** 2 for x in range(6)]
[0, 1, 4, 9, 16, 25]
|
如果不用列表解析创建相同的列表，就会有些麻烦：
1
2
3
|
>>> map(lambda x: x ** 2, range(6))
[0, 1, 4, 9, 16, 25]
# map()对所有的列表成员应用一个操作，lambda用于快速地创建只有一行的函数对象
|
1
|
[expr for iter_var in iterable if cond_expr]
|
举例如下：
1
2
3
4
5
|
# 挑选序列中的奇数
>>> seq = [11, 10, 9, 9, 10, 10, 9, 8, 23, 9, 7, 18, 12, 11, 12]
>>> [x for x in seq if x % 2]
[11, 9, 9, 9, 23, 9, 7, 11]
# 注意这里使用的方法`if x % 2`，这是判断厅偶数的一个非常好的方法
|
如果不用列表解析，则也会挺麻烦：
1
2
3
|
>>> filter(lambda x:x % 2, seq)
[11, 9, 9, 9, 23, 9, 7, 11]
# filter()基于一个条件表达式过滤列表成员
|
显然会看到使用列表解析就会方便很多，也有下面的相关例子：
比如要迭代一个3行5列的矩阵，可以使用下面的算法：
1
2
|
>>> [(x+1, y+1) for x in range(3) for y in range(5)]
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5)]
|
计算文件大小的，算法如下：
1
|
sum([len(word) for line in f for word in line.split()])
|
上面两个例子其实都是嵌套循环，从中也可以看到列表解析的强大之处。
13.生成器表达式
生成器是特定的函数，允许你返回一个值，然后“暂停”代码的执行，稍后恢复，关于生成器在后面中会有提及，这里介绍的是生成器表达式。
列表解析的一个不足就是必要生成所有的数据，用以创建整个列表，这可能对有大量数据的迭代器有负面影响（占用大量的内存），生成器表达式通过结合列表解析和生成器解决了这个问题。
所谓生成器表达式，它并不真正创建数字列表，而是返回一个生成器，这个生成器在每次计算出一个条目后，把这个条目“产生”（yield）出来。即生成器表达式使用了“延迟计算”（lazy evaluation），所以它在使用内存上更有效（比如你想开发一个ftp软件，这就很重要了，因为可以大大节省内存空间）。
其语法与列表解析对比如下：
1
2
3
4
|
# 列表解析
[expr for iter_var in iterable if cond_expr]
# 生成器表达式
(expr for iter_var in iterable if cond_expr)
|
当然，生成器并不会让列表解析废弃，它只是一个内存使用更友好的结构。可以看下面的应用例子。
（1）磁盘文件样例
前面计算文本文件的大小，使用的是下面的方法：
1
|
sum([len(word) for line in f for word in line.split()])
|
这相关于是把f文件中的所有单词都读取出来，然后放入到列表中，从而生成该文件的一个完整单词列表保存在内存中，对于比较小的文件，这是不错的方法，但如果这个文件本身的大小就已经超出了内存空间的大小，这样你的主机肯定就会崩溃了。因此使用生成器表达式就可以解决这个问题：
1
2
|
sum(len(word) for line in f for word in line.split())
# 注意sum的参数不仅可以是列表，还可以是可迭代对象，比如生成器表达式
|
实际使用如下：
1
2
3
4
5
6
7
8
9
|
>>> f = open('welcome.txt', 'r')
>>> sum(len(word) for line in f for word in line.split())
68
# 当然也可以计算单词个数
>>> f = open('welcome.txt', 'r')
>>> for word in (word for line in f for word in line.split()):
... count += 1
>>> count
15
|
（2）交叉配对样例
生成器表达式就好像是懒惰的列表解析，因为它不会先去产生一个计算结果，直接你需要使用时它才会去生产，一个交叉配对的例子如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
>>> rows = [1, 2, 3, 17]
>>> def cols():
... yield 56
... yield 2
... yield 1
...
>>> x_product_pairs = ((i, j) for i in rows for j in cols())
>>> x_product_pairs
<generator object <genexpr> at 0x7feecdd441e0>
>>> for pair in x_product_pairs:
... print pair
...
(1, 56)
(1, 2)
(1, 1)
(2, 56)
(2, 2)
(2, 1)
(3, 56)
(3, 2)
(3, 1)
(17, 56)
(17, 2)
(17, 1)
|
（3）重构样例
主要是考虑内存的节省问题，因为在处理大文件时用普通的迭代方式就需要把文件内容全部读入到内存中，这是需要非常多的内存的，而使用生成器表达式就可以缓解这个问题，如下面一个计算文件最长行字符数的例子：
1
2
3
4
5
6
|
>>> f = open('welcome.txt', 'r')
>>> longest = max(len(x.strip()) for x in f)
>>> f.close()
>>> longest
48
# 这里改进后的例子，原来是使用列表解析，会占用大量的内存空间，而使用生成器表达式则不会
|
当然，重构过程的一个思想方法也是非常不错的，可以参考书上的例子。
另外，多次提到读取文件时占用内存的情况，这主要是指不要尝试把一个大文件保存为Python的数据结构，否则会占用大量的内存，使用迭代器本身是可以节省内存的，如下面的一个测试，big_file的大小为1.4GB：
1
2
3
4
5
6
7
|
>>> f = open('big_file', 'r')
>>> f2 = open('new_file', 'w')
>>> for line in f:
... f2.write(line)
...
>>> f.close()
>>> f2.close()
|
用for line in file的方式来读取文件时，其实用的就是迭代器的方式，前面已经有提过，这里的测试结果是，在文件复制的过程中，内存的占用率并没有太大的变化，说明Python解释器每处理一行数据都会将原来缓存在内存中的一行数据删除掉（垃圾回收机制），然后再去读取另外一行，这样会获得比较高的性能，而如果直接使用f.readlines()的方法，会发现内存占用马上变大。
而使用生成器表达式的情况是针对你希望通过生成一个列表来统计一些数据时内存占用大的问题，因为生成该列表本身就要把数据缓存到内存中，使用列表解析器时就需要生成一个列表，生成器表达式就是弥补列表解析的不足而提出的。
时间： 2024-04-26 03:32:07
