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

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

>>> print 'Age:',42
Age: 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,name
Hello, 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,z
2 1 3

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

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

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

>>> x,y,z=1,2
Traceback (most recent call last):
File "<pyshell#19>", line 1, in <module>
x,y,z=1,2
ValueError: need more than 2 values to unpack
>>> x,y,z=1,2,3,4
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
x,y,z=1,2,3,4
ValueError: 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
>>> x
6
>>> 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==y
True
>>> x==z
True
>>> x is y
True
>>> x is z
False

上述代码中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 断言

如果需要
4000
确保程序中的某个条件一定为真才能让程序正常工作的话，可以使用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 x
x+=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 n
break

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':
#还没完....
pass
elif name == 'Bill Gates':
print 'Access Denied'

2、del

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

>>> x=1
>>> del x
>>> x

Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
x
NameError: 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*2
42