ch5 条件，循环和其他语句

5.1 print和import的更多信息

5.1.1 使用逗号输出

print可以打印多个表达式，只要将他们用逗号隔开

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

注意，print的参数并不能组成一个元组

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
>>>foobar.sqrt(4)
2.0

也可以为函数提供别名

>>>>>>from math import sqrt as 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

这里所做的事情叫做序列解包或可选代解包，将多个值的序列解开，然后放到变量的序列中

>>>scoundre1 = {'name': 'Robin', 'girlfriend': 'Marion'}
>>>key, value = scoundre1.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 语句块：缩排的乐趣

语句块是在条件为真时执行后者执行多次的一组语句，在代码前放置空格来缩进语句即可创建语句块

在python中：标识语句块的开始，块中的每一个语句都是缩进的。当回退到和已经闭合的快一样的缩进量时，就表示当前块已经结束了。

5.4 条件和条件语句

5.4.1 布尔变量的作用

下面的值在作为布尔表达式的时候，会被解释器看做假

False None 0 “” () [] {}

5.4.2 条件执行和if语句

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

5.4.3 else子句

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

5.4.4 elif子句

如果需要检查多个条件，就可以使用elif

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.4.5 嵌套代码块

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'

5.4.6 更复杂的条件

1. 比较运算符

2.相等运算符

判断是否相等，使用相等运算符==

3. 同一性运算符

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

is运算符是判断同一性而不是相等性的，变量x和y都被绑定在同一个列表上，而变量z被绑定在另外一个具有相同数值和顺序的列表上，它们的值可能相等，但是却不是同一个对象。

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

6. 布尔运算符

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

<div class="se-preview-section-delimiter"></div>

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

布尔运算符只有在需要求值时才进行求值，比如x and y需要两个变量都为真时才为真，如果x为假，表达式会返回x的值，否则会返回y的值。这种行为被称为短路逻辑或惰性逻辑。它主要能够避免了无用的执行算法。

5.4.7 断言

与其让程序在晚些时候崩溃，不如在错误条件出现时直接让它崩溃。一般来说，你可以要求某些条件必须为真。语句中使用的关键字是assert。

>>>age = 10
>>>assert 0 < age < 100
>>>age = -1
>>>assert 0 < age < 100
Traceback (most recent call last):
File "G:\python\test.py", line 2, in <module>
assert 0 < age < 100
AssertionError

如果需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert语句就有用了，它可以在程序中放置检查点。条件后可以添加字符串，用来解释断言。

>>>age = -1
>>>assert 0 < age < 100.'The age must be realistic'
Traceback (most recent call last):
File "G:\python\test.py", line 2, in <module>
assert 0 < age < 100, "The age must be realistic"
AssertionError: The age must be realistic

5.5 循环

5.5.1 while循环

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

5.5.2 for循环

while语句非常灵活。它可以用来在任何条件为真的情况下重复执行一个代码块。但有时候需要为集合中每一个元素都执行一个代码块。这个时候可以用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]

如果能不用for循环，就尽量不用while循环

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 一些迭代顺序

在python中迭代序列时，一些函数非常有用，有些函数位于itertools模块中，还有一些python的内建函数也十分有用

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(names, 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(1000000000))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

在上面的代码中，不推荐用range代替xrange，因为尽管只需要前5个数字，但range会计算所有的数字，xrange只计算前5个数字。

2. 编号迭代

有时候想要迭代序列中的对象，同时还要获取当前对象的索引。例如在一个字符串列表中替换所有包含‘xxx’的子字符串。

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

3. 翻转和排序迭代

reversed函数和sorted函数，它们同列表的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

注意，虽然sorted方法返回列表，reversed方法却返回一个可迭代对象，它们具体的含义不用过多关注，大可在for循环以及join方法中使用。不过不能直接对它进行索引，分片以及调用list方法。如果希望进行上述处理，可以使用list型转换返回的对象。

5.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

2. continue

continue语句会让当前的迭代结束，跳到下一轮循环的开始。很多时候只需要用if语句就行了。

3. while True/break

python中的while语句和for循环非常灵活，如果需要当用户在提示符下输入单词时做一些事情，并且在用户不输入单词时结束循环，可以使用下面的方法。

word = 'dummy'
while 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:
word = raw_input('Please enter a word: ')
if not word: break
print 'The word was' + word

5.5.6 循环中的else语句

当在循环内使用break语句时，通常是因为找到了某物或者某事发生了，在跳出时做一些事是很简单的，但是有些时候想要在没有跳出之前做些事情，可以使用布尔变量，在循环之前将其设定为False，跳出后设定为True，然后再使用if语句查看循环是否跳出了。

break_out = False
for x in seq:
do_something(x)
if contion(x):
break_out = True
break
do somethingelse(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 列表推导式-轻量级循环

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

>>>[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]

5.7 三人行

三个语句pass,del和exec

5.7.1

>>>pass
>>>

它可以在程序中作为一个占位符使用，比如程序需要一个if语句，然后进行测试，但是缺少其中一个语句块的代码。python中的空代码块是非法的，解决方法就是在语句块中加上一个pass语句。

if n in seq:
pass

5.7.2 使用del删除

一般来说，Python不会删除那些不再使用的对象（因为使用者不会再通过任何变量或者数据结构引用它们）

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

>>>x = 1
>>>del x
>>>x
Traceback (most recent call last):
File "G:\python\test.py", line 3, in <module>
print x
NameError: name 'x' is not defined

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

虽然x和y都指向同一个列表，但是删除x不会影响y，原因就是删除的只是名称，而不是删除列表本身，事实上在Python中是没有办法删除值的

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

1. exec

执行一个字符串的语句时exec

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

很多情况下可以给它提供命名空间，可以放置变量的地方

>>>from math import sqrt
>>>exec "sqrt = 1"
>>>sqrt(4)
Traceback (most recent call last):
File "G:\python\test.py", line 3, in <module>
print sqrt(4)
TypeError: 'int' object is not callable

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

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

2. eval

eval是类似于exec的内建函数，exec会执行一系列python语句，eval会计算python表达式，并且返回结果值。

>>>eval(raw_input("Enter an arithmetic expression: "))
Enter an arithmetic expression: 6+18*2
42

和exec一样，eval也可以使用命名空间

5.8 小结

打印：打印由逗号隔开的多个值

导入：import…as…

赋值:通过序列解包和链式赋值功能，多个变量赋值可以一次性赋值

块

条件

断言

循环

列表推到式

pass,exec,eval