Python程序设计4——控制语句

1 print和import的更多信息

1.1 使用逗号输出

　　前面已经讲解过如何使用print来打印表达式，可以使用都好来打印多个表达式，只要用逗号隔开即可。

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

　　在python3.0版本中print变成了一个函数，因此打印时候就需要加上括号。

>>> print('Age:','')
('Age:', '')

　　如果想要同时输入文本和变量值，却又不希望使用字符串格式化的话，这个特性很有用

>>> greeting = 'Hello!'
>>> salutation = 'Mr.'
>>> name = 'Jack'
>>> print greeting,salutation,name
Hello! Mr. Jack

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

print 'Hello,',
print 'world!'
输出Hello, world!

1.2 import关键字

　　可以使用import来导入整个模块包或者模块里面的一个函数
有两种句式：
1.import 模块名
2.from 模块名 inport 函数1，函数2....或者from 模块名 import *
　　由于不同的模块可能有相同的处理方法，也就是方法名一样，所以第二种更具普遍一样。对于第一种情况也可以处理，如果两个模块都有相同的函数，比如open函数，可以按照下面这种方式：
模块1.open()
模块2.open()
import语句还有as关键字，就是把导入的包另取一个包名(好像没多大意义)

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

2 赋值

2.1 多变量赋值

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

2.2 交换变量赋值

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

　　上面所做的事情叫做序列解包，将多个值的序列解开，然后放到变量序列中。

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

　　可以看到含有多个值的序列被解开，分别赋给了变量序列，x,y,z

　　可以利用这一点，当函数或者方法返回元组(或者其他序列)时，这个是很有用的。比如popitem方法，它返回的是键值对，可以把这个键值对，赋给两个变量

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

　　注意返回的元素个数必须和赋值的元素个数一致，否则就会引发异常

2.3 增量赋值

普通的赋值运算符是=，增量赋值可以讲一些标准运算符和=结合起来形成如*=，+=，-=这样的

>>> x = 2
>>> x += 1
>>> x
3
>>> x *= 2
>>> x
6

对于其他数据类型也适用

>>> a = 'foo'
>>> a += 'bar'
>>> a
'foobar'
>>> a *= 2
>>> a
'foobarfoobar'

2.4 语句块缩进

　　Python有严格的语句缩进要求，每个缩进4个空格，同一块的语句缩进量相同。在Python中用冒号:表示语句块的开始。

3 条件和条件语句

3.1 布尔值

　　真值也叫布尔值，根据George Boole命名的。
　　下面的值作为布尔表达式时，会被解释器看做是假(False):
False,None,0(所有类型的0，包括浮点型、长整型和其他类型),''(空字符串),()(空元组),[](空列表),{}(空字典)
也就是除了False、None和所有类型的0以及所有的空序列及空字典外，其他的都是真，包括True本身

>>> True
True
>>> True == 1
True
>>> True == 0
False

True和1对应，False和0对应

bool函数可以用来判断是否是True或者False

>>> bool('I think,therefore i am')
True

3.2 条件语句

　　Python提供了if，elif和else三个关键字用于条件语句控制，用冒号表示条件语句下的语句块执行。每一个else肯定有一个if语句配对，但是if不一定和else配对，因为if可以单独使用。

name = raw_input("what's your name?")
if name.endswith('Gumby'):
if name.startswith('Mr'):
print 'Hello Mr.' + name
elif name.startswith('Mrs.'):
print 'Hello Mrs.' + name
else:
print 'Hello,Gumby'
else:
print 'Hello,Strange'
 
输出结果：
what's your name?Mr.Gumby
Hello Mr.Mr.Gumby

3.3 更复杂的条件运算符和条件表达式

1.比较运算符
很多比较运算符和java是一样的，这里说特别的。
x is y x和y是同一个对象
x is not y x和y是不同的对象
x in y x是y容器的成员
x not in y x不是y容器的成员
示例：

>>> x = 1
>>> y = 2
>>> x is y
False
>>> x is not y
True
>>> x = 1
>>> y = [1,2]
>>> z = [3]
>>> x in y
True
>>> x in z
False
>>> x not in z
True

另外<>表示不等于!=,不建议使用这种奇葩的运算符。

2.相等运算符==

　　这个运算符是用来比较是否相等的，注意与=区别，这个运算符是用来赋值的。
3.is运算符        
　　is 运算符判断的是同一性而不是相等性。

>>> x = y = [1,2,3]
>>> z = [1,2,3]
>>> x is y
True
>>> x is z
False
>>> x == z
True

原因很简单，列表、元组和字典都是对象，对象变量放的是数据的地址。

4.字符串和序列的比较

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

>>> 'a ' < 'b'
True

　　大小写有区分，同一个字母对应的大小写，小写大于大写

>>> 'a' < 'A'
False
>>> 'A' < 'a'
True

　　比较时候首先比较首个字符，如果首个字符有区别就会有结果，如果首个字母相同，那就比较第二个，按此类推

　　其他序列也是如此，注意：比较时候，比较对象的结构必须是一样的：

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

5. Python的三元运算符

a if b else c
意思是：如果b为真，返回a，如果为假，返回c

3.4 断言

　　assert关键字用来预判断一些条件，就是预测一些值是否正确。因为某些条件可能会让程序崩溃，assert可以让错误条件出现前，直接让它崩溃，这种场景通常用于调测程序时候。

>>> age = 10
>>> assert 1 < age < 100
>>> assert 1 < age < 3
 
Traceback (most recent call last):
File "<pyshell#140>", line 1, in <module>
assert 1 < age < 3
AssertionError

可以在使用assert时候添加字符串，解释断言

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

4 循环

Python提供了while循环和for循环，没有do...while循环(也没必要，不是吗？)

4.1 while循环

　　对于while循环，必须在循环条件后面加上冒号，然后下一行缩排4个空格，开始一个块。另外可以使用制表符，制表符对于不同编辑器来说代表不同空格，有的代表4个，有的代表8个，为了让代码跨平台，建议手动敲4个空格。例如：

x = 0;
while x < 10:
print x，
x += 1
输出：
0 1 2 3 4 5 6 7 8 9

注意:python中没有像C或java那样的++或--这样的运算符，这种运算符争议很大，很容易出错，所以python没有提供，可以使用x += 1这样不是很好么？

4.2 for循环

python的for循环很简单
for 循环变量 in 被循环的对象
　　print 循环变量
例如:

sentence = ['This','is','a','sentence']
for word in sentence :
    print word,
输出结果：This is a sentence

注意：Java通常循环条件都是加上括号的，python的for循环不允许，这样会报错，不过if、while是允许的，原因是for和in是一个连体关键字，也就是python中for和in必须搭配使用的。

4.3 range函数

　　range函数返回一个一定范围的列表。它包括三个参数，第一个是起始数据(不指定默认是0)，第二个是终点(不包括)，第三个是步长，不指定默认是1

>>> 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]
>>> range(2,10)
[2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1,10,1)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1,10,2)
[1, 3, 5, 7, 9]
>>> range(1,10,3)
[1, 4, 7]

4.4 循环遍历字典元素

　　用for循环可以遍历字典，这是很容易的事情

d = {'Jack':'','Anny':''}
for key in d:
print key,':',d[key]
输出结果：
Jack : 1234
Anny : 3233

4.5 跳出循环

1.break
break跳出整个循环，continue跳出档次循环，不执行当次循环剩下的语句。

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

运行输出结果是：81

也就是说第一个数根整数根时候，跳出了整个循环。

2.continue

这个语句意思是:跳过当前循环次的剩余语句，但是不结束整个循环

while True:
    word = raw_input('Please input a word:')
    if not word:
        break
        print 'The word is',word
输出结果：
Please input a word:3
The word is 3
Please input a word:    

上面not运算符是对word取否。not x的意思是，如果x是False，那not x就是True，如果是True，那not x就是False。

3.再谈else子句

else子句可以放在循环外面，这个和c，java语言都是不同的，作为循环的另一种情况

from math import sqrt
for n in range(99,0,-1):
    root = sqrt(n)
    if root == int(root):
        print n
        break
else：
    print "Didn't find it"

4.5 一些迭代工具

1.并行迭代

程序可以同时迭代两个序列，比如有下面两个列表：

names = ['Quinta','Amy','Landau','Aria']
ages = [23,20,26,23]
for i in range(len(names)):
    print names[i] + "'s age is",ages[i]
输出结果：
Quinta's age is 23
Amy's age is 20
Landau's age is 26
Aria's age is 23

　　同时迭代两个序列，很巧妙的利用了一个共享的循环变量。

2.zip迭代

　　内建的zip函数可以用来并行迭代，它可以讲两个序列合并在一起，返回一个元组

print zip(names,ages)
[('Quinta', 23), ('Amy', 20), ('Landau', 26), ('Aria', 23)]

然后进行解包即可

for names,ages in zip(names,ages):
    print names + "'s age is",ages

4.6 列表推导式——轻量级循环

列表推导式是利用其它列表创建新列表的一种方法。它的工作方式类似于for循环，也很简单：

>>> [x*x for x in range(5)]
[0, 1, 4, 9, 16]

是不是很简单？如果想打印出那些能被3整除的平方数，使用模运算符即可，添加到列表推导式中

>>> [x*x for x in range(5) if x%3 ==0]
[0, 9]

　　还可以往for循环后面增加更多东西，这样就用多个条件限制生成所需要的列表。

>>> girls = ['Alic','Bekky']
>>> boys = ['Andrew','Bob']
>>> [b + '+' + g for g in girls for b in boys if b[0] == g[0]]
['Andrew+Alic', 'Bob+Bekky']

　　上面这个程序就找到了开头字母相同的boys和girs的对应

4.7 pass、del和exec

1.pass
　　在python中空代码块是非法的，pass语句通常和注释差不多，标识你当前还在构想一段程序的结构，但是还没有想好具体的实现细节，比如你定义一个函数，但是你还没想好怎么写，可以用个pass，让编译暂时通过，pass通常用在测试程序时候用到。

def foo_func:
　　pass

2.del删除

　　del语句仅仅删除的是引用变量本身，而不是对象数据(事实上Python没法删除值的，只有垃圾回收可以实现内存的回收)而通常垃圾回收只是断开引用变量和对象的链接。

>>> del x
>>> x
 
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
x
NameError: name 'x' is not defined

3.exec和eval语句

　　exec用于执行字符串语句，所谓的字符串语句就是用引号包起来的普通语句，这样是不是有些麻烦？
比如：

>>> exec "print 'Hello,World'"
Hello,World

　　普通的exec语句是不安全的，因为它可能会破坏命名空间，让一些变量名占用关键字，从而导致代码崩溃。

>>> from math import sqrt
>>> exec 'sqrt = 1'
>>> sqrt(4)
 
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
sqrt(4)
TypeError: 'int' object is not callable

　　注意：命名空间又称为作用域，可以被当作保存变量的地方，在执行x=1这类赋值语句时候，可以将键x和值1放在当前命名空间内。

　　可以通过增加in<scope>来实现，其中的<scope>就是起到放置代码字符串命名空间作用的字典。

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

　　可以看到，潜在的破坏性代码并不会覆盖sqrt函数，原来的函数能正常工作，而通过exec赋值的变量sqrt只在它的作用域内有效。

　　eval是类似于exec的内建函数。exec语句会执行一系列Python语句，而eval会计算Python表达式(以字符串形式书写的表达式)，并且返回结果值。exec语句并不返回任何对象。例如：

>>> eval (raw_input("Enter an arithmetic expression:"))
Enter an arithmetic expression:7*7
49

5 小结

1.打印：print语句可以用来打印逗号隔开的多个值，如果语句以逗号结尾，后面的print语句会在同一行内继续打印
2.导入：使用import ...as....，from...import....
3.赋值：通过序列解包和链式赋值功能，多个变量赋值可以一次性赋值。
4.块：块是通过缩排使语句成组的一种方法，可以在条件及循环语句中使用
5.条件语句：if/elif/else，三个关键词均可独立，else未必需要和if搭配，这个和java里面是不一样的。
6.断言：断言简单来说就是肯定某个表达式为真，如果为假，断言会让程序崩溃。
7.循环：提供了while和for循环两种
8.列表循环推导式：通过旧的序列产生新的序列
9.pass、del、exec和eval语句：pass语句什么都不做，主要用于开发时候进行占位，del语句用来删除变量或者数据结构的一部分，但是不能用来删除值，exec语句用于执行Python程序相同的方式来执行字符串，内建的eval函数对写在字符串中的表达式进行计算并返回结果。