闭包函数与装饰器

闭包
闭包函数:1.函数内部定义的函数,成为内部函数
       2.该内部函数包含对外部作用域,而不是对全局作用域名字的引用
  特点:自带作用域
     延迟计算

closure<包含的作用域>

定义闭包函数的基本形式
def 外部函数名():
  内部函数需要的变量
  def 内部函数():
    引用外部变量
  return 内部函数

def f1():
    name=‘good‘
    def f2():
        print(name)
    return f2     
包两层

def aaa():
    name=‘egon‘
    def wrapper():
        money=1000
        def tell_info():
            print(‘egon have money %s‘ %(money))
            print(‘my namn is %s‘ %name)
        return tell_info
    return wrapper

w=aaa()
tell_info=w()
print(tell_info.__closure__[0].cell_contents)
print(tell_info.__closure__[1].cell_contents)
‘‘‘报错NameError: name ‘money‘ is not defined

原因:    函数的作用域关系在函数定义阶段就已经固定,与调用位置无关    无论函数在何处调用,都需要回到定义阶段去找对应的作用域关系    此例:虽然tell_info(‘egon‘)是在foo内调用并且引用money,但仍需要回到定义    tell_info的阶段去找作用域关系,而定义时tell_info引用的money就是全局的money    如果全局不存在则抛出异常NameError

‘‘‘

装饰器:

‘‘‘
一:开放封闭原则,对扩展是开放的,对修改是封闭的
二:装饰器,装饰器本质可以任意可调用对象,被装饰的对象也可以是任意可调用对象
装饰器的功能是:
在不修改被装饰对象源代码以及被装饰对象的调用方式的前提下为其添加新功能
原则:
1.不修改源代码
2.不修改调用方法
目标:添加新功能

‘‘‘

装饰器的语法:
    在被装饰对象的正上方的单独一行,@装饰器名字

#装饰器修订
import time
import random
#装饰器
def timmer(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print(‘run time is %s‘ %(stop_time-start_time))
        return res
    return wrapper
#被装饰函数

@timmer
def index():
    time.sleep(random.randrange(1,5))
    print(‘welecome to index page‘)
@timmer
def home(name):
    time.sleep(random.randrange(1,3))
    print(‘welecome to %s HOME page‘ %name)
    return 123123123123

index()
#加多个装饰器
import time
import random
#装饰器
def timmer(func):
    def wrapper():
        start_time = time.time()
        func()
        stop_time=time.time()
        print(‘run time is %s‘ %(stop_time-start_time))
    return wrapper
def auth(func):
    def deco():
        name=input(‘name: ‘)
        password=input(‘password: ‘)
        if name == ‘egon‘ and password == ‘123‘:
            print(‘login successful‘)
            func() #wrapper()
        else:
            print(‘login err‘)
    return deco

#被装饰函数
@auth #index=auth(wrapper) #index=deco                      #index=auth(wrapper) #index=deco
@timmer #index=timmer(index) #index=wrapper
def index():
    # time.sleep(random.randrange(1,5))
    time.sleep(3)
    print(‘welecome to index page‘)

def home():
    time.sleep(random.randrange(1,3))
    print(‘welecome to HOME page‘)

# index() #deco()
# home()
时间: 2024-11-08 04:23:57

闭包函数与装饰器的相关文章

闭包函数、装饰器以及语法糖

闭包函数: 1.闭包函数必须在函数内部定义 2.闭包函数可以引用外层函数的名字 闭包函数是 函数嵌套.函数对象.名称空间与作用域 结合体. # 直接传参 def func(x): print(x) func(1000) # 通过闭包函数传参 def outer(number): # number = 100 # inner就是闭包函数 def inner(): print(number) return inner func = outer(1000) # ---> inner地址 ---> f

python3命名空间与作用域,闭包函数,装饰器

一.命名空间与作用域 命名空间是名字和对象的映射,就像是字典,key是变量名,value是变量的值 1.命名空间 name='egon' #定义变量 def func(): #定义函数 pass class Foo: #定义类 pass 2.命名空间的分类 (1)内置名称空间: 随着python解释器的启动而产生,包括异常类型.内建函数和特殊方法,可以代码中任意地方调用 print(sum) print(max) print(min) print(max([1,2,3])) import bui

CSIC_716_20191112【闭包函数和装饰器】

闭包函数 什么是闭包函数:闭包函数是函数嵌套.函数对象.名称空间和作用域的集合体. 闭包函数必须在函数内部定义,闭包函数可以引用外层函数的名字. # _*_ coding: gbk _*_ # @Author: Wonder def outer(): def inner(): #代码体 return inner() outer() # 调用闭包函数 装饰器 什么是装饰器:装饰器本身是一个函数,是在不修改其他函数源代码以及调用方式的前提下,给其他函数增加功能的函数. 装饰器遵循开放闭合原则.即对函

Python基础(7)闭包函数、装饰器

一.闭包函数 闭包函数:1.函数内部定义函数,成为内部函数, 2.改内部函数包含对外部作用域,而不是对全局作用域名字的引用 那么该内部函数成为闭包函数 #最简单的无参闭包函数 def func1() name='ares' def func2() print(name) #有参和返回值的闭包函数 def timmer(func): def wrapper(*args,**kwargs): start_time = time.time() res=func(*args,**kwargs) stop

python3 闭包函数,装饰器

闭包函数: 1.定义在函数内部的函数 2.包含对外部作用域而非全局作用域的引用特点: 1.自带作用域 2.延迟计算(取到内存地址,加括号执行) def 外部函数(func): def 内部函数(*args,**kwargs): pass return 内部函数 f=外部函数(func) print(f.__closure__) print(f.__closure__[0].cell_contents) 优点: 1 自带作用域 2 惰性延迟 1.开放封闭原则,对扩展是开房的,对修改是封闭的2.装饰

闭包函数以及装饰器

三种名称空间 内置名称空间:随着python解释器的启动而产生 全局名称空间:文件级别定义的名字会放入该空间 局部名称空间:调用函数时会产生局部名称空间,只在函数调用时临时有效 作用域 全局作用域:内置名称空间,全局名称空间 局部作用域:局部名称空间 名字查找顺序 局部名称空间--->全局名称空间--->内置名称空间 查看全局作用域内的名字:gloabls() 查看局部作用域内的名字:locals() x=1000def func(y):     x=2     print(locals())

8 闭包函数和装饰器

闭包函数定义 #内部函数包含对外部作用域而非全局作用域的引用 #提示:之前我们都是通过参数将外部的值传给函数,闭包提供了另外一种思路,包起来喽,包起呦,包起来哇 def counter(): n=0 def incr(): nonlocal n x=n n+=1 return x return incr c=counter() print(c()) print(c()) print(c()) print(c.__closure__[0].cell_contents) #查看闭包的元素 应用场景

python自动化--函数(闭包函数和装饰器)

闭包函数 闭包函数定义,定义在函数内部的函数,特点是:包含对外部作用域而不是对全局作用域名字的引用.该函数就称之为闭包函数. 简单装饰器实现 1,为什么要使用装饰器,开放封闭原则,对扩展是开放的,对修改是封闭的 2,什么是装饰器 用来装饰他人,装饰器本身可以是任意可调用对象,被装饰器的对象也可以是任意可调用对象 遵循的原则,1,不修改被装饰对象的源代码 2,不修改被装饰器对象的调用方式. 目标是: 在遵循原则1和2的前提,为被装饰器对象添加上新的功能. 原文地址:https://www.cnbl

四 闭包函数、装饰器

一 闭包函数 一.什么是闭包 二.闭包的意义与应用 二 装饰器 一.为何要用装饰器 二.什么是装饰器 三.装饰器的作用 四.装饰器的语法 五.装饰器补充:wraps 一 闭包函数 一.什么是闭包 1 #内部函数包含对外部作用域而非全局作用域的引用 2 3 #提示:之前我们都是通过参数将外部的值传给函数,闭包提供了另外一种思路 4 5 def counter(): 6 n=0 7 def incr(): 8 nonlocal n 9 x=n 10 n+=1 11 return x 12 retur