一、函数的基本语法及特性
函数定义：
定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可
特性:
- 减少重复代码
- 使程序变的可扩展
- 使程序变得易维护
语法定义：
# def 函数名（参数）： # 函数体 # 。。。 # 返回值 # def hanshu(): #定义函数用关键字def # print("函数DEMO") # hanshu() #调用函数
二、函数参数
形参 变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参 可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
(
形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与实参一一对应）
实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参
区别：形参是虚拟的，不占用内存空间，.形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参
)
# def school_list(name,age,sex): #nameagesex 为形参 # print("name:",name) # print("age:",age) # print("male:",sex) # # # 调用函数school_list # school_list('xiaoming',45,'male') #'xiaoming',45,'male' 为实参默认参数
必备参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
def f(name,age): print('I am %s,I am %d'%(name,age)) f('yang',18) f('xin',16)
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def f(name,age): print('I am %s,I am %d'%(name,age)) # f(16,'xin') #报错 f(age=16,name='alvin')
默认参数（缺省参数）
如果要解决这个问题就可以给函数的值指定一个默认值，指定函数的默认值需要在def这一行指定，制定之后，当调用这个函数的时候就不需要输入函数值了
def school_list(name, age, sex='male'): #sex='male'关键参数（默认参数），关键参数必须在位置参之后
非固定参数：*args和**kwargs
# def school_list(name, age, *args): #非固定参数*args 会把多传入的参数变成一个元组形式
# print(name,age,args)
# school_list('xiaoming', 45, 'args', '安徽念书') #xiaoming 45 ('args', '安徽念书')
# def school_list(name,*args,**kwargs): #*kwargs 会把多传入的参数变成一个dict形式
# print(name,args,kwargs)
# school_list('xiaoming', age=23) #xiaoming () {'age': 23}
三、全局变量和局部变量
- 在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
- 全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
- 当全局变量与局部变量同名时：
- 在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
局部变量
# name = "xiaopang" # def school_list(name): # print(name) # name = "erpang" # print(name) # # #调用 # school_list(name) # print("在外面看看name改了吗?:",name) # # xiaopang # # erpang # # 在外面看看name改了吗?: xiaopang
四、作用域
在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）是不会引入新的作用域的
python中的作用域分4种情况：
- L：local，局部作用域，即函数中定义的变量；
- E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；
- G：global，全局变量，就是模块级别定义的变量；
- B：built-in，系统固定模块里面的变量，比如int, bytearray等。 搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。
局部名称空间--->全局名称空间--->内置名称空间
global关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了，当修改的变量是在全局作用域（global作用域）上的，就要使用global先声明一下，代码如下：
count = 10 def outer(): global count print(count) count = 100 print(count) outer() #10 #100
nonlocal关键字
global关键字声明的变量必须在全局作用域上，不能嵌套作用域上，当要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量怎么办呢，这时就需要nonlocal关键字了
def outer(): count = 10 def inner(): nonlocal count count = 20 print(count) inner() print(count) outer() #20 #20
小结：
（1）变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域；
（2）只有模块、类、及函数才能引入新作用域；
（3）对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；
（4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个 关键字，就能完美的实现闭包了。
五、返回值
要想获取函数的执行结果，就可以用return语句把结果返回
注意:
- 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
- 如果未在函数中指定return,那这个函数的返回值为None
补充（高阶函数）：
高阶函数是至少满足下列一个条件的函数:
- 接受一个或多个函数作为输入
- 输出一个函数
def add(x,y,f): return f(x) + f(y) res = add(3,-6,abs) print(res) ############### def foo(): x=3 def bar(): return x return bar
六、 递归
定义：在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
# 实例 累加 # def fact(n): # result = n # for i in range(1,n): # result += i # return result # # print(fact(100)) #递归 累加 # def fact(n): # if n == 2: # return 2 # return n + fact(n-1) # print(fact(5)) #实例(斐波那契数列) # def f(n): # # before = 0 # # after = 1 # # for i in range(1,n-1): # # ret = before + after # # before = after # # after = ret # # return ret # # print(f(10)) # def f(n): # # if n <= 1: # # return n # # return (f(n-1) + f(n-2)) # # print(f(4000)) #maximum recursion depth exceeded in comparison
递归函数的优点: 是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返 回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)
七、内置函数
内置函数：https://docs.python.org/3.5/library/functions.html#func-memoryview
重要的内置函数：
#filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果
自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。（常用于对列表的筛选） # sun = ['a','b','c','d'] # def fun(s): # if s != 'c': # return s # res = filter(fun,sun) #返回的时一个对象，是一个对象的地址 # print(list(res)) #可以通过列表，元组等打印出来 # str = ['a', 'b', 'c', 'd'] # def fun1(s): # if s != 'a': # return s # # # ret = filter(fun1, str) # # print(list(ret)) # ret是一个迭代器对象 # map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。（对于list的每个元素挨个调用的函数方式挨个处理） # sun = ['a','b','c','d'] # def fun(s): # return s + "happy" # res = map(fun,sun) # print(list(res)) #['ahappy', 'bhappy', 'chappy', 'dhappy'] # sun = ['a','b','c','d'] # def fun(s): # return s + "happy" # res = map(fun,sun) # print(list(res)) # reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，（对列表的元素从头开始，两个两个处理）
reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。reduce(f, [1, 3, 5, 7, 9], 100)=reduce(函数，列表，参数) # from functools import reduce # def add(x,y): # return x*y # print(add(2,3)) # lambda匿名函数 lambda x: x * x # fun = lambda x,y : x+y # print (fun(3,4))
小结：1.filter（）主要用于对列表的筛选 2.map（）主要通过对list的单个元素处理 3. reduce（）对列表的元素从头开始，两个两个处理