2015/9/5 Python基础(9)：条件和循环

louyaoluan

　　条件语句
Python中的if语句如下：



if expression:
　　expr_true_suite
　　其中expression可以用布尔操作符and， or 和 not实现多重判断条件。
如果一个复合语句的的代码块仅仅包含一行代码，那么它可以和前面的语句写在同一行：



if expression: dosomething
　　但实际上，为了可读性，我们尽量不这么做
else语句的使用：



if expression:
　　expr_true_suite
else:
　　expr_false_suite
　　Python使用缩进强制使代码对齐，可以避免制造一些类型的悬挂else问题。但同样要让我们非常小心代码的对齐问题，否则代码很可能不能使用。
elif(else—if)语句
Python没有switch/case语句，所以用if—elif来替代它的使用，并不会降低太多的阅读性



if user.cmd == 'create':
　　action = "create item"
elif user.cmd == 'delete':
　　action = 'delete item'
elif user.cmd == 'update':
　　action = 'update item'
else:
　　action = 'invalid choice... try again!'
　　上面的语句也可以用序列改写：



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)
　　
　　
条件表达式（即“三元操作符”）
也就是C里的C？X：Y
Python里使用了 X if C else Y：



>>> x, y = 4, 3
>>> smaller = x if x < y else y
>>> smaller
3
　　
　　while语句
while循环的一般语法如下：



while expression:
　　suite_to_repeat
　　while循环一般被用作计数循环或者无限循环：



>>> count = 0
>>> while (count < 9):
　　　　print 'the index is:', count
　　　　count += 1
the index is: 0
the index is: 1
the index is: 2
the index is: 3
the index is: 4
the index is: 5
the index is: 6
the index is: 7
the index is: 8
>>>while True:
　　　　message = raw_input("please input :")
　　　　if message.lower() == 'q':
　　　　break
　　
　　for 语句
Python的for非常强大，它可以遍历序列成员，可用在列表解析和生成器表达式，会自动地调用迭代器的 next()方法，捕获StopIteration异常并结束循环(这都是在内部发生的)，Python的for循环不同于传统语言的for循环，类似于shell的foreach
　　一般语法
for循环访问一个可迭代对象（如序列或迭代器）中所有元素，并在所有条目都处理后结束循环



for iter_var in iterable:
　　suit_to_repeat
　　for循环迭代不同的序列对象，有如下例子：



>>> for eachLetter in 'Names': #迭代字符串
　　　　print 'current letter:',eachLetter
current letter: N
current letter: a
current letter: m
current letter: e
current letter: s
>>> nameList = ['Amy', 'Bob', 'Henry']
>>> for eachName in nameList: #迭代序列项
　　　　print eachName, 'Lim'
Amy Lim
Bob Lim
Henry Lim
>>> for nameIndex in range(len(nameList)): #不迭代元素，迭代索引
　　　　print "Liu,", nameList[nameIndex]
Liu, Amy
Liu, Bob
Liu, Henry
>>> nameList = ['Donn', 'Shirley', 'Ben', 'Jane']
>>> for i, eachone in enumerate(nameList): #用项和索引迭代
　　　　print '%d %s' %(i+1, eachone)
1 Donn
2 Shirley
3 Ben
4 Jane
　　
　　for循环访问迭代器和访问序列的方法差不多，只是for语句会做一些额外的事而迭代器不代表循环条目的集合。
迭代器对象有一个next()方法，调用后返回下一个条目。迭代完后引发一个StopIteration异常告诉程序循环结束。for在内部直接调用next()并捕获异常。
　　range()内建函数在之前的博文Python基本使用(2)里已经详细说明。这里不赘述
　　xrange()
xrange()类似range()，当一个列表范围很大时，xrange()更为合适，因为它不会在内存里创建列表的完整拷贝，它只能用于for循环中，在for循环外没有任何意义。使用时性能远高于range()。
　　sorted(), reversed(), enumerate(), zip()



>>> for album in sorted(albums):
　　　　print album,

Freud Gaudi Poe Poe2
>>> for album in reversed(albums):
　　　　print album,

Poe2 Freud Gaudi Poe
>>> for i, album in enumerate(albums):
　　　　print i, album

0 Poe
1 Gaudi
2 Freud
3 Poe2
>>> for album, yr in zip(albums, years):
　　　　print yr, album

1976 Poe
1987 Gaudi
1990 Freud
2003 Poe2
　　
　　break语句和continue语句
　　break,continue和C中的break,continue十分相似。
pass语句
因为Python没有传统的括号，所以用pass表示此代码块什么都不做。
　　另外，循环语句也可以接else语句
表示循环结束后执行此代码块。
　　
　　迭代器和iter()函数
迭代器为类序列对象提供了一个类序列的接口。序列可以利用索引从0开始一直迭代到序列的最后一个条目，用计数的方法迭代序列是很简单的。Python的迭代无缝支持序列对象，还允许非序列类型，包括用户定义的对象。
迭代器用起来很灵巧，可以迭代不是序列但表现出序列行为的对象，例如字典的key，一个文件的行等等。Python在使用迭代时分不出是迭代器还是序列，让人不用去关注这些，因为Python让它像一个序列那样操作。
使用迭代器：
序列：



>>> myTuple = (123, 'xyz', 45.67)
>>> i = iter(myTuple)
>>> i.next()
123
>>> i.next()
'xyz'
>>> i.next()
45.67
>>> i.next()
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
i.next()
StopIteration
　　
　　如果这是一个实际应用程序，那么我们需要把代码放在一个try—except 块中。序列现在回自动地产生它们自己的迭代器，所以一个for循环：



for i in seq:
　　do_something_to(i)
　　
　　实际上是这样工作：



fetch = iter(seq)
while True:
　　try:
　　i = fetch.next()
　　except StopIteration:
　　break
　　do_something_to(i)
　　
　　字典：字典的迭代器会遍历它的键(keys)



>>> legends = {('Poe', 'author'):(1809, 1849, 1976),}
>>> legends = {('Poe', 'author'):(1809, 1849, 1976),('Gaudi','architect'):(1852, 1906, 1987),('Freud', 'psychoanalyst'):(1856, 1939, 1990)}
>>> for eachLegend in legends:
　　　　print 'Name: %s\tOccupation: %s' % eachLegend
　　　　print 'Birth: %s\tDeath: %s\tAlbum:%s\n' % legends[eachLegend]

Name: Poe    Occupation: author
Birth: 1809    Death: 1849    Album:1976
Name: Gaudi    Occupation: architect
Birth: 1852    Death: 1906    Album:1987
Name: Freud    Occupation: psychoanalyst
Birth: 1856    Death: 1939    Album:1990
　　
　　另外，Python还引进了三个新的内建字典方法来定义迭代：myDict.iterkeys()(通过keys迭代)，myDict.itervalues()(通过values迭代)以及myDict.iteritems()(通过key/value对来迭代)
　　文件
文件对象生成的迭代器会自动调用readline()方法，这样，循环就可以访问文本文件的所有行。 程序员可以用for eachLine in myFile 替换 for eachLine in myFile.readlines():



>>> myFile = open('config-win.txt')
>>> for eachLine in myFile:
... 　　print eachLine, # comma suppresses extra \n
...
[EditorWindow]
font-name: courier new
font-size: 10
>>> myFile.close()
　　
　　可变对象和迭代器
迭代可变对象时修改它们不是一个好主意，除了列表外其他序列类型不可变，所以危险就发生在这里。序列的迭代器只记录你当前到达第多少个元素，如果你迭代时改变了元素，更新会立即反映到你所迭代的条目上。在迭代字典的key时，绝对不能改变这个字典（因为字典是无序的）。使用字典的keys()方法是可以的，因为keys()返回一个独立于字典的列表，而迭代器与实际对象绑在一起，它将不会继续执行下去：



>>> myDict = {'a': 1, 'b': 2, 'c': 3, 'd':4}
>>> for eachKey in myDict:
　　　　print eachKey, myDict[eachKey]
　　　　del myDict[eachKey]
a 1
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
for eachKey in myDict:
RuntimeError: dictionary changed size during iteration
　　
　　创建迭代器
对一个对象调用iter()就可以得到它的迭代器：



iter(obj)
iter(func, sentinel)
　　如果传递一个参数给 iter() ,它会检查你传递的是不是一个序列，如果是，那么很简单：根据索引从0一直迭代到序列结束。
如果传递两个参数给iter()，它会重复地调用func，直到迭代器的下个值等于sentinel
另一个创建迭代器的方法是类，以后我将在后面的章节详细学习。
　　列表解析
列表解析是一项非常有用，简单，而且灵活的工具，可以用来动态地创建列表。
列表解析的语法：



[expr for iter_var in iterable]
　　核心是for循环，迭代iterable对象的所有条目。前边的expr应用于序列的每个成员，最后的结果值是该表达式产生的列表。迭代变量并不需要是表达式的一部分。
lambda函数表达式：



>>> map(lambda x: x ** 2, range(6)) #这是lambda函数表达式
[0, 1, 4, 9, 16, 25]
>>> [x ** 2 for x in range(6)] #这是列表解析
[0, 1, 4, 9, 16, 25]
　　列表解析还有结合if的拓展版本



[expr for iter_var in iterable if cond_expr]
　　这个语法在迭代时会过滤/捕获满足条件表达式cond_expr的序列成员
以下例子是挑出序列中的奇数：



>>> seq = [11, 12, 16, 13, 10, 9, 9, 10, 8]
>>> filter(lambda x: x % 2, seq) #用filter和lambda实现
[11, 13, 9, 9]
>>> [x for x in seq if x % 2] #用列表解析实现
[11, 13, 9, 9]
　　
　　生成器表达式
生成器表达式是列表解析的一个扩展，语法如下：



(expr for iter_var in iterable if cond_expr)
　　语法和列表解析基本相同，不过它并不真正创建数字列表，而是返回一个生成器，这个生成器在计算出一个条目后，把这个条目“产生”(yield)出来。生成器表达式用了“延迟计算”，所以它在使用内存上更有效。将在以后的学习中详细地说明这一点