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

闭包函数:   

    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地址 ---》 func变量名
func()  # func ---> inner地址()

闭包函数的应用

# 方式一: 直接传参
def spider_func(url):
    # 往url地址发送请求,获取响应数据
    response = requests.get(url)  # 必须接受url
    # 状态码: 200
    if response.status_code == 200:
        # 获取当前url地址中所有的文本
        print(len(response.text))
        print(response.text)
url = ‘https://www.cnblogs.com/xiaoyuanqujing/‘
spider_func(url)
——————————————————————————
# 方式二: 通过闭包函数接受url地址,执行爬取函数
def spider_outer(url):
    # url = ‘https://www.cnblogs.com/xiaoyuanqujing/‘
    def spider_inner():
        response = requests.get(url)
        if response.status_code == 200:
            print(len(response.text))
    return spider_inner

# 爬取
spider_blog = spider_outer(‘https://www.cnblogs.com/xiaoyuanqujing/‘)
spider_blog()
# 爬取
spider_baidu = spider_outer(‘https://www.baidu.com/‘)
spider_baidu()

装饰器

定义

装饰的工具

必须要遵循的原则:“开放封闭”

开放:对源函数功能的添加是开放的

封闭:对源函数功能修改是封闭的

装饰器的作用

 # 装饰器推导过程
def move():
    ‘‘‘下载电影的源函数‘‘‘
    print(‘开始下载‘)
    time.sleep(2)
    print(‘下载完成‘)
def fun(index):
    def down():
        star_time = time.time()
        index() # 将被装饰对象move赋值给index执行
        end_time = time.time()
        print(f‘总耗时{end_time - star_time}‘)
    return down
fun(move)()
# 有返回值时
def move():
    ‘‘‘下载电影的源函数‘‘‘
    print(‘开始下载‘)
    time.sleep(2)
    print(‘下载完成‘)
    return ‘明日之巅.mp4‘

def fun(index):
    def down():
        star_time = time.time()
        res = index()  # 将index执行结果赋值给res
        # print(res)
        end_time = time.time()
        print(f‘总耗时{end_time - star_time}‘)
        return res  # 将index返回值返回出来
    # print(down())
    return down
move = fun(move)  # 将调用方式改成被装饰对象
move()
# 源函数有参数时
def move(url):
    ‘‘‘下载电影的源函数‘‘‘
    print(f‘{url}开始下载‘)
    time.sleep(2)
    print(‘下载完成‘)
    return ‘明日之巅.mp4‘

def wrapper(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        res = func(*args, **kwargs)
        end_time = time.time()
        print(f‘总耗时:{end_time - start_time}‘)
        return res
    return inner
move = wrapper(move)
move((‘https://www.cnblogs.com‘))
def wrapper(func):
    def inner(*args, **kwargs):
        # 调用前增加新功能
        res = func(*args, **kwargs)  # 调用被装饰对象,接收返回值
        # 调用后增加的新功能
        return res  # 接收被装饰对象的返回值
    return inner

装饰器语法糖

1、装饰器的语法糖是属于装饰器的

2、用@+装饰器名,在被装饰对象开头

3、在使用装饰器语法糖时,装饰器必须定义在被装饰对象之上

在不修改被装饰对象源代码和调用方式的前提下,增加新功能

必须遵循的原则:

1、不修改被装饰对象的源代码

2、不修改被装饰对象的调用方式

为什么要使用装饰器

解决代码冗余问题,提高代码可扩展性

怎么使用装饰器

编写装饰器通过闭包函数实现

装饰器推导过程

# 增加统计代码运行时间的装饰器
def wrapper(func):
    def inner(*args,**kwargs):
        start_time = time.time()
        res = func(*args,**kwargs)
        end_time = time.time()
        print(end_time-start_time)
        return res
    return inner
# 使用语法糖
@wrapper
def movie():
    print("开始下载")
    time.sleep(2)
    print(‘下载结束‘)
# 不使用语法糖调用增加新功能后的函数
# movie = wrapper(movie)
# movie()
# 使用语法糖后可直接调用
movie()

原文地址:https://www.cnblogs.com/lvguchujiu/p/11845368.html

时间: 2024-10-07 23:41:21

闭包函数、装饰器以及语法糖的相关文章

闭包函数 装饰器

什么是闭包函数 闭:指的是闭包函数数定义在一个函数内部的函数 包:该内部函数包含对外城函数作用域名字的引用 需要结合函数对象的概念将闭包函数返回到全局作用域去使用,从而打破函数层级的限制 为什么要用闭包函数 闭包函数提供了一种为函数体传值的解决方案 如何用闭包函数 # 为函数体传值的方式一:参数 # def func(x,y): # print(x+y) # # func(1,2) 3 # 为函数体传值的方式二:闭包 def outter(x,y): # x=1 # y=2 def func()

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

python_装饰器_语法糖

什么是高阶函数? -- 把函数名当做参数传给另外一个函数,在另外一个函数中通过参数调用执行 #!/usr/bin/python3 __author__ = 'beimenchuixue' __blog__ = 'http://www.cnblogs.com/2bjiujiu/' def func_x(x): return x * 2 def func_y(y): return y * 3 def func_z(x, y): # 等价于 return func_x(5) + func_y(3) r

闭包函数 装饰器 有参装饰器

闭包函数: 1 内部函数 2 包含对外部作用域而非全局作用域的引用闭包函数的特点: 自带作用域  延迟计算 #闭包函数定义 1 def timmer(func): 2 def inner(*args,**kwargs): 3 re = func(*args,**kwargs) 4 return re 5 return inner 6 7 index(): 8 print("hello") 9 10 index = timmer(index) #index == inner 11 ind

Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数

一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(First-Class Object)呢? 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量.可以作为元素添加到集合对象中.可作为参数值传递给其它函数,还可以当做函数的返回值,这些特性就是第一类对象所特有的. 1.函数身为一个对象,拥有对象模型的三个通用属性:id.类型.和值.

【Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数】

一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(First-Class Object)呢? 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量.可以作为元素添加到集合对象中.可作为参数值传递给其它函数,还可以当做函数的返回值,这些特性就是第一类对象所特有的. 1.函数身为一个对象,拥有对象模型的三个通用属性:id.类型.和值.

python学习笔记之装饰器(语法糖)

什么是装饰器 装饰器的知识点铺垫(函数即变量,高阶函数,嵌套函数) 不带参数的装饰器示例 带参数的装饰器示例 作业 一.什么是装饰器 本质上,装饰器就是返回一个函数的高阶函数.装饰器就是一个函数 装饰器的原则: 不修改被装饰对象的源代码 不修改被装饰对象的调用方式 二.装饰器涉及的知识点 函数即变量 高阶函数 嵌套函数 函数即变量: 在python中,一个变量首先被定义,分配内存空间,然后再使用. 以x=1,这个简单的赋值语句为例子.首先在内存中分配一个空间,x指向该内存空间,该内存空间内存入"

Python作用域-->闭包函数-->装饰器

1.作用域: 在python中,作用域分为两种:全局作用域和局部作用域. 全局作用域是定义在文件级别的变量,函数名.而局部作用域,则是定义函数内部. 关于作用域,我要理解两点:a.在全局不能访问到局部定义的变量 b.在局部能够访问到全局定义的变量,但是不能修改全局定义的变量(当然有方法可以修改) 下面我们来看看下面实例: x = 1 def funx(): x = 10 print(x) # 打印出10 funx() print(x) # 打印出1 如果局部没有定义变量x,那么函数内部会从内往外

<04day>_函数嵌套--闭包函数--装饰器--迭代器--生成器

一.函数的嵌套定义 1.python函数支持嵌套 def f1(): #f1函数的定义 def f2(): #f2函数的定义 print('from f2') def f3(): #f3函数的定义 print('from f3') f2() f1() 嵌套函数--运行结果说明: 1首先调用f1()结果,f1函数为空.担保函f2函数,f2函数有内容打印并且有调用,f2函数包含f3函数,但f3函数无调用. 运行结果: 列子:多个数据之间的大小比较. #!/usr/bin/python # -*- c