3-1 函数和装饰器

一函数的定义和调用

def 关键字函数名（设定与变量相同）:
函数体

例子

 1 #函数定义 2 def mylen(): 3     """计算s1的长度""" 4     s1 = "hello world" 5     length = 0 6     for i in s1: 7         length = length+1 8     print(length) 9 10 #函数调用  11 mylen()

二函数的返回值return

 1    1,遇到return，结束函数。 2     def func1(): 3         print(11) 4         print(22) 5         return 6         print(333) 7         print(444) 8     func1() 9     2,给函数的调用者(执行者)返回值。10         无 return 返回None11         return 不写 或者 None 返回None12         return 返回单个数.13         return 返回多个数，将多个数放在元组中返回。14 '''

1 没有返回值

 1 #函数定义 2 def mylen(): 3     """计算s1的长度""" 4     s1 = "hello world" 5     length = 0 6     for i in s1: 7         length = length+1 8     print(length) 9 10 #函数调用11 str_len = mylen()12 #因为没有返回值，此时的str_len为None13 print('str_len : %s'%str_len)14 15 没有return

2 返回多个值

 1 # def my_len(): 2 #     count = 0 3 #     for i in s1: 4 #         count += 1 5 #     return 666,222,count,'老男孩' 6 # print(my_len(),type(my_len())) 7  8  9 10 # def my_len():11 #     count = 012 #     for i in s1:13 #         count += 114 #     return 666,222,count15 # ret1,ret2,ret3 = my_len()  # (666, 222, 19,)16 # print(ret1)17 # print(ret2)18 # print(ret3)

3 返回一个值

 1 #函数定义 2 def mylen(): 3     """计算s1的长度""" 4     s1 = "hello world" 5     length = 0 6     for i in s1: 7         length = length+1 8     return length 9 10 #函数调用11 str_len = mylen()12 print('str_len : %s'%str_len)13 14 return返回一个值

三函数的传参

 1 li = [1, 2, 3, 43, 'fdsa', 'alex'] 2 s1 = 'fdsgdfkjlgdfgrewioj' 3  4 # def my_len(a):  # 函数的定义（）放的是形式参数，形参 5 #     count = 0 6 #     for i in a: 7 #         count += 1 8 #     return count 9 # ret = my_len(li)  # 函数的执行（） 实际参数，实参10 # print(ret)11 # print(len(s1))

3.1 实参分为：

位置参数。 必须一一对应，按顺序

# def func1(x,y):#     print(x,y)# func1(1, 2)

#2，关键字参数。必须一一对应，不分顺序。

# def func1(x,y,z):#     print(x,y,z)# func1(y=2,x=1,z=5,)

混合参数。一一对应 且 关键字参数必须在位置参数后面。

1 # def func2(argv1,argv2,argv3):2 #     print(argv1)3 #     print(argv2)4 #     print(argv3)5 # func2(1,2,argv3=4)

3.2 形参分为

#1，位置参数。 必须一一对应，按顺序

# def func1(x,y):#     print(x,y)# func1(1,2)

默认参数。 必须在位置参数后面。

1 # def register(name,sex='男'):2 #     with open('log1',encoding='utf-8',mode='a') as f1:3 #         f1.write("{} {}\n".format(name,sex))4 # register('aa')

动态参数 *args，**kwargs 万能参数

# kwargs接收的只是键值对的参数，并保存在字典中#args接收除去键值对以外的所有参数,保存成元组形式

1  ##动态参数 *args  **kwargs2 # def func2(*args,**kwargs):3 #     print(args)  ##打印成元组4 #     print(kwargs) ##打印成字典5 # func2(1,2,2,3,4,5,'alex','老男孩',a='ww',b='qq')

三种参数的混合排序

 1 # def func3(a,b,*args,sex='男'):  ##顺序是 位置参数，*args ,默认参数 2 #     print(a) 3 #     print(b) 4 #     print(sex) 5 #     print(args) 6 # func3(1,2,'老男孩','alex',sex='女') 7  8  9 # def func4(a,b,*args,sex='男',**kwargs): ##位置参数，*args,默认参数,**kwargs10 #     print(a)11 #     print(b)12 #     print(args)13 #     print(sex)14 #     print(kwargs)15 # func4(1,2,3,'alex','aa',sex='女',name='alex')

打散

 1 # def func1(*args,**kwargs): 2 #     print(args) 3 #     print(kwargs) 4 # l1 = [1,2,3,4] 5 # l11 = (1,2,3,4) 6 # l2 = ['alex','wusir',4] 7 # func1(*l1,*l2,*l11)    ##这个是以元组出现的 8 打印出来的结果：  (1, 2, 3, 4, 'alex', 'wusir', 4, 1, 2, 3, 4)10 11 def func1(*args,**kwargs):12     print(args)13     print(kwargs)14 dic1 = {'name1':'alex'}15 dic2 = {'name2':'wusir'}16 func1(**dic1,**dic2)   ##出来的结果是以字典形式存在的打印出来的结果：{'name1': 'alex', 'name2': 'wusir'}

四函数的命名空间和作用域

命名空间一共分为三种：

　　全局命名空间

　　局部命名空间

　　内置命名空间

*内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。

三种命名空间之间的加载与取值顺序：

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

取值顺序：

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

　　在全局调用：全局命名空间->内置命名空间

综上所述，在找寻变量时，从小范围，一层一层到大范围去找寻。

作用域

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

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

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

4.1 命名空间

 1 # name = 'wusir'  ##全局命名空间 2 # age = 12 3 # def func1(): 4 #     name1 = 'wusir'  ##局部命名空间 5 #     age1 = 34 6 #     return name1 7 # print(func1()) 8 # print(name) 9 10 11 # name1 = 'wusir'12 # def func1():13 #     print(name1)14 #     def func2():15 #         print('xxxxx',name1)16 #     func2()17 # func1()

查看命名空间

1 # name1 = 'wusir'2 # def func1():3 #     name2 = 'laonanhai'4 #     print(globals())  ##查看全局变量5 #     print(locals())  ##查看局部变量6 # func1()

4.2

##global 关键字   声明全局空间，如果已经存在则更改

 1 #global  ##声明一个全局变量(限于字符串，数字) 2 # name = 'wusir' 3 # def func1(): 4 #     global name  ##声明一个全局变量 5 #     name = 'alex' 6 #     return 7 # func1() 8 # print(name)  ##打印的结果是alex 9 10 11 12 #对可变数据类型（list，dict，set）可以直接引用不用通过global。13 # li = [1,2,3]14 # dic = {'a':'b'}15 #16 # def change():17 #     li.append('a')18 #     dic['q'] = 'g'19 #     print(dic)20 #     print(li)21 # change()22 # print(li)23 # print(dic)

nonlocal  ##1不能修改全局变量#2在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，# 并且引用的哪层，从那层及以下此变量全部发生改变

 1 # def func2(): 2 #     name1 = 'alex' 3 #     print('+',name1) 4 #     def inner(): 5 #         nonlocal name1 6 #         name1 = 'wusir' 7 #         print('*',name1) 8 #         def inner1(): 9 #             pass10 #     inner()11 #     print('%',name1)12 # func2()

4.3 函数名

 1 # #1 可以互相赋值 2 # def func1(): 3 #     print(666) 4 # f1 = func1 5 # f1() 6  7 #2 函数名可以当成函数的参数 8 # def func1(): 9 #     print(777)10 # def func2(argv):11 #     argv()12 #     print(999)13 # func2(func1)14 15 #可以当成容器类数据类型的参数16 # def func1():17 # #     print(666)18 # # def func2():19 # #     print(777)20 # # def func3():21 # #     print(888)22 # # ll = [func1,func2,func3]23 # # for i in ll:24 # #     i()25 26 27 #函数名可以当成函数的返回值28 # def func1():29 #     print(666)30 # def func2(argv):31 #     print(777)32 #     return argv33 # ret = func2(func1) ##func2执行  并且把func1传给了argv而argv又返回给了ret，所以ret=func134 # ret()

4.4 闭包

闭包 内层函数对外层函数非全局变量的引用，叫做闭包#闭包的好处：如果python 检测到闭包，# 他有一个机制，你的局部作用域不会随着函数的结束而结束

# def wrapper():#     name1 = '老男孩'#     def inner():#         print(name1)#     inner()#     print(inner.__closure__)  ##如果返回是cell是闭包# wrapper()# name1 = '老男孩'# def wrapper():#     def inner():#         print(name1)#     inner()#     print(inner.__closure__)  ##返回none不是闭包# wrapper()name = 'alex'def wrapper(argv):def inner():print(argv)    inner()print(inner.__closure__)  # cellwrapper(name)

五装饰器

装饰器：在不改变原函数即原函数的调用的情况下，
# 为原函数增加一些额外的功能，打印日志，执行时间，登录认证等等。

5.1 最简单的装饰器

 1 # # ##最简单的装饰器 2 import time 3  4 # def func1(): 5 # #     print('hello world') 6 # #     time.sleep(0.3) 7  8 # # def timer(f1):  #f1 = func1 9 # #     def inner():10 # #         start_time = time.time()11 # #         f1()  ##相当于执行func1()12 # #         end_time = time.time()13 # #         print('此函数的执行效率%s' %(end_time - start_time))14 # #     return inner  ##inner返回给了func115 # # func1 = timer(func1)16 # # func1()   ##执行inner()

5.2 @  第二种装饰器

 1 # def timer(f1): 2 #     def inner(): 3 #         start_time = time.time() 4 #         f1() 5 #         end_time = time.time() 6 #         print('此函数的执行效率是%s' % (end_time-start_time)) 7 #     return inner 8 # 9 # @timer  ##func1 = timer(func1） =inner10 # def func1():11 #     print('hello world')12 #     time.sleep(0.3)13 # func1()  ##相当于执行了inner()  ,然后返回到上面 执行inner里面的语句，14 # @timer15 # def func2():16 #     print('你好，世界')17 #     time.sleep(0.4)18 # func2()

5.3 #被装饰的函数带参数

 1 # def timer(f1):  ##f1 = func1 2 #     def inner (*args,**kwargs): 3 #         start_time = time.time() 4 #         f1(*args,**kwargs)  ##func1函数是在这步开始执行的func1(111,222) 5 #         end_time = time.time() 6 #         print('此函数的执行效率是%s' %(end_time-start_time)) 7 #     return inner 8 # @timer #func1 = timer(func1)  ##inner=func1 9 # def func1(a,b):10 #     print(a,b)11 #     print('hello world')12 #     time.sleep(0.9)13 # func1(111,222)  ##inner  把 111和222传给了上面的inner(*args）

5.4 被装饰的函数带返回值

 1 def timer(f1): 2     def inner(*args,**kwargs): 3         start_time = time.time() 4         ret = f1(*args,**kwargs)  ##func1(111,222) 5         end_time = time.time() 6         print('此函数执行效率%s' % (end_time-start_time)) 7         return ret  ##返回给了func1 8     return inner 9 @timer  #func1 = timer(func1)10 def func1(a,b):11     print(a,b)12     print('hello world')13     time.sleep(0.4)14     return 66615 ret2 = func1(111,222)  ##inner(111,222)16 print(ret2)

更多相关文章

随机推荐