一：为何要用函数

（1）可以增加代码的可读性

（2）避免代码的重用

二：函数的定义与调用

（1）函数的定义：

def  函数名（参数1，参数2）:

　　‘’‘函数注释：包括函数的作用，参数是什么，返回值是什么’‘’

　　函数体

　　return 返回值

（2）函数的调用

　　函数名（）

 1 #函数的定义
 2 def my_length(s):
 3     '''计算字符串的长度，参数是要计算的字符串
 4     返回值是字符串长度'''
 5     length = 0
 6     for i in s:
 7         length += 1
 8     return length
 9 
10 #函数的调用
11 l = my_length('hello world')
12 print(l)
View Code

函数名（参数1，参数2）

三：函数返回值

关键字：return

作用：1、结束函数的执行。2、返回要返回的值

函数返回值的两种情况：

1、返回值为None

2、返回值不为None

　　返回一个值

　　返回多个值

 1 def ret_demo1():
 2     '''返回多个值'''
 3     return 1,2,3,4
 4 
 5 def ret_demo2():
 6     '''返回多个任意类型的值'''
 7     return 1,['a','b'],3,4
 8 
 9 ret1 = ret_demo1()
10 print(ret1)
11 
12 ret2 = ret_demo2()
13 print(ret2)
View Code

　　返回多个值会被组织成元组返回，也可以用多个值来接收

def ret_demo2():
    return 1,['a','b'],3,4

#返回多个值，只用一个变量接收
ret2 = ret_demo2()
print(ret2)

#返回多个值，用多个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

 

四：函数的参数

（1）实参与形参

调用函数时传递的参数是实际参数，即实参。定义在函数中的参数叫形参。

（2）传递多个参数

1、传递多个参数共有三种方法：位置传参、默认传参、动态传参

在实参中，不指定变量名即用位置传参，指定变量名的话即关键字传参

1 def mymax(x,y):
2     #此时x=10,y=20
3     the_max = x if x > y else y
4     return the_max
5 
6 ma = mymax(10,20)
7 print(ma)
View Code
def mymax(x,y):
    #此时x = 20,y = 10
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(y = 10,x = 20)
print(ma)

位置传参必须在关键字传参的前面

一个形参只能复制一次

对于形参来讲：

位置参数必须传值

位置参数必须得传值

2、默认参数

对于变化小的参数，设置为默认参数。但默认参数是可变的

默认参数

 3、动态参数

用*args与**kwargs来传递多个值，分别返回的是元组与字典。*args是按照位置来传参数，**kwargs是按照关键字来传参。*可以是把参数组合起来，也可以是把参数解压出来

 1 def mysum(*args):
 2     the_sum = 0
 3     for i in args:
 4         the_sum+=i
 5     return the_sum
 6 
 7 the_sum = mysum(1,2,3,4)
 8 print(the_sum)
 9 
10 *args求和函数应用
View Code
1 def stu_info(**kwargs):
2     print(kwargs)
3     print(kwargs['name'],kwargs['sex'])
4 
5 stu_info(name = 'alex',sex = 'male')
View Code

 五：命名空间与作用域

一：创建的存储“变量名与值的关系”的空间叫做全局命名空间，在函数的运行中开辟的临时的空间叫做局部命名空间，存放Python解释其为我们存放的名字，叫内置命名空间

二：加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)

三：取值：在局部调用：局部命名空间->全局命名空间->内置命名空间

四：作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。

　　全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效

　　局部作用域：局部名称空间，只能在局部范围内生效

　　globals和locals方法

1 def func():
2     a = 12
3     b = 20
4     print(locals())
5     print(globals())
6 
7 func()
8 
9 在局部调用globals和locals
View Code

五：函数名的本质

函数名本质就是函数的内存地址，可以当做变量使用、作为函数的参数、可以作为返回值、可以当做容器类型的元素

六：闭包函数

基本类型：

1 def func():
2     name = 'eva'
3     def inner():
4         print(name)
5     return inner
6 
7 f = func()
8 f()
View Code

七：装饰器：

基本装饰器：

 1 def wapper(func):
 2     def inner(*args,**kwargs):
 3         '''执行函数之前功能'''
 4         ret = func(*args,**kwargs)
 5         '''执行函数之后功能'''
 6         return ret
 7     return inner
 8 @wapper   #fun = wapper(fun)
 9 def fun(*args,**kwargs):
10     ret = print('from fun')
11     return ret
12 fun()
View Code

多个装饰器装饰一个函数

 1 #两个装饰器装饰函数，执行顺序为：（1）先执行第一个装饰函数的before函数，再执行第二个装饰函数before函数。
 2 #（2）在执行真正的被装饰的函数，再执行第二个装饰函数的after函数，在执行第一个装饰函数的after函数
 3 def qqxing(func):
 4     def inner(*args,**kwargs):
 5         print('in qqxing befor')
 6         ret = func(*args,**kwargs)
 7         print('in qqxing after')
 8         return ret
 9     return inner
10 
11 
12 def pipixia(func):
13     def inner(*args,**kwargs):
14         print('in pipixia before')
15         ret = func(*args,**kwargs)   #func 为被装饰函数   inner变为dapengxie
16         print('in pipixia after')
17         return ret
18     return inner
19 
20 
21 @qqxing    #dapengxie = qqxing(daoengxie)  使得func == pipixia_inner   dapengxie == qqing_inner
22 @pipixia   #dapengxie = pipixia(dapengxie)  使得func == dapengxie  dapengxie == pipixia_inner
23 def dapengxie():
24     print('enlema')
25 
26 dapengxie()
View Code

有参数的装饰器

 1 T = False
 2 # T = True
 3 def outer(flag):
 4     def wrapper(func):
 5         def inner(*args,**kwargs):
 6             if flag:
 7                 print('before')
 8                 ret = func(*args,**kwargs)
 9                 print('after')
10             else:
11                 ret = func(*args, **kwargs)
12             return ret
13         return
14     return wrapper
15 
16 @outer(T)  #--> @wrapper --> hahaha = wrapper(hahaha)
17 def hahaha():
18     print('from hahahaha')
19 
20 @outer(T)
21 def shaungww():
22     print('shangwaiwai')
23 
24 shaungww()
25 hahaha()
View Code