Python基础教程（第三版）读书笔记（5）

条件、循环和其他语句

今天学习的是，条件语句和循环语句。
说两种语句之前，先说一下print和import.

再谈print和import

打印多个参数

之前我们用print打印参数，只打印了一个。其实print还可以打印多个参数，条件是用逗号分隔它们。

>>> print("Age:", 42)
Age: 42

另外，print函数还可以自定义结束字符串，已替换默认的换行符

>>> print("Hello,")
Hello,
>>> print("hhhh,", end='NewEnd')
hhhh,NewEnd

导入时重命名

导入模块时，如果多个模块都实现了某一个函数，那我们该怎么办呢？
第一种方法是使用 module1.函数（），module2.函数（）的形式。
第二种方法是在语句末尾添加as子句并指定别名。
例子1：导入整个模块并给它指定别名。

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

例子2：导入特定函数并给它指定别名。

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

赋值魔法

之前我们学了使用 = 号赋值，其实赋值语句还有很多小技巧。

序列解包

序列解包：将一个序列（或任何可以迭代的对象）解包，并将得到的值存储到一系列变量中。
使用序列解包，进行数据交换

>>> 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
>>> print(x, y, z)
1 2 3

字典序列解包

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

但是序列解包的使用是有条件的，待解包的序列包含的元素个数必须与你在等号左边的列出的目标个数相同。

>>> x, y, z = 1, 2
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    x, y, z = 1, 2
ValueError: not enough values to unpack (expected 3, got 2)
>>> x, y, z = 1, 2, 3, 4
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    x, y, z = 1, 2, 3, 4
ValueError: too many values to unpack (expected 3)

不过当值非常多时，可使用星号运算符（*)来收集多余的值。

>>> a, b, *rest = [1, 2, 3, 4]
>>> rest
[3, 4]

赋值语句右边可以是任意类型的序列，但带星号的变量最终包含的总是一个列表。

>>> a, *b, c = 'abc'
>>> b
['b']

另外还有链式赋值，和增强赋值

>>> x = y = 1
>>> x, y
(1, 1)
>>> x += 1
>>> x
2

代码块：缩进的乐趣

Python用缩进来区分各个代码块。不用c中的花括号。另外，Python使用冒号(:)指出接下来是一个代码块，并将该代码块中的每行代码都缩进相同的程度。

条件和条件语句。

条件判断语句 if, elif, else

条件语句使用例子。

>>> name = input('What is your name? ')
What is your name? Yang	
>>> 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')

Hello, stranger

条件

除了条件语句，我们来看看条件本身，条件语句根据条件的真假，来选择是否执行相应的代码块。我们看几个特殊的运算符。

is: 相同运算符（对象相同为真）

is和== 运算符一样，都是判断

>>> x = y = [1, 2, 3]
>>> z = [1, 2, 3]
>>> x == y
True
>>> x == z
True
>>> x is y
True
>>> x is z    # 不是同一个对象，所以为错
False

小小总结一下，就是==用来检查两个对象是否相等， 而is用来检查两个对象是否相同。

比较大小

字符串和序列根据字符的字母排列顺序进行比较。

断言

断言的意义是让程序在错误条件出现时立即崩溃。立即崩溃胜过以后再崩溃。断言伪代码如下。

>>> # if not condition:
>>> # 	  crash program

Python使用关键字assert设置断言

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

也可在条件后面添加一个字符串，对断言做出说明。

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

忘了说了，条件表达式，c语言中三目运算符的Python版本。

>>> status = 'friend' if name.endswith('Gumby') else 'stranger'
>>> status
'stranger

循环语句

while循环语句

使用实例。

>>> x = 1
>>> while x <= 100:
	print(x)
	x += 1

for循环语句

除了while语句以外，还有for语句，for语句一般用于为序列（或其他可迭代对象）中每个对象执行代码块。

>>> words = ['this', 'is', 'an', 'ex', 'parrot']
>>> for word in words:
	print(word, end=' ')

this is an ex parrot 

Python另外提供了一个内置函数range来创建范围。

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

迭代字典

使用for循环迭代字典。

>>> d = {'x':1, 'y':2, 'z':3}
>>> for key in d:
	print(key, 'corresponds to', d[key], end=' ')	
	
x corresponds to 1 y corresponds to 2 z corresponds to 3 
>>> for key, value in d.items():
	print(key, 'corresponds to', value, end=' ')	
	
x corresponds to 1 y corresponds to 2 z corresponds to 3 

使用for循环的优点之一是，可在其中使用序列解包。

迭代工具。

python提供了多种可迭代的序列，也提供了多种迭代的工具。具体如下。

并行迭代

1. 使用循环索引变量，或者使用内置函数zip

>>> names = ['anne', 'beth', 'george', 'damon']
>>> ages = [12, 45, 32, 102]
>>> for i in range(len(names)):
	print(names[i], 'is', ages[i], 'years old')
	
anne is 12 years old
beth is 45 years old
george is 32 years old
damon is 102 years old

2. 使用zip函数进行“缝合”,返回一个由元组组成的序列。

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

迭代时获取索引

使用内置函数enumerate在迭代时获取索引

>>> for index, name in enumerate(names):
	if 'e' in name:
		names[index] = '[censored]'

		
>>> names
['[censored]', '[censored]', '[censored]', 'damon']

另外也可以反向迭代或者排序后再迭代。

跳出循环

使用break语句中断循环，continue语句开始新迭代。

简单推导

学了循环后，我们可以用循环来创捷列表。
使用列表推导从其他列表创建列表。

>>> [x * x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> a = [x * x for x in range(10)]
>>> a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

列表推导中添加其他语句

>>> a = [x * x for x in range(10) if x % 3 == 0]
>>> a
[0, 9, 36, 81]

上面那条语句等于

>>> a = []
>>> for x in range(10):
	if x%3 == 0 :
		a.append(x*x)

		
>>> a
[0, 9, 36, 81]

还可以添加更多的for循环

>>> a = [(x, y) for x in range(3) for y in range(3)]
>>> a
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

等价于

>>> a = []
>>> for x in range(3)
SyntaxError: invalid syntax
>>> for x in range(3):
	for y in range(3):
		a.append((x, y))

		
>>> a
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

需要注意的是：使用圆括号代替方括号并不能实现元组推导，而是创建生成器。然而，可使用花括号来执行**字典推导 **

>>> squares = {i:"{} squared is {}".format(i, i**2) for i in range(10)}
>>> squares[8]
'8 squared is 64'

在列表推导中，for前面只有一个表达式，而在字典推导中，for前面有两个用冒号分隔的表达式。这两个表达式分别为键及其对应的值。

三人行

三条特殊语句： pass, del和exec。

什么都不做

pass: 一条什么都不做的语句。可以使用在代码块没有，但是想测试的情况。

>>> if x ==1 :
	pass

使用del删除

del: 删除对象的引用和对象本身。

>>> x = 1
>>> del x
>>> x
Traceback (most recent call last):
  File "<pyshell#178>", line 1, in <module>
    x
NameError: name 'x' is not defined
>>> x = ['Hello', 'World']
>>> y = x
>>> y[1] = 'Python'
>>> x
['Hello', 'Python']
>>> del x
>>> # 删除x只是删错了x这个引用和名称，对值,没有影响。
>>> y
['Hello', 'Python']
>>> x
Traceback (most recent call last):
  File "<pyshell#186>", line 1, in <module>
    x
NameError: name 'x' is not defined

使用exec和eval执行字符串及计算其结果

evec：用于将字符串作为python程序执行

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

eval: 计算用字符串表示的表达式并返回结果.

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

小结

• 打印语句： 你可以使用print语句来打印多个用逗号分隔的值。如果print语句以逗号结尾，后续print语句将在当前行接着打印。
• 导入语句: 有时候，你不喜欢要导入的函数的名称——可能是因为你已将这个名称用作他用。在这种情况下，可使用import……as …… 语句在本地重命名函数。
• 赋值语句： 使用奇妙的序列解包和链式赋值，可同时给多个变量赋值；而使用增强赋值可就地修改变量。
• 代码块： 代码块用于通过缩进将语句编组。代码块可用于条件语句和循环中，还可用于函数和类定义中。
• 条件语句: 条件语句根据条件（布尔表达式）决定是否执行后续代码块。使用if/elif/else可将多个条件语句组合起来。条件语句的一个变种是条件表达式，如a if b else c。
• 断言： 断言断定某件事（一个布尔表达式）为真，可包含说明为何如此的字符串，如果指定的表达式为假，断言将导致程序停止执行。
• 循环：你可针对序列中的每个元素（如特定范围内的每个数）执行代码块，也可在条件为真时反复执行代码块。要跳过代码块中余下的代码，直接进入下一次迭代，可使用continue语句；要跳出循环，可使用break语句。另外你还可以在循环末尾添加一个else子句，它将在没有执行循环中任何break语句时执行。
• 推导：推导并不是语句，而是表达式。它们看起来很像循环。通过列表推导，可从既有列表创建出新列表。
• pass、del、exec和eval： pass语句什么都不做，但适合用作占位符。del语句用于删除字典量或数据结构的成员，但不能用于删除值。函数exec用于将字符串作为Python程序执行。函数eval计算用字符串表示的表达式并返回结果。

学习到的新函数。

函数	描述
chr（n）	返回一个字符串，其中只包含一个字符，这个字符对应于传入的顺序值n（0《n<256）
eval(source[,globals[,locals]])	计算并返回字符串表示的表达式的结果。
exec（source[, globals[, locals]]）	将字符串作为语句执行。
enumerate（seq）	生成可迭代的索引–值对。
ord（c）	接受一个只包含一个字符的字符串，并返回这个字符的顺序值（一个整数）。
range([start,], stop[, stop])	创建一个由整数组成的列表。
reversed（seq)	按相反的顺序返回seq中的值，以便用于迭代。
sorted（seq[, cmp][, key][, reverse]）	返回一个列表，其中包含seq中的所有值且这些值是经过排序的。
xrange（[, start] stop[, stop]）	创建一个用于迭代的xrange对象。
zip（seq1， seq2，……）	创建一个适合用于并行迭代的新序列。

小结部分，是摘抄书上的。