一、函数的基本语法及特性

函数定义：

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

减少重复代码

使程序变的可扩展

使程序变得易维护

语法定义：

#def 函数名(参数)：#函数体#。。。#返回值

#def hanshu(): #定义函数用关键字def#print(“函数DEMO”)#hanshu() #调用函数

二、函数参数

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

(

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

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

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

)

#def school_list(name,age,sex): #name\age\sex 为形参#print(“name:”,name)#print(“age:”,age)#print(“male:”,sex)#

## 调用函数school_list#school_list(‘xiaoming’,45,’male’) #’xiaoming’,45,’male’ 为实参默认参数

必备参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

deff(name,age):print(‘I am %s,I am %d’%(name,age))

f(‘yang’,18)

f(‘xin’,16)

关键字参数

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

deff(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

defouter():globalcountprint(count)

count= 100

print(count)

outer()#10#100

nonlocal关键字

global关键字声明的变量必须在全局作用域上，不能嵌套作用域上，当要修改嵌套作用域(enclosing作用域，外层非全局作用域)中的变量怎么办呢，这时就需要nonlocal关键字了

defouter():

count= 10

definner():

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

补充(高阶函数)：

高阶函数是至少满足下列一个条件的函数:

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

输出一个函数

defadd(x,y,f):return f(x) +f(y)

res= add(3,-6,abs)print(res)###############

deffoo():

x=3

defbar():returnxreturn 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)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返     回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)

七、内置函数

重要的内置函数：

#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()对列表的元素从头开始，两个两个处理