闭包函数
1.闭:定义在函数内部的函数
2.包:内部函数引用了外部函数作用域的名字
闭包函数：只需要传一次参，下面无论在哪用到，直接拿那个名字就可以了
特点：只给内部传参，需要什么传什么，永远不会变
def outter(): #先定义一个outter函数
x = 111
def inner():
print(x)
return inner
res = outter() # res就是inner函数内存地址
def func():
x = 333
res()
func()
给函数体传值的第一种方式 ：传参，直接传递数据
def index1(username):
print(username)
给函数体传参的第二种方式 闭包（包起来，我给你）
def outter(x,y): # x = 1 # y = 40 def my_max(): if x > y: return x return y return my_max res1 = outter(1,40) # res就是my_max函数的内存地址 print(res1()) print(res1()) print(res1()) res2 = outter(90,200) print(res2()) print(res2()) print(res2()) print(res2()) print(res2()) print(res2())
需要注意的是
def outter (x,y) 与 def outter(): x = 1 y = 10 这两种本质是一样的，都是在outter里面绑定两个名字，产生两个值
import requests
第一个直接给函数传参
url1 = ‘https://www.baidu.com‘
url2 = ‘...‘
def my_get(url):
response = requests.get(url)
if response.status_code == 200:
print(len(response.text))
my_get(url1)
my_get(url1)
my_get(url1)
my_get(‘https://www.baidu.com‘)
my_get(‘https://www.baidu.com‘)
my_get(‘https://www.baidu.com‘)
第二种给函数传参的方式 闭包
def outter(url):
# url = ‘https://www.jd.com‘
def my_get():
response = requests.get(url)
if response.status_code == 200:
print(len(response.text))
return my_get
my_jd = outter(‘https://www.jd.com‘)
my_jd()
my_jd()
my_baidu = outter(‘https://www.baidu.com‘)
my_baidu()
my_baidu()
my_baidu()
my_baidu()
my_baidu()
装饰器:
器:就是一个工具
装饰:给被装饰对象添加新的功能
为什么要用装饰器
开放封闭原则:
开放:对扩展开放
封闭:对修改封闭
装饰器(可调用对象)必须遵循的两个原则:
1.不改变被装饰对象源代码
2.不改变被装饰对象(可调用对象)调用方式
def index():
pass
index()
如何用
"""
import time #统计时间
print(time.time())
#1562812014.731474 时间戳 当前时间距离1970-1-1 00:00:00相差的秒数
#1970-1-1 00:00:00是Unix诞生元年
time.sleep(3) # 让cpu谁三秒 让你的程序暂停三秒
print(‘FBI warning!‘)
简单版本装饰器
1.统计index函数执行的时间
import time
def index():
time.sleep(3)
print(‘开业了‘)
start = time.time()
index()
end = time.time() #cpu运行代码的时候速度是非常快的，代码与代码之间距离的时间特别的短，
print(‘index run time：%s‘%(end-start))
1.统计index函数执行的时间
import time
def index():
time.sleep(3)
print(‘开业了‘)
def outter(func): #func = index函数的内存地址
# func = index
def get_time(func): #func=index函数
start = time.time()
func() #func=index函数内存地址() 直接调用 运行结束时间
end = time.time() #运行结束时间
print(‘index run time:%s‘%(end-start))
return get_time
# res = outter(index) #res变量名 想等于什么就是什么
# res()
index = outter(index) #函数名只要加括号，优先级最高 outter（最开始的index函数内存地址）
#index指向get_time函数的内存地址
index()
升级版装饰器
import time def index(): time.sleep(3) print(‘开业了‘) def login(name): #形参是位置形参 time.sleep(1) print(‘%s is sb‘%name) def outter(func): # func = index def get_time(*args,**kwargs): #func = login函数的内存地址 start = time.time() func(*args,**kwargs) #args = (‘egon‘,) kwargs={} end = time.time() print(‘index run time:%s‘%(end-start)) return get_time # res = outter(index) # res() login = outter(login) #outter(最原始的login函数的内存地址） login是get_time login(‘egon‘) index = outter(index) #最原始的index函数 index()
函数参数的问题
无参函数和有参函数都可以直接调用???
函数可以接收任意数量的参数
装饰器的模板
def outter(func):
def inner(*args,**kwargs):
print(‘执行被装饰函数之前 你可以做的操作‘)
res = func(*args,**kwargs)
print(‘执行被装饰函数之后 你可以做的操作‘)
return res
return inner
装饰器语法糖
@outter #本质是在最前面
@的工作原理：固定语法会将紧挨着它下面的可调用的名字当做它的参数自动传入，直接执行
例如：
index = outter(index)
(自动outter（）)
mport time def outter(func): # func = 最原始的index函数的内存地址 def get_time(*args, **kwargs): start = time.time() res = func(*args, **kwargs) # 最原始的login函数的内存地址() 直接调用 func(‘egon‘) end = time.time() print(‘func run time:%s‘%(end-start)) return res return get_time # login = outter(login) # outter(最原始的login函数的内存地址) # index = outter(index) # home = outter(home) @outter # index = outter(index) outter(最原始的index的函数的内存地址) def index(): time.sleep(3) print(‘澳门最大线上赌场开业啦 性感tank在线发牌!‘) return ‘index‘ # res1 = index() @outter # login = outter(login) def login(name): time.sleep(1) print(‘%s is sb‘%name) return ‘login‘ # res = login(‘egon‘) @outter # home = outter(home) def home(*args,**kwargs): time.sleep(1) return ‘home‘ # login = outter(login) # outter(最原始的login函数的内存地址) # index = outter(index) # home = outter(home) index() login(‘egon‘) home()
注：语法糖在书写的时候应该与被装饰对象紧紧挨着
两者之间不要有空格
原文：https://www.cnblogs.com/pangqian/p/11182946.html