一、函数（补充）
1.1.函数定义
你可以定义一个由自己想要功能的函数，以下是简单的规则：函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
使用 def 关键字，一般格式如下：
def 函数名（参数列表）:
函数体
示例：
def add(x, y):
print("x+y={0}".format(x + y))
return x + y
add(34, 40)
返回结果：
x+y=74
1.2.函数关键字
def ：定义函数
return：返回值
pass：略过
exit(1)：直接退出
示例1：
#字符遇到e就pass，遇到t就返回
str = "appletestletappendeverythingfinished"
def check(s):
for i in s:
if i == "e":
pass
print("遇到e了，直接pass")
elif i=="t":
print("字母t的下标为：{0}".format(i))
return s.index("t")
print("当前字母为：{0}".format(i))
if __name__=="__main__":
check(str)
示例2：
def test():
while 1:
n = input("请输入字符串：")
if n=="quit":
print("输入了quit，程序直接退出")
exit(1)
for i in range(0,len(n)):
print(n[i])
if __name__=="__main__":
test()
1.3.函数参数
函数可以是字符串，还可以是以下两种类型参数
def(*args, **kwargs)
其中：
*args：元组类型参数 tuple(1,)
**kwargs：字典类型参数，dict{"k":"v"}
示例：
def fun(*args1,**args2):
print("**args2字典参数为：{0}".format(args2))
if __name__=="__main__":
fun(1,2,3,4,5,a="test1",b="test2")
结果
*args1元组参数为：(1, 2, 3, 4, 5)
**args2字典参数为：{'a': 'test1', 'b': 'test2'}
1.4.匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
如：
lambda x,y:x+y
相当于
def add(x,y):
return x+y
示例
#求两个数的和
sums=lambda x,y:x+y
print("和为：{0}".format(sums(20,30)))
结果
和为：50
1.5.高阶函数
1.5.1.map
map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
不常用
map(function, iterable)
参数
function -- 函数，有两个参数
iterable -- 一个或多个序列
返回值
Python 2.x 返回列表。
Python 3.x 返回迭代器。
示例
#求两个列表对应位置的数据之和
print("两个列表相应位置元素之和为：{0}".format(list(map(lambda x,y:x+y,[1,2,3,4,5],[11,12,13,14,15]))))
1.5.2.reduce
reduce() 函数会对参数序列中元素进行累积。函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
不常用
语法
reduce(function, iterable[, initializer])
参数
function -- 函数，有两个参数
iterable -- 可迭代对象
initializer -- 可选，初始参数
返回值
返回函数计算结果。
示例
from functools import reduce
def add(x,y):
return x+y
print(reduce(add,[1,2,3,4,5]))
1.5.3.filter
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法
filter(function, iterable)
参数
function -- 判断函数。
iterable -- 可迭代对象。
返回值
Python 2.x 返回列表。
Python 3.x 返回迭代器。
示例
def grok(n):
return n%2==1
newlist=filter(grok,[12,13,15,16,18,1,7,19,22,25,31,34])
print(list(newlist))
1.5.4.sorted排序
sorted() 函数对所有可迭代的对象进行排序操作。sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作
语法
sorted(iterable, key=None, reverse=False)
参数
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回值
返回重新排序的列表。
m = dict(a=1,c=10,b=20,d=15)
print(m)
print(sorted(m.items(),reverse=True)) #默认以第一列值进行排序，即以key进行排序
print(dict(sorted(m.items(),key=lambda x:x[1]))) #以value值进行排序,x[0]指的是key，x[1]指的是value
结果
{'a': 1, 'c': 10, 'b': 20, 'd': 15}
[('d', 15), ('c', 10), ('b', 20), ('a', 1)]
{'a': 1, 'c': 10, 'd': 15, 'b': 20}
二、生成式和生成器
2.1.生成式
列表生成式格式[exp for val in collection if condition]
示例：
#九宫格
def jgg():
count = 1
number = list()
for i in range(1, 10):
number.append(i)
for A in [x for x in range(1, 10)]:
for B in [x for x in range(1, 10) if x != A]:
for C in [x for x in range(1, 10) if x != A and x != B]:
for D in [x for x in range(1, 10) if x != A and x != B and x != C]:
for E in [x for x in range(1, 10) if x != A and x != B and x != C and x != D]:
for F in [x for x in range(1, 10) if x != A and x != B and x != C and x != D and x != E]:
for G in [x for x in range(1, 10) if
x != A and x != B and x != C and x != D and x != E and x != F]:
for H in [x for x in range(1, 10) if
x != A and x != B and x != C and x != D and x != E and x != F and x != G]:
for I in [x for x in range(1, 10) if
x != A and x != B and x != C and x != D and x != E and x != F and x != G and x != H]:
if ( A + B + C == D + E + F == G + H + I == A + D + G == B + E + H == C + F + I == A + E + I == G + E + C == 15):
print('''
第{9}种排序
-------
|{0}|{1}|{2}|
|{3}|{4}|{5}|
|{6}|{7}|{8}|
-------
'''.format(A, B, C, D, E, F, G, H, I, count))
count += 1
jgg()
第1种排序
-------
|2|7|6|
|9|5|1|
|4|3|8|
-------
第2种排序
-------
|2|9|4|
|7|5|3|
|6|1|8|
-------
第3种排序
-------
|4|3|8|
|9|5|1|
|2|7|6|
-------
第4种排序
-------
|4|9|2|
|3|5|7|
|8|1|6|
-------
第5种排序
-------
|6|1|8|
|7|5|3|
|2|9|4|
-------
第6种排序
-------
|6|7|2|
|1|5|9|
|8|3|4|
-------
第7种排序
-------
|8|1|6|
|3|5|7|
|4|9|2|
-------
第8种排序
-------
|8|3|4|
|1|5|9|
|6|7|2|
-------
2.2.生成器（generator）
方法一：
#列表生成式为[]，生成器为()
(exp for val in collection if condition)
方法二：
使用yield关键字，包含yield语句的函数会被特地编译成生成器
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器（iter和next）。
在调用生成器运行的过程中,yield可以理解成return，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
示例
def test():
for i in range(1,10):
yield i
print("=====" * 10)
m = test() #生成了一个迭代器
print(m)
for i in iter(m):
print(i)
结果
==================================================
<generator object test at 0x00000000026F7570>
1
2
3
4
5
6
7
8
9
什么情况下需要使用 yield？
一个函数 f，f 返回一个迭代器，这个迭代器是动态计算出来的（不管是数学上的计算还是逻辑上的读取格式化），并且这个迭代器会很大（无论是固定很大还是随着输入参数的增大而增大），这个时候，我们希望每次调用这个函数并使用迭代器进行循环的时候一个一个的得到每个元素来节省内存，这个时候 yield 就很有用。