一.函数介绍
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码块。函数能提高应用的模块性，和代码的重复利用率。python有很多内建函数，比如 print() 。但你也可以自己创建函数，这叫做用户自定义函数。
二.自定义函数
1.定义规则
（1）函数代码块以 def 关键词开头，后接函数标识符名称（自己定义的函数名）和圆括号（）。
（2）任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
（3）函数内容以冒号开始，并且缩进。
（4）函数只有调用时才会执行。
def function_name(para):
print("函数体代码")2.函数调用
通过函数名加英文状态下的小括号对函数进行调用，如：function_name()?
def function_name(para):
print("函数体代码")
function_name() # 函数调用运行结果：
函数体代码三.函数的参数
1.形参与实参
（1）形参就是形式上的参数，没有实际的意值，通过别人赋值后才有意义，相当于变量。
（2）实参就是实际意义上的参数，是一个实际存在的参数。
def test(b): # 形参
print(b)
a = 1
test(a) # 实参2.可变类型参数与不可变类型参数
（1）不可变类型参数在函数体内对变量进行赋值，相当于重新开辟了一块空间来保存值。
def test(a):
a = 10
print('111',a) # 10
a = 1
test(a)
print('222',a) # 1（2）可变类型参数在函数体内可以改变原有的值。
def test1(li):
li.extend([1,11])
print('111',li) # [1, 2, 3, 1, 11]
li = [1,2,3]
test1(li)
print('222',li) # [1, 2, 3, 1, 11]3.位置参数
位置参数就是实参与形参顺序一一对应，而不是变量名。
def sum_nums(num1, num2):
result = num1 + num2
print("num1",num1)
print("num2",num2)
num1 = int(input("请输入num1:"))
num2 = int(input("请输入num2:"))
sum_nums(num1, num2)
sum_nums(num2, num1)假如 input 输入的 num1 为10，num2 为20。
sum_nums(num1 ,num2) 调用执行的结果为10，20。
sum_nums(num2?,num1) 调用执行的结果为20，10。
4.关键字参数
以形参作为关键字作为参数，不论参数位置。
?
5.默认值参数
形参数进行赋值，所以当调用时不传该参数就默认使用形参处的值。当调用时传了该参数，则覆盖掉默认参数。
?
6.可变长度参数
（1）*args 接受时会转变为元组类型（args只是一个默认的名字，也可以改名）
?（2）**kwargs接受时会转为字典数据类型
（3）解包（*args的逆过程，但要注意函数的形参数要与元组的长度一致）
四.函数的返回值
1.返回值介绍
当两个函数之间，想要互相使用到内部变量时，就可以应用到函数的返回值。
比如：今天距离放假还有13天；放假距离春节5天，今天距离春节多少天？
?注意：（1）使用 return 关键字返回内容，（2）将内容返回到函数调用处，（3）函数体中没有 return 时，函数运行结束，则默认返回 None ，也被称为隐含返回值。
2.多个返回值
（1）当执行函数体内代码时，遇到第一个 return 就将值返回到函数调用处，也就是执行到 return 这行代码，后面的都不执行。
（2）多个返回值时，用逗号隔开，但默认为为元组。
五.函数作用域
1.函数作用域介绍
Python中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共分为4种，分别是：
（1）L（local）：局部作用域，即函数中定义的变量；
（2）E（enclosing）：嵌套的父级函数的局部作用域，即包含此函数的上级函数的作用域，但不是全局的；
（3）G（global）：全局变量，就是模块级别定义的变量；
（4）B（build-in）：内建作用域，系统固定模块里面的变量，比如：int()等。
2.作用域优先级
局部作用域(L) > 父级函数作用域(E) > 全局作用域(G) > 系统模块(B)
a = int(3.14) # built-in
b = 11 # global
def outer():
c = 5 # enclosing
def inner():
d = 6 # local
return 1?但是注意在函数内部无法追截修改全局变量。
?
3.global关键字
那当我们需要在函数内部直接修改全局变量时，我们可以将函数内部的局部变量通过 global 关键字声明为全局变量。
?
六.递归函数
1.递归函数介绍
函数Func(args)直接或间接调用函数本身，则该函数称为递归函数。实例如下：
1.计算阶乘
（1）阶乘本质：n! = 1 * 2 * 3 * ... * n,
（2）用函数func(n)表示, 可以看出:func(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = func(n-1) * n,所以, func(n)可以表示为n * func(n-1)。
代码如下：
2.计算累加
代码如下：
?
七.常用内置函数
1.range() 函数——range(start,stop[,step]) ->range object
（1）start 计数从start开始。默认为0。例如：range(3)等价于range(0,3);
（2）stop 计数到stop结束，但不包括 stop 。例如：list(range(0,3))是 [0,1,2] 而没有3；
（3）step 为步长，默认为。例如：range(0,3) 等价于 range(0,3,1)。
注意：在python3中，range() 函数返回的是一个range() 对象。而python2中直接返回的是列表。
>>> range(3)
range(0, 3) # 返回range对象
>>> list(range(0,3)) # 转为list
[0, 1, 2]
>>> list(range(0,10,2)) # 步长
[0, 2, 4, 6, 8]在实际应用中，range() 函数通常结合 for 循环使用。比如，遍历 1-10的数。
>>> for i in range(1,11):
... print(i)
...
1
2
3
4
5
6
7
8
9
102.zip() 函数
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
zip(iter1 [,iter2 [...]]) --> zip object
（1）iter为可迭代的对象
（2）返回值为zip对象
实例：
>>> li1 = [1,2,3]
>>> li2 = [4,5,6]
>>> zip(li1,li2) # 返回的是zip object
<zip object at 0x0000021049539908>
>>> list(zip(li1,li2)) # 转为list
[(1, 4), (2, 5), (3, 6)]?
3.map() 函数
map() 函数会根据提供的函数对指定序列做映射。
map(func, *iterables) --> map object
（1）func 以参数序列中的每一个元素调用 func 函数，返回包含每次 func 函数返回值的新列表。
实例：
>>> li = [1,2,3,4]
>>> map(str,li)
<map object at 0x0000021049778438>
>>> list(map(str,li))
['1', '2', '3', '4']
?
?
4.filter() 函数
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
filter(function or None, iterable) --> filter object
（1）function为自定义函数
（2）iterable为可迭代的对象
（3）返回值为filter对象
?
八.匿名函数
1.介绍：当我们在传入函数时，有些时候，不需要去重复调用该函数，直接传入匿名函数更加方便，也无需担心函数名冲突，并且还可以将匿名函数赋值给一个变量，再利用变量来调用该函数。
2.语法
（1）匿名函数表达式为 lambda x:x*x；
（2）关键字 lambda 表示匿名函数；
（3）冒号前面的 x 表示函数参数；
（4）x*x 是匿名函数的表达式，并且注意匿名函数只能有一个表达式，不能写 return ，返回值就是该表达式的结果。
实际上就是：
def f(x):
return x * x3.匿名函数作返回值
?注意当返回的匿名函数里面有参数时，就相当于一个普通的匿名函数，而这种方法返回的匿名函数实际上是，一个无参的函数，返回为一个固定的常数。
?
4.匿名函数作实参
?
九.高阶函数
实际上，map() , filter() , 等都是高阶函数。那么只要满足以下一个条件的就是高阶函数。
1.函数名作为参数传入；
2.函数名作为返回值。
十.闭包
闭包的定义需要满足以下三个条件：
1.在一个外函数中定义了一个内函数；
2.内函数里调用了外函数的临时变量；
3.并且外函数的返回值是内函数的引用。
代码如下：
def test(number):
print("--1--")
def test_in(number_in): # 1.内部函数
print(number_in)
print("--2--")
return number_in + number # 2.外部环境的变量引用
print("--3--")
return test_in #3.内部函数test_in返回
res = test(20) # res = test_in
res(25) 
?
十一.装饰器
由于我们在开发中要遵循封闭开放的原则，所以python开发者开始使用装饰器，装饰器也就是说在不改变源代码的情况下为函数添加新的功能。并且使用 @ 符号，@符号为语法糖。
举例如下：
import time
def calcu_time(func):
def test_in():
start = time.time()
func()
end = time.time()
print("spend {}".format(end - start))
return test_in
@calcu_time
def test1():
print("---test1---")
time.sleep(2)
test1() 
?