大一第二次培训——下

下半部分给大家讲流程控制与函数。流程控制比较简单，重点是其注意事项。

流程控制

if elif else

格式：

	if 表达式 1：
	    代码块 1
	elif 表达式 2：
	    代码块 2
	elif 表达式 3：
	    代码块 3
	...//其它elif语句
	else：
	    代码块 n

对语法格式的说明：

“表达式”可以是一个单一的值或者变量，也可以是由运算符组成的复杂语句，形式不限，只要它能得到一个值就行。不管“表达式”的结果是什么类型，if else 都能判断它是否成立（真或者假）。
“代码块”由具由相同缩进量的若干条语句组成。
if、elif、else 语句的最后都有冒号:，不要忘记。
允许嵌套

pass

在实际开发中，有时候我们会先搭建起程序的整体逻辑结构，但是暂时不去实现某些细节，而是在这些地方加一些注释，方面以后再添加代码。
但是 Python 提供了一种更加专业的做法，就是空语句 pass。pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做。

有时候程序需要占一个位置，或者放一条语句，但又不希望这条语句做任何事情，此时就可以通过 pass 语句来实现。使用 pass 语句比使用注释更加优雅。

assert断言函数

assert 语句，又称断言语句，可以看做是功能缩小版的 if 语句，它用于判断某个表达式的值，如果值为真，则程序可以继续往下执行；反之，Python 解释器会报 AssertionError 错误。
assert 语句的语法结构为：

	assert 表达式

assert 语句的执行流程可以用 if 判断语句表示，如下所示：

	if 表达式==True:
	    程序继续执行
	else:
	    程序报 AssertionError 错误

while

while 语句的语法格式如下：

	while 条件表达式：
	    代码块

比较简单，不再赘述。

for

for 循环的语法格式如下：

	for 迭代变量 in 字符串|列表|元组|字典|集合|....：
	    代码块

格式中，迭代变量用于存放从序列类型变量中读取出来的元素，所以一般不会在循环中对迭代变量手动赋值；代码块指的是具有相同缩进格式的多行代码（和 while 一样），由于和循环结构联用，因此代码块又称为循环体。

例子：
计算1+…+100;

	print("计算 1+2+...+100 的结果为：")
	#保存累加结果的变量
	result = 0
	#逐个获取从 1 到 100 这些值，并做累加操作
	for i in range(101):
	    result += i
	print(result)

for 循环遍历字典
在使用 for 循环遍历字典时，经常会用到和字典相关的 3 个方法，即 items()、keys() 以及 values()，它们各自的用法已经在前面讲过，这里不再赘述。当然，如果使用 for 循环直接遍历字典，则迭代变量会被先后赋值为每个键值对中的键。

else

无论是 while 循环还是 for 循环，其后都可以紧跟着一个 else 代码块，它的作用是当循环条件为 False 跳出循环时，程序会最先执行 else 代码块中的代码。
以 while 循环为例，下面程序演示了如何为 while 循环添加一个 else 代码块：

	add = "happy everyday!"
	i = 0
	while i < len(add):
	    print(add[i],end="")
	    i = i + 1
	else:
	    print("\n执行 else 代码块")

程序执行结果为：

happy everyday!
执行 else 代码块

上面程序中，当i==len(add)结束循环时（确切的说，是在结束循环之前），Python 解释器会执行 while 循环后的 else 代码块。

也可以为 for 循环添加一个 else 代码块，例如：

	add = "happy everyday!"
	for i in  add:
	    print(i,end="")
	else:
	    print("\n执行 else 代码块")

程序执行结果为：

happy everyday!
执行 else 代码块

break continue

和其他语言的break continue功能基本一样。只讲注意事项。
前面讲道，for 循环后也可以配备一个 else 语句。这种情况下，如果使用 break 语句跳出循环体，不会执行 else 中包含的代码。举个例子：

	add = "happy everyday!"
	for i in add:
	    if i == ',' :
	        #终止循环
	        break
	    print(i,end="")
	else:
	    print("执行 else 语句中的代码")
	print("\n执行循环体外的代码")

程序执行结果为：

happy everyday!
执行循环体外的代码

从输出结果可以看出，使用 break 跳出当前循环体之后，该循环后的 else 代码块也不会被执行。但是，如果将 else 代码块中的代码直接放在循环体的后面，则该部分代码将会被执行。

python推导式

列表推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。

列表推导式的语法格式如下：

	[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]

此格式中，[if 条件表达式] 不是必须的，可以使用，也可以省略。

通过列表推导式的语法格式，明显会感觉到它和 for 循环存在某些关联。其实，除去 [if 条件表达式] 部分，其余各部分的含义以及执行顺序和 for 循环是完全一样的（表达式其实就是 for 循环中的循环体），即它的执行顺序如下所示：

	for 迭代变量 in 可迭代对象
	    表达式

列表推导式最终会将循环过程中，计算表达式得到的一系列值组成一个列表。

例：

	a_range = range(10)
	# 对a_range执行for表达式
	a_list = [x * x for x in a_range]
	# a_list集合包含10个元素
	print(a_list)

上面代码的第 3 行会对 a_range 执行迭代，由于 a_range 相当于包含 10 个元素，因此程序生成的 a_list 同样包含 10 个元素，且每个元素都是 a_range 中每个元素的平方（由表达式 x*x 控制）。

运行上面代码，可以看到如下输出结果：

[0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64, 81]

不仅如此，我们还可以在列表推导式中添加 if 条件语句，这样列表推导式将只迭代那些符合条件的元素。例如如下代码：

	b_list = [x * x for x in a_range if x % 2 == 0]
	# a_list集合包含5个元素
	print(b_list)

第一行代码与程序一中第 3 行代码大致相同，只是为这里给列表推导式增加了 if 条件语句，这会导致推导式只处理 range 区间的偶数，因此程序生成的 b_list 只包含 5 个元素。

运行上面代码，可以看到如下输出结果：

[0 ,4 , 16, 36, 64]

Python元组推导式
元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式的语法格式如下：

	(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )

其中，用 [] 括起来的部分，可以使用，也可以省略。

通过和列表推导式做对比，你会发现，除了元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是 []，其它完全相同。不仅如此，元组推导式和列表推导式的用法也完全相同。

例如，我们可以使用下面的代码生成一个包含数字 1~9 的元组：

	a = (x for x in range(1,10))
	print(a)

运行结果为：

<generator object at 0x0000020BAD136620>

从上面的执行结果可以看出，使用元组推导式生成的结果并不是一个元组，而是一个生成器对象，这一点和列表推导式是不同的。

如果我们想要使用元组推导式获得新元组或新元组中的元素，有以下三种方式：

使用 tuple() 函数，可以直接将生成器对象转换成元组，例如：
a = (x for x in range(1,10))
print(tuple(a))
运行结果为：
(1, 2, 3, 4, 5, 6, 7, 8, 9)
直接使用 for 循环遍历生成器对象，可以获得各个元素，例如：
a = (x for x in range(1,10))
for i in a:
print(i,end=’ ')
print(tuple(a))
运行结果为：
1 2 3 4 5 6 7 8 9 ()

注意，无论是使用 for 循环遍历生成器对象，还是使用 next() 方法遍历生成器对象，遍历后原生成器对象将不复存在，这就是遍历后转换原生成器对象却得到空元组的原因。

Python字典推导式
Python 中，使用字典推导式可以借助列表、元组、字典、集合以及 range 区间，快速生成符合需求的字典。

字典推导式的语法格式如下：

	{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}

其中，用 [] 括起来的部分，可以使用，也可以省略。

可以看到，和其它推导式的语法格式相比，唯一不同在于，字典推导式用的是大括号{}。

	listdemo = ['哈哈哈','hahaha']
	#将列表中各字符串值为键，各字符串的长度为值，组成键值对
	newdict = {key:len(key) for key in listdemo}
	print(newdict)

运行结果为：

{‘哈哈哈’: 3 ,‘hahaha’: 6}

交换现有字典中各键值对的键和值。

	olddict={'哈哈哈': 3, 'hahaha': 6}
	newdict = {v: k for k, v in olddict.items()}
	print(newdict)

运行结果为：

{3: ‘哈哈哈’, 6: ‘hahaha’}

使用 if 表达式筛选符合条件的键值对。

	olddict={'哈哈哈': 3, 'hahaha': 6}
	newdict = {v: k for k, v in olddict.items() if v>4}
	print(newdict)

运行结果为：

{6: ‘hahaha’}

zip()

zip() 函数是 Python 内置函数之一，它可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组。

zip() 函数的语法格式为：

	zip(iterable, ...)

其中 iterable,… 表示多个列表、元组、字典、集合、字符串，甚至还可以为 range() 区间。

下面程序演示了 zip() 函数的基本用法：

	my_list = [11,12,13]
	my_tuple = (21,22,23)
	print([x for x in zip(my_list,my_tuple)])
	my_dic = {31:2,32:4,33:5}
	my_set = {41,42,43,44}
	print([x for x in zip(my_dic)])
	my_pychar = "python"
	my_shechar = "shell"
	print([x for x in zip(my_pychar,my_shechar)])

程序执行结果为：

[(11, 21), (12, 22), (13, 23)]
[(31,), (32,), (33,)]
[(‘p’, ‘s’), (‘y’, ‘h’), (‘t’, ‘e’), (‘h’, ‘l’), (‘o’, ‘l’)]

如果分析以上的程序和相应的输出结果不难发现，在使用 zip() 函数“压缩”多个序列时，它会分别取各序列中第 1 个元素、第 2 个元素、… 第 n 个元素，各自组成新的元组。需要注意的是，当多个序列中元素个数不一致时，会以最短的序列为准进行压缩。

另外，对于 zip() 函数返回的 zip 对象，既可以像上面程序那样，通过遍历提取其存储的元组，也可以向下面程序这样，通过调用 list() 函数将 zip() 对象强制转换成列表：

	my_list = [11,12,13]
	my_tuple = (21,22,23)
	print(list(zip(my_list,my_tuple)))

程序执行结果为：

[(11, 21), (12, 22), (13, 23)]

reversed()

reserved() 是 Pyton 内置函数之一，其功能是对于给定的序列（包括列表、元组、字符串以及 range(n) 区间），该函数可以返回一个逆序序列的迭代器（用于遍历该逆序序列）。

reserved() 函数的语法格式如下：

	reversed(seq)

其中，seq 可以是列表，元素，字符串以及 range() 生成的区间列表。

下面程序演示了 reversed() 函数的基本用法：

	#将列表进行逆序
	print([x for x in reversed([1,2,3,4,5])])
	#将元组进行逆序
	print([x for x in reversed((1,2,3,4,5))])
	#将字符串进行逆序
	print([x for x in reversed("abcdefg")])
	#将 range() 生成的区间列表进行逆序
	print([x for x in reversed(range(10))])

程序执行结果为：

[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]
[‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

除了使用列表推导式的方式，还可以使用 list() 函数，将 reversed() 函数逆序返回的迭代器，直接转换成列表。例如：

	#将列表进行逆序
	print(list(reversed([1,2,3,4,5])))

程序执行结果为：

[5, 4, 3, 2, 1]

再次强调，使用 reversed() 函数进行逆序操作，并不会修改原来序列中元素的顺序，例如：

	a = [1,2,3,4,5]
	#将列表进行逆序
	print(list(reversed(a)))
	print("a=",a)

程序执行结果为：

[5, 4, 3, 2, 1]
a= [1, 2, 3, 4, 5]

sorted()

sorted() 作为 Python 内置函数之一，其功能是对序列（列表、元组、字典、集合、还包括字符串）进行排序。

sorted() 函数的基本语法格式如下：

	list = sorted(iterable, key=None, reverse=False)  

其中，iterable 表示指定的序列，key 参数可以自定义排序规则；reverse 参数指定以升序（False，默认）还是降序（True）进行排序。sorted() 函数会返回一个排好序的列表。

注意，key 参数和 reverse 参数是可选参数，即可以使用，也可以忽略。

下面程序演示了 sorted() 函数的基本用法：

	#对列表进行排序
	a = [5,3,4,2,1]
	print(sorted(a))
	#对元组进行排序
	a = (5,4,3,1,2)
	print(sorted(a))
	#字典默认按照key进行排序
	a = {4:1,\
	     5:2,\
	     3:3,\
	     2:6,\
	     1:8}
	print(sorted(a.items()))
	#对集合进行排序
	a = {1,5,3,2,4}
	print(sorted(a))
	#对字符串进行排序
	a = "51423"
	print(sorted(a))

程序执行结果为：

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[(1, 8), (2, 6), (3, 3), (4, 1), (5, 2)]
[1, 2, 3, 4, 5]
[‘1’, ‘2’, ‘3’, ‘4’, ‘5’]

再次强调，使用 sorted() 函数对序列进行排序， 并不会在原序列的基础进行修改，而是会重新生成一个排好序的列表。例如：

	#对列表进行排序
	a = [5,3,4,2,1]
	print(sorted(a))
	#再次输出原来的列表 a
	print(a)

程序执行结果为：

[1, 2, 3, 4, 5]
[5, 3, 4, 2, 1]

显然，sorted() 函数不会改变所传入的序列，而是返回一个新的、排序好的列表。

除此之外，sorted(）函数默认对序列中元素进行升序排序，通过手动将其 reverse 参数值改为 True，可实现降序排序。例如：

	#对列表进行排序
	a = [5,3,4,2,1]
	print(sorted(a,reverse=True))

程序执行结果为：

[5, 4, 3, 2, 1]

另外在调用 sorted() 函数时，还可传入一个 key 参数，它可以接受一个函数，该函数的功能是指定 sorted() 函数按照什么标准进行排序。