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) #查看闭包的元素

应用场景

#闭包的意义:返回的函数对象,不仅仅是一个函数对象,在该函数外还包裹了一层作用域,这使得,该函数无论在何处调用,优先使用自己外层包裹的作用域
#应用领域:延迟计算(原来我们是传参,现在我们是包起来)
    from urllib.request import urlopen

    def index(url):
        def get():
            return urlopen(url).read()
        return get

    baidu=index(‘http://www.baidu.com‘)
    print(baidu().decode(‘utf-8‘))

了解闭包函数

‘‘‘
闭包:
1. 定义在内部函数
2. 包含对外部作用域而非全局作用域的引用,
该内部函数就成为闭包函数
‘‘‘
# def f1():
#     x=1
#     def f2():
#         print(x)
#
#     return f2
#
# f=f1()
# print(f)

#闭包应用:惰性计算
from urllib.request import urlopen
#
# res=urlopen(‘http://crm.oldboyedu.com‘).read()
# print(res.decode(‘utf-8‘))

def index(url):
    def get():
        return urlopen(url).read()
    return get

oldboy = index(‘http://crm.oldboyedu.com‘)
# print(oldboy().decode(‘utf-8‘))
print(oldboy.__closure__[0].cell_contents)

def f1():
    # x=1
    y=2
    def f2():
        print(x,y)
    return f2
f=f1()
print(f.__closure__[0].cell_contents)

装饰器是闭包函数的一种

装饰器他人的器具,本身可以是任意可调用对象,被装饰者也可以是任意可调用对象。
强调装饰器的原则:1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式
装饰器的目标:在遵循1和2的前提下,为被装饰对象添加上新功能

了解装饰器

‘‘‘
装饰器:修饰别人的工具,修饰添加功能,工具指的是函数

装饰器本身可以是任何可调用对象,被装饰的对象也可以是任意可调用对象

为什么要用装饰器:
    开放封闭原则:对修改是封闭的,对扩展是开放的
    装饰器就是为了在不修改被装饰对象的源代码以及调用方式的前提下,为期添加新功能

‘‘‘

# import time
#
# 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 wrapper
#
# @timmer
# def index():
#
#     time.sleep(3)
#     print(‘welcome to index‘)
#
# index()

# import time
#
# def timmer(func):
#     def wrapper():
#         start_time=time.time()
#         func() #index()
#         stop_time=time.time()
#         print(‘run time is %s‘ %(stop_time-start_time))
#     return wrapper
#
#
# @timmer #index=timmer(index)
# def index():
#     time.sleep(3)
#     print(‘welcome to index‘)
#
#
# # f=timmer(index)
# # # print(f)
# # f() #wrapper()---->index()
#
# # index=timmer(index) #index==wrapper
#
# index() #wrapper()----->

#流程分析
# import time
# 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
#
# @timmer #index=timmer(index)
# def index():
#     time.sleep(3)
#     print(‘welcome to index‘)
#
#
# index() #wrapper()

# import time
# 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 #index=timmer(index)
# def index():
#     time.sleep(3)
#     print(‘welcome to index‘)
#     return 1
#
# @timmer
# def foo(name):
#     time.sleep(1)
#     print(‘from foo‘)
#
#
# res=index() #wrapper()
# print(res)
#
# res1=foo(‘egon‘)  #res1=wrapper(‘egon‘)
# print(res1)
#
#

# def auth(func):
#     def wrapper(*args,**kwargs):
#         name=input(‘>>: ‘)
#         password=input(‘>>: ‘)
#         if name == ‘egon‘ and password == ‘123‘:
#             print(‘\033[45mlogin successful\033[0m‘)
#             res=func(*args,**kwargs)
#             return res
#         else:
#             print(‘\033[45mlogin err\033[0m‘)
#     return wrapper
#
#
#
# @auth
# def index():
#     print(‘welcome to index page‘)
# @auth
# def home(name):
#     print(‘%s welcome to home page‘ %name)
#
# index()
# home(‘egon‘)
#

# login_user={‘user‘:None,‘status‘:False}
# def auth(func):
#     def wrapper(*args,**kwargs):
#         if login_user[‘user‘] and login_user[‘status‘]:
#             res=func(*args,**kwargs)
#             return res
#         else:
#             name=input(‘>>: ‘)
#             password=input(‘>>: ‘)
#             if name == ‘egon‘ and password == ‘123‘:
#                 login_user[‘user‘]=‘egon‘
#                 login_user[‘status‘]=True
#                 print(‘\033[45mlogin successful\033[0m‘)
#                 res=func(*args,**kwargs)
#                 return res
#             else:
#                 print(‘\033[45mlogin err\033[0m‘)
#     return wrapper
#
# @auth
# def index():
#     print(‘welcome to index page‘)
# @auth
# def home(name):
#     print(‘%s welcome to home page‘ %name)
# index()
# home(‘egon‘)

时间: 2024-11-07 14:24:20

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

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

闭包函数: 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() # 调用闭包函数 装饰器 什么是装饰器:装饰器本身是一个函数,是在不修改其他函数源代码以及调用方式的前提下,给其他函数增加功能的函数. 装饰器遵循开放闭合原则.即对函

闭包函数与装饰器

闭包闭包函数:1.函数内部定义的函数,成为内部函数   2.该内部函数包含对外部作用域,而不是对全局作用域名字的引用 特点:自带作用域 延迟计算 closure<包含的作用域> 定义闭包函数的基本形式def 外部函数名(): 内部函数需要的变量 def 内部函数(): 引用外部变量 return 内部函数 def f1(): name='good' def f2(): print(name) return f2 包两层 def aaa(): name='egon' def wrapper():

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())

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