python教程21-闭包的概念、计算代码执行时长、装饰器的使用和详解及高级使用

最新推荐文章于 2022-02-08 13:39:39 发布
最新推荐文章于 2022-02-08 13:39:39 发布
阅读量391 收藏 1
点赞数 1
分类专栏： python基础教程学习手记 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjl_xiaoliu/article/details/109325372
版权

Python教程_小白入门2020/10/28

学习目标
在这里插入图片描述

文章目录

P129 闭包的基本概念
# 　函数的嵌套
# author by zhangjiong

def outer(x):
    m = 100
    print("我是outer函数")

    def inner():
        print("我是inner函数")

    if x > 18:
        inner()

    return 'hello'

# 函数内部定义的变量不能在函数外部使用
# print(m)        # name 'm' is not defined
# inner()         # 函数内部定义的东西不能在外部使用

outer(21)
# 我是outer函数
# 我是inner函数

outer(12)
# 我是outer函数

闭包的相关概念

# 　闭包的基本概念
# @author ：zhangjiong
def outer():
    x = 10  # 在外部函数里定义了一个变量x，是一个局部变量

    def inner():
        # 在内部函数如何修改外部函数的局部变量nonlocal
        # 想在内部函数中修改外部函数的局部变量，而不是在内部函数中额外定义一个变量，就需要用到nonloca
        nonlocal x  # 此时，这里的x不再是新增的变量，而是外部的局部变量
        x = 20
        y = x + 1
        print("inner里的y", y)

    return inner
    

# 如果在一个内部函数里，对外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包
# 比如在此例中，inner（）函数就是闭包，要注意的是，inner（）函数返回的是inner而不是inner()
# 返回的值是函数
outer()()      # inner里的y 21
# 当outer函数里只有一个函数，使用两个括号就可以直接调用
P 130 计算代码的执行时长
# 　计算一段代码的执行时间
# @author ：zhangjiong
# 在代码运行之前，获取下时间
# 在代码执行之后，再获取下时间
# time模块是可以获取当前的时间
# 时间戳是从1970-01-01 00.00.00 UTC到 现在的秒数

import time

start = time.time()  # time模块里的time方法，可以获取当前电脑时间戳
print("start=", start)
# start= 1603849646.9062228
x = 1
for i in range(1, 20001):
    x += i

print(x)

end = time.time()
print("代码执行时间为{}秒".format(end - start))

代码执行时间优化，使用函数调用来计算代码执行时间

# 　计算一段代码的执行时间优化
# @author ：zhangjiong
import time


def cal_time(fn):
    start = time.time()
    fn()
    end = time.time()
    print("代码执行的时间为{}".format(end - start))


def demo():
    x = 0
    for i in range(1, 100000000):
        x += i
    print(x)


# cal_time(demo())        # 注意，不能加括号加括号就会报错
# 写demo()就是代表传入的是demo()计算后的结果
# 写demo就是代表传入的是demo函数
cal_time(demo)


# 4999999950000000
# 代码执行的时间为6.806422472000122


def foo():
    print("hello")
    time.sleep(3)
    print("world")

cal_time(foo)
# hello
# world
# 代码执行的时间为3.0001254081726074
P131 装饰器的基本使用
# 　装饰器的使用
# @author ：zhangjiong
import time


def cal_time(fn):
    print("我是外部函数cal_time，我被调用了")
    print("fn={}".format(fn))
    def inner():
        start = time.time()
        fn()
        end = time.time()
        print("代码耗时", end - start)
    return inner

# 修饰器是在定义的函数上边加@
# 装饰器的执行流程：
# 第一件事：调用cal_time，只要写了@cal_time会直接调用这个函数
# 第二件事：把被装饰的函数传递给fn，此时inner函数是没有被调用的
@cal_time
def demo():
    x = 0
    for i in range(1, 100000000):
        x += i
    print(x)

# 我是外部函数cal_time，我被调用了
# fn=<function demo at 0x000001930B51B5E0>


# 第三件事：当再次调用demo函数时，此时的demo函数不再是上边的demo
# 而是变成了cal_time函数的返回值，也就是inner函数
# 装饰后的demo=<function cal_time.<locals>.inner at 0x0000022CA1C4A700>
print("装饰后的demo={}".format(demo))
# fn指向的是以前的demo,而后边的demo指向的是inner函数
P132 装饰器详解
# 　装饰器详解
# @author ：zhangjiong
import time


def cal_time():
    print("我是外部函数cal_time，我被调用了")
    print("fn={}".format(fn))

    def inner():
        start = time.time()
        s = fn(m)
        end = time.time()
        print("代码耗时", end - start)
        return s

    return inner


@cal_time
def demo0():
    x = 0
    for i in range(1, 100000):
        x += i
    return x

z = demo0()
print(z)

# 我是外部函数cal_time，我被调用了
# fn=<function demo at 0x000001F20CEDB5E0>
# 代码耗时 0.00840306282043457
# 4999950000


# 　装饰器详解
# @author ：zhangjiong
import time


def cal_time(fn):
    print("我是外部函数cal_time，我被调用了")
    print("fn={}".format(fn))

    def inner(m):
        start = time.time()
        s = fn(m)
        end = time.time()
        print("代码耗时", end - start)
        return s

    return inner

@cal_time
def demo1(m):
    x = 0
    for i in range(1, m):
        x += i
    return x


aaa = demo1(1000000)  # demo1不再是曾经的demo1,而是变成了inner()
print(aaa)


# 我是外部函数cal_time，我被调用了
# fn=<function demo1 at 0x000001E0C33CB5E0>
# 代码耗时 0.07489585876464844
# 499999500000

# 　装饰器详解
# @author ：zhangjiong
import time


def cal_time(fn):
    print("我是外部函数cal_time，我被调用了")
    print("fn={}".format(fn))

    def inner(m):
        start = time.time()
        s = fn(m)
        end = time.time()
        # print("代码耗时", end - start)
        return s, end - start

    return inner


@cal_time
def demo1(m):
    x = 0
    for i in range(1, m):
        x += i
    return x


aaa, bbb = demo1(1000000)  # demo1不再是曾经的demo1,而是变成了inner()
print(aaa)
print(bbb)

# 我是外部函数cal_time，我被调用了
# fn=<function demo1 at 0x000001EB7D7CB5E0>
# 499999500000
# 0.07241535186767578

# 　装饰器详解
# @author ：zhangjiong
import time


def cal_time(fn):
    print("我是外部函数cal_time，我被调用了")

    def inner(m, *args, **kwargs):
        start = time.time()
        s = fn(m)
        end = time.time()
        return s, args,kwargs

    return inner


@cal_time
def demo1(m):
    x = 0
    for i in range(1, m):
        x += i
    return x

# 要记住，后边的demo1不再是原来的demo1，所以原来的demo1只有一个参数，而到后边的demo1可以有多个参数，因为他们不是同一个，所以参数可以不一样
# 这也是python修饰器强大的一点
# 原来的demo1是和fn（）是一伙的，后来的demo1是和inner一伙的

aaa = demo1(100, 'hello', l=500)  # demo1不再是曾经的demo1,而是变成了inner()
print("aaa的值是：",aaa)

# 我是外部函数cal_time，我被调用了
# fn=<function demo1 at 0x000001B7A74BB5E0>
# aaa的值是： (4950, ('hello',), {'l': 500})
P133 装饰器的高级使用
# 　装饰器的高级使用
# @author ：zhangjiong

# 产品经理：提需求  /  改需求
# 开放封闭原则，已经写好的代码能不要改就不要改
# 装饰器的高级使用：在不采编原有函数的基础上，为函数增添函数，增加功能

def can_play(fn):
    def inner(x, y,*args,**kwargs):
        if args[0]<=22:
            fn(x, y)
        else:
            print("太晚了，抓紧睡")
    return inner


@can_play
def play_game(name, game):
    print("{}正在玩{}".format(name, game))


play_game("张三", "王者荣耀",18)
play_game("李四", "绝地求生",23)
# 张三在玩王者荣耀
# 太晚了，抓紧睡


# 　装饰器的高级使用
# @author ：zhangjiong

# 产品经理：提需求  /  改需求
# 开放封闭原则，已经写好的代码能不要改就不要改
# 装饰器的高级使用：在不采编原有函数的基础上，为函数增添函数，增加功能

def can_play(fn):
    def inner(x, y, *args, **kwargs):
        if kwargs["clock"] >= 22:
            fn(x, y)
        else:
            print("太晚了，抓紧睡")
    return inner


@can_play
def play_game(name, game):
    print("{}正在玩{}".format(name, game))

play_game("李四", "绝地求生", clock = 23)

# 李四正在玩绝地求生

# 　装饰器的高级使用
# @author ：zhangjiong

# 产品经理：提需求  /  改需求
# 如果超过22点不让玩游戏，如果不告诉时间，默认不让玩游戏
# 开放封闭原则，已经写好的代码能不要改就不要改
# 装饰器的高级使用：在不采编原有函数的基础上，为函数增添函数，增加功能

def can_play(fn):
    def inner(x, y, *args, **kwargs):
        clock = kwargs.get("clock", 23)
        if clock <= 22:
            fn(x, y)
        else:
            print("太晚了，抓紧睡")

    return inner


@can_play
def play_game(name, game):
    print("{}正在玩{}".format(name, game))


play_game("李四", "绝地求生", m="hello", n='world')

# 太晚了，抓紧睡
# 使用kwargs.get("clock", 23)方法来给clock一个默认值
张_囧_囧
关注
专栏目录
python 闭包,装饰器 详解
Damon_duanlei的博客
02-26 235
python 闭包 装饰器 闭包 在python中一切皆对象，这样就使得变量所拥有的属性，函数也同样拥有。这样我们就可以理解在函数内创建一个函数的行为是完全合法的。这种函数被叫做内嵌函数，这种函数只可以在外部函数的作用域内被正常调用，在外部函数的作用域之外调用会报错.而如果内部函数里引用了外部函数里定义的对象（甚至是外层之外，但不是全局变量），那么此时内部函数就被称为闭包函数。闭包函数所引用的外部...
python代码案例详解-Python代码样例列表
weixin_37988176的博客
11-01 4678
扫描左上角二维码，关注公众账号 数字货币量化投资，回复“Python例子”，获取以下600个Python经典例子源码├─algorithm│ Python用户推荐系统曼哈顿算法实现.py│ NFA引擎,Python正则测试工具应用示例.py│ Python datetime计时程序的实现方法.py│ python du熊学斐波那契实现.py│ p...
Java中闭包简单代码示例
08-28
主要介绍了Java中闭包简单代码示例，具有一定借鉴价值,需要的朋友可以参考下
地铁python——闭包：代码执行时间
weixin_45596398的博客
07-03 304
##计算一个代码的执行时间 import time#time 模块 start=time.time() #time 模块里的time方法，可以获取当前的时间和时间戳——1970年01月01日0点UTC到现在的秒数，北京时间是UTC+8 x=0 for i in range(1,500000): x+=i print(x) end=time.time() print('代码运行耗时{}秒'.format(end-start)) #优化： def foo(): print('hello') .
打印代码运行时间的装饰器
Yolo_C的博客
01-21 304
python 打印函数运行时间的装饰器 装饰器代码 import time def func_runtime(func): def wrapper(*args,**kwargs): t1 = time.time() func(*args,**kwargs) t2 = time.time() print('%s costs : ...
【原创】利用python装饰器提升代码运行效率
weixin_30448685的博客
10-25 163
编程有一个原则DRY=Don’t Repeat Yourself，就是说你的代码不要重复来重复去的，这个原则同样可以用于理解动态规划，动态规划除了满足最优子结构，它还存在子问题重叠的性质，我们不能重复地去解决这些子问题，所以我们将子问题的解保存起来，类似缓存机制，之后遇到这个子问题时直接取出子问题的解。 举个简单的例子，斐波那契数列中的元素的计算，很简单，我们写下如下的代码： ...
打印函数运行时间的装饰器
weixin_30538029的博客
05-29 95
1 import time 2 3 def timethis(func): 4 """ 5 测试函数运行花费时间的装饰器 6 """ 7 def wrapper(*args, **kwargs): 8 start = time.time() 9 result = func(*args, **kw...
详解python三大器——迭代器、生成器、装饰器
weixin_45005677的博客
10-19 3383
迭代器 聊迭代器前我们要先清楚迭代的概念：通常来讲从一个对象中依次取出数据，这个过程叫做遍历，这个手段称为迭代(重复执行某一段代码块，并将每一次迭代得到的结果作为下一次迭代的初始值)。 可迭代对象(iterable)：是指该对象可以被用于for…in…循环，例如：集合，列表，元祖，字典，字符串，迭代器等。 在python中如果一个对象实现了 iter 方法，我们就称之为可迭代对象，可以查看set\list\tuple…等源码内部均实现了__iter__方法 如果一个对象未实现__iter__方法，但.
python代码示例-Python代码样例列表
q6q6q的专栏
10-28 4107
├─algorithm│ Python用户推荐系统曼哈顿算法实现.py│ NFA引擎,Python正则测试工具应用示例.py│ Python datetime计时程序的实现方法.py│ python du熊学斐波那契实现.py│ python lambda实现求素数的简短代码.py│ Python localtime()方法计算今天是一...
Python装饰器详解，详细介绍它的应用场景
Python学习Q群696455390
04-10 828
装饰器的应用场景 附加功能 数据的清理或添加: 函数参数类型验证 @require_ints 类似请求前拦截 数据格式转换 将函数返回字典改为 JSON/YAML 类似响应后篡改 为函数提供额外的数据 mock.patch 函数注册 在任务中心注册一个任务 注册一个带信号处理器的函数 不同应用场景下装饰器实现 函数注册表 简单注册表 funcs = [] de...
写一个装饰器，查看函数执行的时间
weixin_43347512的博客
02-01 1075
1.在装饰器中打印执行时间即可 2.递归函数除外 def continue_time(func): import time def wrapper (*args,**kwargs): start_time=time.time() print('开始时间{}'.format(start_time)) result=func(*arg...
(更新时间)2021年3月28日 python基础知识(闭包)
热门推荐
时光隧道
03-28 5万+
一 闭包的概念 1. 闭包的介绍 闭包的定义: 在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。 2. 闭包的构成条件 通过闭包的定义，我们可以得知闭包的形成条件: 在函数嵌套(函数里面再定义函数)的前提下 内部函数使用了外部函数的变量(还包括外部函数的参数) 外部函数返回了内部函数 3. 简单闭包的示例代码 # 定义一个外部函数 def func_out(num1): # 定义一个内部函数 def func_
闭包（含实例代码，通俗易懂）
Delicia_Lani的博客
08-01 3197
闭包实现累加： var count = 0 var fn1 = function () { return function (){ count++ console.log(count) } } var fn2 = fn1() fn2() fn2() fn2() fn2() 闭包实现函数只有一次有效调用： var fn1 = functi...
函数的嵌套以及闭包概念
weixin_50077855的博客
02-08 208
函数的嵌套以及闭包的概念 函数的嵌套 def outer(x): m = 100 print('我是outer函数') def inner(): # inner函数定义在outer函数内部 print('我是inner函数') if x > 18: inner() return 'hello' outer(21) 闭包的概念 如果在一个函数里，对外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包（
学习装饰器，并设计一个装饰器，作用于函数上，打印函数执行时间-python
dkolli的博客
11-02 1851
装饰器 在代码运行期间动态增加功能的方式，称为装饰器Decorator。常见的内置装饰器有： @property @setter 定一个装饰器升级now 装饰器 以一个函数作为参数，并返回一个函数 def log(f): def write_log(*args, **kw): # 使用*是说可变参数，不限制参数的数量 with open('./module2/a.t...
python实例：使用装饰器实现打印函数的执行时间
fyydhsw的专栏
01-25 3415
# -*- coding: utf-8 -*- import time import functools def log(text=''): def metric(fn): @functools.wraps(fn) def wrapper(*args, **kwargs): t_begin = time.time() ...
一个简单的python装饰器实现打印函数被调用时间和次数
阿冲编程
09-28 5121
  直接上代码：  # Author : geoker # Date :2018/9/28 23:32 import time ''' @Author:geoker 一个简单的装饰器实现打印函数被调用时间和次数 ''' def decorate(fun): ''' 打印函数被调用的时间及调用次数 ''' count = 0 def wrapper(*a...
python装饰器计算函数运行时间
亚马逊丛林
12-02 5685
import time from functools import wraps import random def fn_timer(function): @wraps(function) def function_timer(*args, **kwargs): t0 = time.time() result = function(*args,
Python高级函数：闭包与装饰器详解
本章重点围绕Python程序执行原理展开，旨在帮助学习者理解闭包和装饰器这两个高级特性。 **1. Python发展历程与特点及应用领域** - Python起源于1991年，由Guido van Rossum开发，以其简洁明了的语法、动态类型系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值