一.函数的作用

1.减少重复代码

2.方便修改，易于扩展

3.保持代码一致性，增强可读性

二.函数的使用和结构

1.函数的创建：

def 函数名(<参数>):

　　函数体

2.函数的调用：函数名(<参数>)

3.函数的命名规则：和变量一样

4.函数和变量类似，故函数名也可以进行赋值，如f1=f2，则f2函数与f1函数功能一样

5.函数的参数：

（1）形参：

形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与实参一一对应）

（2）实参：

实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参

（3）区别：

形参是虚拟的，不占用内存空间，.形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参

6.实例：

import time

times=time.strftime('%Y--%m--%d')  #取出当前时间

def f(time):

　　print('Now  time is : %s'%times)  #利用格式化输出，将变化内容作为参数

f(times)

三.函数的参数

1.必备参数

（1）备注：必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

（2）示例：

def f(name,age):

　　print('Name：%s \n Age：%d' %(name,age))

f('zhou',20)

2.关键字参数

（1）备注：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

（2）示例：

def f(name,age):

　　print('Name：%s \n Age：%d' %(name,age))

f(age=20,name='zhou')

3.默认参数

（1）备注：调用函数时，缺省参数的值如果没有传入，则被认为是默认值。一般放在其他参数的后面。

（2）示例：

def f(name,age,sex='male'):

　　print('Name：%s　　\n Age：%d　　\n Sex：%s'　　%(name,age,sex))

f('zhou',20)

f('lin',20,'female')

4.不定长参数

（1）备注：一个函数能处理比当初声明时更多的参数，这样的参数叫做不定长参数，和上述2种参数不同，声明时不会命名。

（2）示例1：（加法器）

def add(*args):  #*代表参数不定长，且参数为元组形式

　　sum=0

　　for i in args:

　　　　sum+=i

　　print(sum)

add(1,2,3)

（3）示例2：（个人信息显示）

def f(*args,**kwargs):  #**代表参数不定长，且参数为字典形式

　　print('Name：%s　　\n Age：%d　　\n Sex：%s'　　%(args[0],args[1],args[2]))

　　for i in kwargs:

　　　　print(%s:%s %(i,kwargs[i]))

f('zhou',20,'male',Hobby='invention',Job='student')  #前三个没有键的存入args成为元组，后两个有键的存入kwargs成为字典

（4）示例3：（将一个列表/字典拆分传输）

def f(*args/**kwargs):

　　print(args/kwargs)

f(*[1,2,3]/**{'name':'zhou'})  #此时打印结果为1，2，3/{'name':'zhou'}单个元素而不是整个列表/字典

（5）参数优先级：关键参数>默认参数>*args>**kwargs，必须按照此顺序排列实参

四.函数的返回值

（1）要想获取函数的执行结果，就可以用return语句把结果返回

（2）函数在执行过程中只要遇到return语句，就会停止执行并返回结果，所以也可以理解为 return 语句代表着函数的结束

（3）如果未在函数中指定return,那这个函数的返回值为None

（4）return多个对象，解释器会把这多个对象组装成一个元组作为一个一个整体结果输出。

（5）函数返回值既可以是一个变量，也可以是一个函数，例如：

def f():

　　def inner():

　　　　return 6

　　return inner

f()  #此时返回的是一个地址，即储存函数代码的地址

五.函数的作用域

1.作用域介绍

（1）L：local，局部作用域，即函数中定义的变量；

（2）E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；

（3）G：globa，全局变量，就是模块级别定义的变量；

（4）B：built-in，系统固定模块里面的变量，比如int, bytearray等。

（5）搜索变量的优先级顺序依次是：局部作用域>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB（从小到大）。

（6）示例：

x = int(2.9)  # int built-in

g_count = 0  # global

def outer():

　　o_count = 1  # enclosing

　　def inner():

　　　　i_count = 2  # local

2.作用域产生

在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）不会引入新的作用域

3.变量的修改

（1）局部作用域只能读取全局作用域的变量，但不能修改：（下面的程序会报错）

x=1

def a():

　　print（x）#此时拿到的是全局变量10

　　x=2  #错误的原因在于print(x)时,解释器会在局部作用域找,会找到x=2(函数已经加载到内存),但x使用在声明前了,所以报错

a()

（2）要想修改全局作用域中的变量，需在局部变量前加global

（3）要想修改嵌套作用域中的变量，需在局部变量前加nonlocal

 六.高阶函数

1.高阶函数需要满足的条件（至少其中之一）：

（1）接受一个或多个函数作为输入

（2）输出一个函数

2.示例：

def f(n):

　　return n*n

def F(a,b,func)

　　print(f(a)+f(b))

F(1,2,f)  #输出5

七.递归函数

1.定义：在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

2.递归函数的优点：定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

3.递归特性：

（1）必须有一个明确的结束条件

（2）每次进入更深一层递归时，问题规模相比上次递归都应有所减少

（3）递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

八.内置函数

1.内置函数大全：https://docs.python.org/3.5/library/functions.html#repr

2.重要的内置函数：

（1）filter(function, sequence)  #将sequence中的item一个一个传入function

示例：

　　str = ['a','b','c','d']

　　def fun1(s):

　　　　if s != 'a':

　　　　　　return s

　　ret = filter(fun1, str)

　　print(list(ret))  #ret是一个迭代器对象

解释：对sequence中的item依次执行function(item)，将执行结果为True的item做成一个filter object的迭代器返回。可以看作是过滤函数。

（2）map（function, sequence）

示例1：

　　str = ['a','b','c']

　　def fun2(s):

　　　　return s+‘zhou’

　　ret = map(fun2, str)

　　print(list(ret))  #['azhou', 'bzhou', 'czhou']

解释：对sequence中的item依次执行function(item)，将执行结果组成一个map object迭代器返回。

示例2：

　　ef add(x,y):

　　　　return x+y

　　print (list(map(add, range(10), range(10))))##[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

解释：map也支持多个sequence，这就要求function也支持相应数量的参数输入

（3）reduce(function, sequence, starting_value)

示例：

　　from functools import reduce

　　def add1(x,y):

　　　　return x + y  #若为x*y则可以用来做阶乘

　　print (reduce(add1, range(1, 101)))  # 5050 （注：1+2+...+99+100）

　　print (reduce(add1, range(1, 101), 20))  # 4970 （注：1+2+...+99+20）

解释：对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用。

（4）lambda  #匿名函数

匿名函数的命名规则：

　　用lamdba 关键字标识，冒号（：）左侧表示函数接收的参数（a,b） ,冒号（：）右侧表示函数的返回值（a+b）。

普通函数与匿名函数的对比：

#普通函数

　　def add(a,b):

　　　　return a + b

　　print(add(2,3))

#匿名函数

　　add=lambda a,b : a + b, [2,3]

　　print(add(2,3))  #一行即可实现上面多行内容，用于代码简化

#输出

　　5

　　5

匿名函数使用范围：当函数名不重要而只用其内容时，可以用lambda将函数体直接引用，省去定义函数的代码

3.结合使用功能更加强大：

（1）阶乘：（reduce+lambda）

　　from functools import reduce

　　print (reduce(lambda x,y: x*y, range(1,6)))

（2）平方：（map+lambda）

　　squares = map(lambda x : x*x ,range(9))

　　print (squares)  #<map object at 0x10115f7f0>迭代器

　　print (list(squares))  #[0, 1, 4, 9, 16, 25, 36, 49, 64]