第5章 Python笔记 条件、循环和其他语句

一、print和import的更多信息
1、使用逗号输出
1.1 print在打印多个表达式时，需要用逗号隔开（打印后每个参数之间插入了一个空格）：

>>> print 'Age:',42Age: 42

同时输出文本和变量：

>>>greeting='Hello'>>> name='Gumby'>>> salutation='Mr.'>>> greeting='Hello,'>>> print greeting,salutation,name

Hello, Mr. Gumby

如果变量greeting中不带逗号的话，还想再输出语句加上逗号，解决方案可以为：

>>> name='Gumby'>>> salutation='Mr.'>>> greeting='Hello'>>> print greeting+',',salutation,nameHello, Mr. Gumby

上述解决方案中可以使Hello后面紧跟着逗号，如果使用下面的语句就会在Hello后面有空格：

print greeting,',',salutation,name

1.2 如果在结尾处加上逗号，那么接下来的语句会与前一条语句在同一行打印：

print 'Hello,',print 'world!'Hello, world!

2、导入模板
可以在导入模板或者函数语句末尾增加as语句，为模板或者函数提供别名：

>>> import math as foobar>>> foobar.sqrt(4)2.0>>> from math import sqrt as foobar>>> foobar(4)2.0

二、赋值的拓展
1、序列解包
1.1 多个赋值操作同时进行：

>>> x,y,z=1,2,3>>> print x,y,z

1 2 3

交换变量：

>>> x,y=y,x>>> print x,y,z2 1 3

上述行为就是序列解包的意思，或者称为可迭代解包——将多个值的序列解开，然后放到变量的序列中。比如：

>>> values=1,2,3>>> values(1, 2, 3)>>> x,y,z=values>>> x1

所解包的序列中的元素数量必须和放置在=左边的变量数量一致：

>>> x,y,z=1,2Traceback (most recent call last):  File "<pyshell#19>", line 1, in <module>    x,y,z=1,2ValueError: need more than 2 values to unpack>>> x,y,z=1,2,3,4Traceback (most recent call last):  File "<pyshell#20>", line 1, in <module>    x,y,z=1,2,3,4ValueError: too many values to unpack

1.2 popitem方法将键-值作为元祖返回，那么这个元祖就可以直接赋值到两个变量中：

>>> scoundrel={'name':'Robin','girlfriend':'Marion'}>>> key,value=scoundrel.popitem()>>> key'girlfriend'>>> value'Marion'

1.3 在Python 3.0 中有另外一个解包的特性：可以使用星号运算符。例如，a,b,rest*=[1,2,3,4]最终会在a和b都被赋值之后将所有其他的参数都收集到rest中。本例中，rest的结果将会是[3,4]。
2、链式赋值
链式赋值是将同一个值赋给多个变量：

x=y=somefunction()

和下面的语句效果一样：

y=somefunction()x=y

3、增量赋值
把表达式运算符放置在赋值运算符=的左边，这种写法叫做增量赋值。

>>> x=2>>> x+=1>>> x*=2>>> x6>>> fnord='foo'>>> fnord+='bar'>>> fnord*=2>>> fnord'foobarfoobar'

三、语句块
语句块是在条件为真时执行或者执行多次(循环语句)的一组语句。在代码前放置空格来缩进语句即可创建语句块，块中的每行都应该缩进同样的量。
在Python中，冒号（:）用来标识语句块的开始，块中的每一个语句都是缩进的（缩进量相同）。当回退到和已经闭合的块一样的缩进量时，就表示当前快已经结束了。
四、条件和条件语句
1、布尔变量
下面的值在作为布尔变量是会被看做为假（false）：
False  None  0  ""  ()  []  {}
也就是说标准值False和None、所有类型的数字0（包括浮点型、长整型和其他类型）、空序列（比如空字符串、元祖和列表）以及空的字典都为假。其他的一切都被解释为真，包括特殊值True。

bool函数可以将其他值转换为布尔值：

>>> bool('I think,therefore I am')True>>> bool(42)True>>> bool('')False>>> bool(0)False

2、if语句

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

上面就是if语句，如果条件（在if 和冒号之间的表达式）判断为真，那么后面的语句块（本例中是单个的print语句）就会被执行。如果条件为假，语句块就不会执行。
3、else子句

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

之所以叫else子句是因为它不是独立的语句，而只能作为if语句的一部分。上述代码如果因为条件判断为假，第一个语句块没有执行，就会转入第二个语句块。
4、elif子句

elif是“else if”的简写。

num=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、嵌套代码块

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:        print 'Hello.Gumby'else:    print 'Hello,stranger'

6、更复杂的条件

6.1 比较运算符

6.2 相等运算符
相等运算符为两个等号“==”

>>> "foo"=="foo"True>>> "foo"=="bar"False

6.3 is：同一性运算符

>>> x=y=[1,2,3]>>> z=[1,2,3]>>> x==yTrue>>> x==zTrue>>> x is yTrue>>> x is zFalse

上述代码中x is z的结果为False，是因为is运算符是判断同一性而不是相等性的。x和z它们的值相等，但是却不是同一个对象。
总结：==运算符用来判断两个对象是否相等，is运算符用来判断两者是否等同（同一个对象）。

6.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".'

6.5 字符串和序列比较

字符串可以按照字母顺序排列进行比较：

>>> "alpha"<"beta"True

其他的序列也可以用同样的方式进行比较：

>>> [1,2]<[2,1]True>>> [2,[1,4]]<[2,[1,5]]True

6.6 布尔运算符

number=input('Enter a number between 1 and 10: ')if number <=10 and number >=1:    print 'Great!'else:    print 'Wrong!'

上述代码中的and运算符就是所谓的布尔运算符。它连接两个布尔值，并且在两者都为真时返回真，否则返回假。此外还有or和not。

在python2.5中有一个内置的条件表达式：

a if b else c

如果b为真，返回a，否则，返回c。

6.7 断言
如果需要确保程序中的某个条件一定为真才能让程序正常工作的话，可以使用assert语句，它可以在程序中置入检查点。

>>> age=-1>>> assert 0<age<100,'The age must be realistic'Traceback (most recent call last):  File "<pyshell#5>", line 1, in <module>    assert 0<age<100,'The age must be realistic'AssertionError: The age must be realistic

五、循环
1、while循环

>>> x=1>>> while x<=100:print xx+=1

2、for循环

>>> words=['this','is','an','ex','paarrot']>>> for word in words:print word

>>> numbers=[0,1,2,3,4,5,6,7,8,9]>>> for number in numbers:print number

range函数的工作方式类似于分片，同样包头不包尾。

>>> range(0,10)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> range(10)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

下面的程序会打印1~100的数字：

>>> for number in range(1,101):print number

xrange函数的循环行为类似于range函数，区别在于range函数一次创建整个序列，而xrange一次只创建一个数。
3、循环遍历字典元素

>>> d={'x':1,'y':2,'z':3}>>> for key in d:print key,'corresponds to',d[key]

d.items方法会将键—值对作为元祖返回，for循环的一大好处就是可以循环中使用序列解包：

>>> for key,value in d.items():print key,'corresponds to',value

4、一些迭代工具

4.1 并行迭代
zip函数可以用来进行并行迭代，可以把两个序列“压缩”在一起，然后返回一个元祖的列表：

>>> names=['anne','beth','george''damon']>>> ages=[12,45,32,102]>>> zip(names,ages)[('anne', 12), ('beth', 45), ('georgedamon', 32)]>>> for name,age in zip(names,ages):print name,'is',age,'years old'

zip函数也可以应付不等长的序列：当最短的序列“用完”的时候就会停止：

>>> zip(range(5),xrange(100000000))[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

4.2 编号迭代

有些时候需要迭代序列中的对象，同时还要获取当前对象的索引。可以使用enumerate函数，这个函数可以在提供索引的地方迭代索引—值对。

for index,string in enumerate(strings):    if 'xxx' in string:        strings[index]='[censored]'

4.3 翻转和排序迭代

reversed和sorted：它们同列表的reverse和sort（sorted和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.1 break

结束（跳出）循环可以使用break语句

>>> from math import sqrt>>> for n in range(99,0,-1):root=sqrt(n)if root==int(root):print nbreak

5.2 continue

continue会让当前的迭代结束，“跳”到下一轮循环的开始。基本的意思是：跳过剩余的循环体，但是不结束循环。
5.3 while True/break习语

while True:    word=raw_input('Please enter a word: ')    if not word:break    print 'The word was '+word

while True/break 可以在循环内部任何地方而不是只在开头（像普通的while循环一样）终止循环。
六、列表推导式——轻量级循环

列表推导式是利用其他列表创建新列表的一种方法。

>>> [x*x for x in range(10)][0, 1, 4, 9, 16, 25, 36, 49, 64, 81]>>> [x*x for x in range(10) if x%3==0][0, 9, 36, 81]>>> [(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)]

七、pass、del和exec

1、pass

pass表示程序什么事都不用做。在python中空代码块是非法的，解决方法就是在语句快中加上一个pass语句：

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

2、del

del语句不仅移除一个对象的引用，也会移除那个名字的本身。

>>> x=1>>> del x>>> xTraceback (most recent call last):  File "<pyshell#2>", line 1, in <module>    xNameError: name 'x' is not defined

下面的代码中删除x后，y并没有随之消失。原因是删除的只是名称，而不是列表本身（值）。事实上，在Python中是没有办法删除值的，也不需要过多考虑删除值的问题，因为在某个值不再使用的时候，Python解释器会负责内存的回收。

>>> x=["Hello","world"]>>> y=x>>> y[1]="Python">>> x['Hello', 'Python']>>> del x>>> y['Hello', 'Python']

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

3.1 执行一个字符串的语句是exec：

>>> exec "print 'Hello,world!'"Hello,world!

exec语句最有用的地方在于可以动态地创建代码字符串。为了安全起见，可以增加一个字典，起到命名空间的作用。这可以通过增加in<scope>来实现，其中<scope>就是起到放置代码字符串命名空间作用的字典。下面两段代码进行对比：

>>> from math import sqrt>>> exec "sqrt=1">>> sqrt(4) #已经破坏了原有的sqrt函数。Traceback (most recent call last):  File "<pyshell#3>", line 1, in <module>    sqrt(4)TypeError: 'int' object is not callable

>>> from math import sqrt>>> scope={}>>> exec 'sqrt=1' in scope>>> sqrt(4)2.0>>> scope['sqrt']1

有上述可以看到潜在的破坏性代码并不会覆盖sqrt函数，原来的函数可以正常工作，而通过exec赋值的变量sqrt只在它的作用域内有效。
3.2 eval会计算Python表达式（以字符串形式书写），并且返回结果值：

>>> eval(raw_input("Enter an arithemetic expression: "))Enter an arithemetic expression: 6+18*242