python全栈开发从入门到放弃之装饰器函数

1、函数名可以当作函数的参数

 1 import time
 2 def timmer(func):
 3     #函数名可以当做函数的参数
 4     def inner():
 5         start = time.time()
 6         func()
 7         end = time.time()
 8         print(end - start)
 9     return inner
10
11 def hahaha():
12     time.sleep(0.1)
13     print(‘aaaa‘)
14
15 hahaha()
16
17 输出结果
18 aaaa

2、假如我们不能修改这个函数的调用方式,也不能修改原代码,该怎么做到呢

 1 import time
 2 def timmer(func):
 3     #函数名可以当做函数的参数
 4     def inner():
 5         start = time.time()
 6         func()
 7         end = time.time()
 8         print(end - start)
 9     return inner
10
11 def hahaha():
12     time.sleep(0.1)
13     print(‘aaaa‘)
14
15 hahaha = timmer(hahaha)       #timmer函数的地址给了hahaha  然后在进行调用
16 hahaha()
17
18 aaaa
19 0.10033607482910156

# hahaha = timmer(hahaha) #timmer函数的地址给了hahaha
# hahaha() #实际上执行的是timmer

3、函数传参

 1 def timmer(func):  #---> hahaha
 2     def inner(*args,**kwargs):         #动态参数接收从kkk传来的1,2并进行压缩成元组
 3         #args == (1,2)  kwargs == {}
 4         #*args == 1,2   **kwargs == a =1,b = 2
 5         func(*args,**kwargs)  # ---》kkk   #func把值传给kkk并还原,实际上就是解压之前动态参数接收的压缩的值,返回给kkk函数
 6     return inner
 7
 8
 9 def kkk(a,b):
10     print(a)
11
12 kkk = timmer(kkk)     #timmer函数里的func是kkk函数,然后返回inner函数给kkk
13 kkk(1,2)      #kkk函数调用并传参给inner(动态参数*args),
14
15 1

参数
#实参:调用函数的时候传入的参数
#形参
#位置参数:必须传值

1 def aaa(a,b):
2 print(a,b)
3 aaa(1,2)

#默认参数:可以不传

1 def bbb(x=10):      #默认参数 没上传参数的话用默认的参数,上传的话会用上传的参数。
2 print(x)
3 bbb() #x = 10
4 bbb(20) #x = 20

#动态参数

1 def ccc(*args):#1,2,3,4,5     #*args  会将ccc上传的参数以元组的方式存放
2 print(args)
3
4 ccc(1,2,3,4,5)#按位置传参数

解压传参

1 def ccc(*args):#1,2,3,4,5
2     print(args)
3
4 #ccc(1,2,3,4,5)#按位置传参数
5
6 t = (1,2,3,4,5)
7 ccc(t) # ((1, 2, 3, 4, 5),)
8 ccc(*t)  #(1, 2, 3, 4, 5)   #解压

按关键字传参

1 def ddd(**kwargs):   #kwargs接收传参然后以字典的方式存放
2     print(kwargs)
3
4 ddd(k = ‘a‘,j = ‘b‘)#按关键字传参数

打散赋值

 1 def ccc(*args):
 2     print(‘ccc:‘,args)  #(1,2,3,4,5)
 3     def inner(a,b,c,d,e):
 4         print(‘inner‘,a,b,c,d,e)
 5     inner(*args)  #*(1,2,3,4,5)  打散
 6
 7 def inner(a,b,c,d,e):     #接收解压的参数然后一一赋值
 8     print(‘inner‘,a,b,c,d,e)
 9 ccc(1,2,3,4,5)
10 inner(1,2,3,4,5)

4、语法糖

 1 def timmer(func):  #---> jjj
 2     def inner(*args,**kwargs):
 3         ret = func(*args,**kwargs)  # --->ret = jjj()
 4         print(ret)
 5         return ret
 6     return inner
 7
 8 @timmer  #jjj = timmer(jjj)  语法糖
 9 def jjj():
10     return 123
11
12
13 jjj()     #ret = jjj()
14
15
16 输出结果
17 123

5、装饰器函数

#装饰器的本质 :闭包函数
#功能:就是在不改变原函数调用方式的情况下,在这个函数前后加上扩展功能
def timmer(func):
def inner(*args,**kwargs):
‘‘‘添加函数调用之前的扩展代码‘‘‘
ret = func(*args,**kwargs)
‘‘‘添加函数调用之后的扩展代码‘‘‘
return ret
return inner
#设计模式 原则 开放封闭原则
#对扩展是开放的
#对修改是封闭的

6、装饰器装饰两个函数

 1 def wrapper(func):#装饰
 2     def inner(*args,**kwargs):
 3
 4         ret = func(*args,**kwargs)
 5
 6         return ret
 7     return inner
 8
 9 @wrapper        #aaa = wrapper(aaa)
10 def aaa():
11     print(‘asghksdlhf‘)
12
13 @wrapper        #bbb = wrapper(bbb)
14 def bbb():
15     print(‘asghksdlhf‘)
16
17
18 aaa()
19 bbb()
20
21
22 #输出结果:
23 #asghksdlhf
24 #asghksdlhf

7、

时间: 07-27

python全栈开发从入门到放弃之装饰器函数的相关文章

python全栈开发从入门到放弃之模块和包

一 模块 1 什么是模块? 常见的场景:一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀. 但其实import加载的模块分为四个通用类别: 1 使用python编写的代码(.py文件) 2 已被编译为共享库或DLL的C或C++扩展 3 包好一组模块的包 4 使用C编写并链接到python解释器的内置模块 2 为何要使用模块? 如果你退出python解释器然后重新进入,那么你之前定义的函数或者变量都将丢失,因此我们通常将程序写到文件中以便永久保存下来,需要时就

python全栈开发从入门到放弃之常用模块和正则

什么是模块? 常见的场景:一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀. 但其实import加载的模块分为四个通用类别: 1 使用python编写的代码(.py文件) 2 已被编译为共享库或DLL的C或C++扩展 3 包好一组模块的包 4 使用C编写并链接到python解释器的内置模块 为何要使用模块? 如果你退出python解释器然后重新进入,那么你之前定义的函数或者变量都将丢失,因此我们通常将程序写到文件中以便永久保存下来,需要时就通过python

python全栈开发从入门到放弃之网络基础

一.操作系统基础 操作系统:(Operating System,简称OS)是管理和控制计算机硬件与软件资源的计算机程序,是直接运行在"裸机"上的最基本的系统软件,任何其他软件都必须在操作系统的支持下才能运行. 注:计算机(硬件)->os->应用软件 回到顶部 二.网络通信原理 回到顶部 2.1 互联网的本质就是一系列的网络协议 一台硬设有了操作系统,然后装上软件你就可以正常使用了,然而你也只能自己使用 像这样,每个人都拥有一台自己的机器,然而彼此孤立 如何能大家一起玩耍 然

python全栈开发从入门到放弃之socket网络编程基础

网络编程基础 一 客户端/服务器架构 1.硬件C/S架构(打印机) 2.软件C/S架构 互联网中处处是C/S架构 如黄色网站是服务端,你的浏览器是客户端(B/S架构也是C/S架构的一种) 腾讯作为服务端为你提供视频,你得下个腾讯视频客户端才能看它的视频) C/S架构与socket的关系: 我们学习socket就是为了完成C/S架构的开发 为何学习socket一定要先学习互联网协议: 1.首先:本节课程的目标就是教会你如何基于socket编程,来开发一款自己的C/S架构软件 2.其次:C/S架构的

python全栈开发从入门到放弃之内置函数

1.locals.globals 1 def func(): 2 x = 1 3 y = 2 4 print(locals()) #打印局部作用域中的名字 5 print(globals()) #打印全局作用域中的名字 2. 1 print(123) 2 "print(456)" #字符串 3 eval("print(456)") #字符串->转换成python代码去执行 4 5 输出结果 6 123 7 456 8 1 exec("print(78

python全栈开发从入门到放弃之字符串的应用

1.strip strip 脱去(...的)衣服 去掉左右两边的空白msg=' hellprint(msg) 1 1 print(msg.strip()) #去掉左右两边的空白 2 2 3 3 hello 4 4 hello 5 5 6 6 msg='********hello************' 7 7 print(msg) 8 8 print(msg.strip('*')) #指定的去掉左右两边的* 9 9 ********hello************ 10 10 11 11 h

python全栈开发从入门到放弃之函数基础

1.为什么要用函数#1.避免代码重用#2.提高代码的可读性 2.函数的定义def 函数名(参数1,参数2):    '''函数注释'''    print("函数体")    return "返回值" 3.函数调用返回值 = 函数名(参数1,参数2) 4.函数定义--返回值#关键字:return#return的作用:    #1.结束函数的执行    #2.返回要返回的值#返回值的两种情况:    #返回值为None    #返回值不为None        #1.

python全栈开发从入门到放弃之socket并发编程之IO模型

一 IO模型介绍 同步(synchronous) IO和异步(asynchronous) IO,阻塞(blocking) IO和非阻塞(non-blocking)IO分别是什么,到底有什么区别?这个问题其实不同的人给出的答案都可能不同,比如wiki,就认为asynchronous IO和non-blocking IO是一个东西.这其实是因为不同的人的知识背景不同,并且在讨论这个问题的时候上下文(context)也不相同.所以,为了更好的回答这个问题,我先限定一下本文的上下文. Stevens在文

python全栈开发从入门到放弃之列表的内置方法

1.列表切片 1 l=['a','b','c','d','e','f'] 2 print(l[1:5]) # 根据索引号来切片,但顾头不顾尾 3 ['b', 'c', 'd', 'e'] 4 print(l[1:5:2]) # 根据索引号来切片,顾头不顾尾,后面加个haxi值每两个空一个 5 ['b', 'd'] 6 print(l[2:5] ) 7 ['c', 'd', 'e'] 8 print(l[-1]) #-1代表从后往前取 -1代表最后一个 9 f 10 11 12 l=['a','b