Python基础教程第五章学习笔记——条件、循环和其他语句

5 条件、循环和其他语句

5.1 print和import的更多信息

5.1.1 使用逗号输出

>>> print ‘Age:’, 42           #可打印多个表达式，它们之间用逗号隔开就行
Age: 42
>>> print 1,2,3                         #逗号隔开，并不能变成元组
1 2 3
#希望同时输出文本和变量值，又不希望用字符串格式化。这个特性就很有用了：
>>> name = 'Gumby'
>>> salutation = 'Mr. '
>>> greeting = 'Hello, '
>>> print greeting, salutation, name
Hello, Mr. Gumby
#若Hello后无逗号，想加上逗号怎么办？
>>> print greeting, ',', salutation, name          #这样不行，因为Hello后会先加上空格再加逗号。
Hello , Mr. Gumby
>>> print greeting + ',', salutation, name        #正确
Hello, Mr. Gumby
#结尾处加上逗号，那接下来的语句会与前一条语句打印在同一行。
print 'Hello,',
print 'World!'
Hello,World!

5.1.2 把某件事作为另一件事导入

从模块导入函数时，可使用：
import somemodule
或者
from somemodule import somefunction
或者
from somemodule import somefunction, anotherfunction,yetanotherfunction
或者
from somemodule import *                #从给定模块中导入所有功能
若两个模块中都有open函数，则可按第一种方式导入，然后按以下方法使用函数：
module1.open(...)
module2.open(...)
也可以在句子末尾增加一个as字句，在字句中给出名字，或给整个模块提供别名：
>>> import math as foobar                   #将math模块别名为foobar
>>> foobar.sqrt(4)
2.0
>>> from math import sqrt as foobar             #将函数sqrt别名为foobar
>>> foobar(4)
2.0
#对上面的open函数可以：
from module1 import open as open1
from module2 import open as open2

5.2 赋值魔法

5.2.1 序列解包（可选代解包）：将多个值的序列解开，然后放到变量的序列中

#例如多个赋值操作同时进行
>>> x, y, z = 1, 2, 3
>>> print x, y, z
1 2 3
#交换多个变量也没问题
>>> x, y = y, x
>>> print x, y, z
2 1 3
#当函数或方法返回元组（或 其他序列或可迭代对象）时，这个特性尤其有用
>>> scoundrel = {'name': 'Robin', 'girlfriend': 'Marion'}
>>> key, value = scoundrel.popitem()
>>> key
'girlfriend'
>>> value
'Marion'
注意：=左右的变量和元素数量必须一致。

5.2.2 链式赋值：将同一个值赋给多个变量的捷径

x = y = somefunction()与y = somefunction();x = y 效果是一样的，但是和x= somefunction; y = somefunction不一定等价

5.2.3 增量赋值：将表达式运算符（+-）放置在赋值运算符（=）之前

>>> x = 2
>>> x += 1
>>> x *= 2
>>> x
6
对其他类型也适用（只要二元运算符本身也适用于这些数据类型就行）
>>> fnord = 'foo'
>>> fnord +=  'bar'
>>> fnord *= 2
>>> fnord
'foobarfoobar'

5.3 语句块：缩排的乐趣

语句块是在条件为真（条件语句）时执行或执行多次（循环）的一组语句。在代码前放置空格来缩进语句就可创建语句块
很多语言适用特殊单词或者字符（如begin、{）表示语句块的开始，另外的单词或字符（如end、}）表示语句块的结束。
Python中冒号（：）用来标识语句块的开始，块中每一个语句都是缩进的（缩进量相同）。当退回到和已闭合的块一样的缩进量时，表示当前块已结束。

5.4 条件和条件语句

5.4.1 这就是布尔变量的作用（真值（布尔值））

下列值作为布尔表达式时，会被解释器看做假（false）
False    None     0      " "      ()      []       {}
除此之外其他一切都被解释为真，包括特殊值True
>>> True ==1
True
>>> False == 0
True
>>> True + False + 42
43
bool函数可以用来转换其他值:
>>> bool('I think')
True
>>> bool(42)
True
>>> bool('')
False
>>> bool(0)
False

5.4.2 条件执行和if语句

if语句  实现条件执行——条件为真，执行冒号后代码块；条件为假，不执行。
name = raw_input('What is your name? ')
if name.endswith('Gumby'):
    print 'Hello. Mr. Gumby'

5.4.3 else字句（不是独立语句，只能作为if语句的一部分）

name = raw_input('What is your name? ')
if name.endswith('Gumby'):
    print 'Hello. Mr, Gumby'
else:
    print 'Hello, stranger'

5.4.4 elif子句：需检查多个条件时——是具有条件的else子句

num = raw_input('Enter a number: ')
if num > 0 :
    print 'The number is positive'
elif num < 0:
    print 'The number is negative'
else:
    print 'The number is zero'

5.4.5 嵌套代码块：if语句里可嵌套使用if语句

name = raw_input('What is your name? ')
if name.endswith('Gumby'):
    if name.startswith('Mr. '):
        print 'Hello, Mr. Gumby'
    elif name.startswith('Mrs. '):
        print 'Hello, Mrs. Gumby'
    else:
d30a

        print 'Hello, Gumby'
else:
    print 'Hello, stranger'

5.4.6 更复杂的条件

1 比较运算符：==；<; >; >=; <=; !=; is; is not; in; not in      #应比较相同或近似类型的对象

比较运算和赋值运算一样——都是可以连接的：几个条件运算符连在一起使用，例如：0 < age <100

2 相等运算符：==      比较两个东西是否相等，单个相等运算符是赋值运算符

3 is： 同一性运算符    判定两个东西是否等同

>>> x = y = [1, 2, 3]
>>> z = [1, 2, 3]
>>> x == y
True
>>> x == z
True
>>> x is y
True
>>> x is z
False         #两个列表值相同，但是不是同一个对象
>>> x = [1, 2, 3]
>>> y = [2, 4]
>>> x is not y
True
>>> del x[2]
>>> y[1[ = 1
>>> y.reverse()
>>> x == y 
True
>>> x is y
False

4 in：成员资格运算符

name = raw_input('What is your name?')
if 's' in name:
    print 'Your name contains the letter "s".'
else:
    print 'Your name does not contain the letter "s".'

5 字符串和序列比较——字符串可按字母顺序排列进行比较

>>> 'alpha' < 'beta'
True
#字符串包含大写字母，结果会有点乱。若要忽略大小写，使用lower或upper
>>> 'FnOrD'.lower() == 'Fnord'.lower()
True
#其他序列也可以
>>> [1, 2] < [2,1]
True
>>> [2, [1, 4]] < [2, [1, 5]]
True

6 布尔运算符

and、or、not就是布尔运算符：and——左右两者皆真才真；or——左右任意为真，或全为真；not——取反
#读取数字，并判断其是否在1-10之间
#第一种方法
number = raw_input('Enter a number between 1 and 10: ')
if number <= 10:
    if number >=1:
        print 'Great'
    else:
        print 'Wrong!'
else:
    print 'Wrong!'
#第二种方法
number = raw_input('Enter a number between 1 and 10: ')
if number >= 1 and number <= 10 :
    print 'Great'
else:
    print 'Wrong'

5.4.7 断言：条件不满足时，程序立即崩溃

>>> age = 10
>>> assert 0 < age < 100
>>> age = -1 
>>> assert 0 < age < 100
AssertionError

5.5 循环

5.5.1 while循环

x = 1
while x <= 100:
    print x
    x += 1
name = ''
while not name:
    name = raw_input('Please enter your name: ')
print 'Hello, %s!' % name

5.5.2 for循环

words = ['This', 'is', 'an', 'ex', 'parrot']
for word in words:
    print word
内建的范围函数：
>>> range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]             #包括下限，不包括上限
希望下限为0时，可直接提供上限：
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for number in range(1, 101):
    print number                               #打印1—100的数字

5.5.3 循环遍历字典元素

d = {'x': 1, 'y': 2, 'z': 3}
for key in d:                               #顺序无定义
    print key, 'corresponds to', d[key]
#可在for循环中直接序列解包
for key, value in d.items:
    print key, 'corresponds to', value

5.5.4 一些迭代工具

1 并行迭代：程序可同时迭代两个序列

names = ['anne', 'beth', 'george', 'damon']
ages = [12, 45, 32, 102]
for i in range(len(names)):
    print names[i], 'is', ages[i], 'years old'
内建函数zip可以用来并行迭代——把两个序列合在一起，返回一个元组的列表：
>>> zip(naems,ages)
[('anne', 12), ('beth', 45), ('george', 32), ('damon', 102)]
for name, age in zip(names, ages):
    print name, 'is', age, 'years old'
zip函数可以用于任意多的序列。很重要一点是可以应付不等长序列：当最短序列用完时就会停止。
>>> zip(range(5), xrange(100000000))                 #range会计算所有数字，而xrange只会计算前五个数字（需要计算的量，匹配前边）
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

2 编号迭代：迭代序列中的对象，同时获取当前对象的索引

index = 0
for string in strings:
    if 'xxx' in string:
   string[index] = '[censored]'
index += 1
内建函数enumerate可实现同样目的
for index, string in enumerate(strings):
    if 'xxx' in string:
        strings[index] = '[censored]'

3 翻转和排序迭代：sorted和reversed

同列表的reverse和sort方法类似，但实际作用于任何序列或可迭代对象上，不是原地修改对象，而是返回翻转或排序后的版本
>>> sorted([4, 3, 6, 8, 3])
[3, 3, 4, 6, 8]
>>> sorted('Hello, world!')
[' ', '!', ',', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
>>> list(reversed('Hello, world!'))
['!', 'd', 'l', 'r', 'o', 'w', ' ', ',', 'o', 'l', 'l', 'e', 'H']
>>> ''.join(reversed('Hello, world!'))
'!dlrow ,olleH'

5.5.5 跳出循环

一般循环一直执行到条件为假或者序列元素用完时，但有时会想中断它。

1 break—结束循环

from math import sqrt
for n in range(99, 0, -1):
    root = sqrt(n)
    if  root == int(root):
        print n
        break                                        #找到最大的平方数之后就会跳出循环，列表内剩余的数不在执行

2 continue—结束当前迭代，跳到下一个循环的开始。但比break用的少

for x in seq:
    if condition1: continue
    if condition2: continue
    if condition3: continue

    do_something()
    do_something_else()
    do_another_thing()
    etc()
可直接使用if语句：
for x in seq:
    if not (condition1 or condition2 or condition3):
        do_something()
        do_something_else()
        do_another_thing()
        etc()

3 while True /break 习语

word = 'dummy'
whiile word:
    word = raw_input('Please enter a word: ')
    print 'The word was ' + word
#代码有些丑，因为循环前需赋给word一个哑值。这是工作不完美标志，应尽量避免。
word = raw_input('Please enter a word: ')
while word:
    print 'The word was ' + word
    word = raw_input('Please enter a word: ')
#哑值不见了，但是有重复代码（应尽量避免），可以使用while True/break 语句：
while True:
    word = raw_input('Please enter a word: ')
    if not word: break
    print 'The word was ' + word

5.5.6 循环中的else子句

break_out = False
for x in seq:
    do_something(x)
    if condition(x):
        break_out = True
        break
    do_something_else(x)
if not break_out:
    print "I didn't break out!"
#简单点：在循环中增加else子句——仅在没有调用break时执行
from math import sqrt
for n in range(99, 81, -1):
    root = sqrt(n)
    if root == int(root):
        print n
        break
else:
    print "Didn't find it!"

5.6 列表推导式——轻量级循环：利用其它列表创建新列表

>>> [x*x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
还可添加if语句
>>> [x*x for x in range(10） if x % 3 == 0]
[0, 9, 36, 81]
还可增加更多for语句部分
>>> [(x, y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2,0), (2,1), (2, 2)]
等同于：
result = []
for x in range(3);
    for y in range(3):
        result.append((x, y))
此时同样可与if子句联合使用
>>> girls = ['alice', 'bernice', 'clarice']
>>> boys = ['chris', 'arnold', 'bob']
>>> [b+ '+' +g for b in boys for g in girls if b[0] == g[0]]
['chris+clarice', 'arnold+alice', 'bob+bernice']
更优方案：

girls = ['alice', 'bernice', 'clarice']
boys = ['charis', 'arnold', 'bob']
letterGirls = {}
for girl in girls:
letterGirls.setdefault(girl[0],[]).append(girl)              #缩进两位
print [b+ '+' +g for b in boys for g in letterGirls[b[0]]]

5.7 三人行：pass、del和exec

5.7.1 什么都没发生——pass语句出马

>>> pass
>>> 
#可在代码中做占位符使用——比如程序需要一个if语句，然后进行测试，但是缺少其中一个语句块的代码
if name == 'Ralph Auldus Melish':
    print 'Welcome!'
elif name == 'Enid':
    #还没完。。。。。。
elif name == 'Bill Gates':
    print 'Access Denied'                           #此时代码不会执行，因为Python中空代码是非法的。解决方法就是加上一个pass语句

if name == 'Ralph Auldus Melish':
    print 'Welcome!'
elif name == 'Enid':
    #还没完。。。。。。
    pass
elif name == 'Bill Gates':
    print 'Access Denied'   

5.7.2 使用del删除

>>> scoundrel1 = {'age': 42}

>>> robin = scoundrel1
>>> scoundrel1
{'age':42}
>>> robin
{'age':42}
>>> scoundrel1 = None
>>> robin
{'age': 42}
>>> robin = None
s和r同时指向一个字典，将s指定为None之后，r仍可用。但是将r值也设为None时，字典就会漂在内存中，无法获取和使用——所以Python解释器直接删除了那个字典。
另一个方法就是使用del语句——不仅会移除一个对象的引用，也会移除那个名字本身：
>>> x = 1
>>> del x
>>> x
NameError: name 'x' is not defined
例子：
>>> x = ['Hello', 'World']
>>> y = x
>>> y[1] = 'Python'
>>> x
['Hello', 'Python']
删除x之后，y并不会消失：
>>> del x
>>> y 
['Hello', 'Python']

5.7.3 使用exec和eval执行和求值字符串

1 exec——执行字符串的语句,执行一系列的Python语句

>>> from math import sqrt
>>> exec 'sqrt = 1'
>>> sqrt(4)
TypeError:...
改正：
>>> from math import sqrt
>>> scope = {}                                   
>>> exec 'sqrt = 1' in scope                   #使用命名空间scope来放置exec的代码字符串
>>> sqrt(4)
2.0
>>> scope['sqrt']
1
>>> lenscope
2
>>> scope.keys()
['sqrt', '_builtins_']               #内建的字典scope会自动包含所有的内建函数和值

2 eval——会计算Python表达式（以字符串形式书写），并且返回结果值

>>> eval(raw_input('Enter an arithmetic expression: '))
Enter an arithmetic expression: 6 + 18 * 2
42
eval也可以使用命名空间。
>>> scope = {} 
>>> scope['x'] = 2
>>> scope['y'] = 3
>>> eval('x*y', scope)
6
>>> scope = {}
>>> exec 'x = 2' in scope
>>> eval('x*x',scope)
4

5.8 小结

打印。print语句可打印中间逗号隔开的多个值；语句以逗号结尾，后面的print语句会在同一行继续打印
导入。 import。。as。。语句进行函数的局部重命名
赋值。 通过序列解包和链式赋值功能，多个变量赋值可一次性赋值。
块。 使用缩排使语句成组的一种方法
条件。 if  elif  else
断言。 assert
循环。 for  while；continue，break， else子句
列表推导式。[x*x for x in range(10)]
pass,del,exec和eval语句

5.8.1 本章新函数

chr(n)                                                         当传入序号n时，返回n所代表的包含一个字符的字符串，（0=<n<256)
eval(source[,globals[,locals]])                     将字符串作为表达式计算，并返回值
enumerate(seq)                                          产生用于迭代的（索引，值）对
ord(c)                                                          返回单字符字符串的int值
range([start,] stop[. step])                            创建整数的列表
reversed(seq)                                              产生seq中值的反向版本，用于迭代
sorted(seq[, cmp][, key][, reverse])             返回seq中值排序后的列表
xrange([start,] stop[, step])                          创造xrange对象用于迭代
zip(seq1._seq2....)                                       创造用于并行迭代的新序列