概念与用法详解,在JS中执会调查计算局计函数执行次数与履行时间

By admin in 4858美高梅 on 2019年4月12日

要是想计算JS中的函数执行次数最多的是哪个,执行时间最长的是哪位,该怎么办呢?

Python装饰器(decorator)定义与用法详解,pythondecorator

正文实例讲述了Python装饰器(decorator)定义与用法。分享给我们供我们参考,具体如下:

什么样是装饰器(decorator)

大致来说,能够把装饰器掌握为八个封装函数的函数,它1般将盛传的函数可能是类做一定的处理,重临修改未来的对象.所以,我们能够在不改动原函数的底蕴上,在履行原函数前后执行其余代码.相比较常用的情形有日记插入,事务处理等.

装饰器

概念与用法详解,在JS中执会调查计算局计函数执行次数与履行时间。最不难易行的函数,再次来到八个数的和

def calc_add(a, b):
 return a + b
calc_add(1, 2)

唯独今后又有新的需要,计算求和操作耗费时间,很简短,求和前得到一下小时,求和后再获得一次,求差即可

import datetime
def calc_add(a, b):
 start_time = datetime.datetime.now()
 result = a + b
 end_tiem = datetime.datetime.now()
 print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return result
calc_add(1, 2)

现在呢,函数calc_diff(a, b),总括a-b,也想总结减法操作的光阴差,很好办,把那段代码复制过去.但是尽管大家明日想编的是一个数学函数库,种种函数都想计算其实践耗时,总不能够一个一个复制代码,想个越来越好的办法.

作者们明白,在Python中函数也是被视为对象的,可以当做参数字传送递,那么只要把计算耗费时间的独自为二个独自的函数calc_spend_time(),然后把须要总括耗费时间的函数例如calc_add的引用传递给它,在calc_spend_time中调用calc_add,那样具有的急需总计耗费时间的函数都并非修改自个儿的代码了.

def calc_spend_time(func, *args, **kargs):
 start_time = datetime.datetime.now()
 result = func(*args, **kargs)
 end_tiem = datetime.datetime.now()
 print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
def calc_add(a, b):
 return a + b
calc_spend_time(calc_add, 1, 1)
# calc_spend_time(calc_add, a=1, b=2)

看起来也没有错,负责总计的函数不用更改,只需调用的时候作为参数字传送给总计时间差的函数.但正是那,调用的时候方式变了,不再是clac(一, 二),而是calc_spend_time(clac_add, 1,
2),万一calc_add大规模被调用,那么还得一处一处找,然后修改回复,依旧很麻烦.若是想不修改代码,就得使clac()calc_spend_time(clac)成效等同,那么能够在calc_spend_time()里把传播的clac包装一下,然后回来包装后的新的函数,再把重返的包裹好的函数赋给clac,那么calc()的作用就和上例calc_spend_time(calc())意义1样.

import datetime
def calc_spend_time(func):
 def new_func(a, b):
  start_time = datetime.datetime.now()
  result = func(a, b)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
def calc_add(a, b):
 return a + b
calc_add = calc_spend_time(calc_add)
calc_add(1, 2)

语法糖

上边的事例就是装饰器的定义,包装函数的函数.事实上上边的例证还足以更简短

import datetime
def calc_spend_time(func):
 def new_func(a, b):
  start_time = datetime.datetime.now()
  result = func(a, b)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
@calc_spend_time
def calc_add(a, b):
 return a + b
calc_add(1, 2)

@calc_spend_time正是语法糖,它的终南山真面目便是:calc_add = calc_spend_time(calc_add)

无参数的函数装饰器

import datetime
def calc_spend_time(func):
 def new_func(*args, **kargs):
  start_time = datetime.datetime.now()
  result = func(*args, **kargs)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
@calc_spend_time
def calc_add(a, b):
 return a + b
@calc_spend_time
def calc_diff(a, b):
 return a - b
calc_add(a=1, b=2)
calc_diff(1, 2)

注:

*args:把持有的参数按出现顺序打包成list
**kargs:把具有的key=value情势的参数打包成3个dict

带参数的函数装饰器

即使大家供给知道函数的部分附加音讯,例如函数笔者,能够经过给装饰器函数增添参数来达成.

import datetime
def calc_spend_time(author):
 def first_deco(func):
  def new_func(*args, **kargs):
   start_time = datetime.datetime.now()
   result = func(*args, **kargs)
   end_tiem = datetime.datetime.now()
   print author, "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
  return new_func
 return first_deco
@calc_spend_time('author_1')
def calc_add(a, b):
 return a + b
@calc_spend_time('author_2')
def calc_diff(a, b):
 return a - b
calc_add(a=1, b=2)
calc_diff(1, 2)

Python内置装饰器

Python内置的装饰器有三个:staticmethodclassmethodproperty

staticmethod:把类中的方法定义为静态方法,使用staticmethod装饰的方法能够使用类可能类的实例对象来调用,不要求传入self

class Human(object):
 """docstring for Human"""
 def __init__(self):
  super(Human, self).__init__()
 @staticmethod
 def say(message):
  if not message:
   message = 'hello'
  print 'I say %s' % message
 def speak(self, message):
  self.say(message)
Human.say(None)
human = Human()
human.speak('hi')

输出:

I say hello
I say hi

classmethod:把类中的方法定义为类措施,使用classmethod装饰的艺术能够使用类只怕类的实例对象来调用,并将该class对象隐式的作为第二个参数字传送入

class Human(object):
 """docstring for Human"""
 def __init__(self):
  super(Human, self).__init__()
  self.message = '111'
 def say(message):
  if not message:
   message = 'hello'
  print 'I say %s' % message
 @classmethod
 def speak(cls, message):
  if not message:
   message = 'hello'
  cls.say(message)
human = Human()
human.speak('hi')

出口同上例

property:把措施成为属性

class Human(object):
 """docstring for Human"""
 def __init__(self, value):
  super(Human, self).__init__()
  self._age = value
 @property
 def age(self):
  return self._age
human = Human(20)
print human.age

更加多关于Python相关内容可查阅本站专题:《Python数据结构与算法教程》、《Python
Socket编制程序技巧总计》、《Python函数使用技术计算》、《Python字符串操作技巧汇总》及《Python入门与进阶经典教程》

但愿本文所述对咱们Python程序设计有着扶助。

本文实例讲述了Python装饰器(decorator)定义与用法。分享给咱们供大家参考,具体如下:
什…

正文实例讲述了Python装饰器(decorator)定义与用法。分享给大家供大家参考,具体如下:

一  什么是 Console
Console 是用以浮现 JS和 DOM 对象音信的单身窗口。并且向 JS 中流入三个console 对象,使用该对象
能够输出音信到 Console 窗口中。另外打开Console后,ALT+F1的话,会弹出快速键一览,也是相比实惠的。

 

哪些是装饰器(decorator)

 
二  什么浏览器帮忙 Console
不少人恐怕都知晓 Chrome 和 FireFox(FireBug)中都扶助Console。而其他浏览器都支
持倒霉。比如 IE八 自带的开发工具纵然援助Console,但功用相比较单调,突显对象的时候都以呈现
[Object,Object],而且无法点击查阅对象里面包车型大巴性质。IE陆、IE7 即使能够设置
Developer Toolbar,但也
不协助 console。Safari、Opera 都支持 Console,但使用上都未曾 FireBug和
Chrome 的造福。
  现在firebug推出了
firebuglite工具,能够让全体浏览器都辅助Console功效,而且使用上和FireBug
大概同一。详见
http://getfirebug.com/firebuglite
 
3  为啥不直接动用 alert 或本人写的 log
应用 alert 不是同壹能够显示音讯,调节和测试程序吗?alert
弹出窗口会中断程序,
倘诺要在循环中显示音信,手点击关闭窗口都累死。而且 alert
展现对象永远呈现为[object ]。
  本人写的 log 就算能够体现1些 object 音信,但许多效应支持都未曾
console 好,看完后边 console
的介绍就掌握了。
 

一. 总括函数执行次数

不难的话,能够把装饰器精晓为二个装进函数的函数,它一般将盛传的函数也许是类做肯定的拍卖,重返修改之后的对象.所以,大家能够在不修改原函数的功底上,在履行原函数前后执行其他代码.比较常用的风貌有日记插入,事务处理等.


2. 总计函数执行时间

装饰器

(部分可比鸡肋的艺术未有列出来,用粗蓝标出来的是常用的格局)

叁. 怎么控制函数的调用次数

最简易的函数,重返七个数的和

四  Console.log(object[, object, …])
Console.log 是最简易输出新闻到 console
窗口的艺术,支持八个参数,该措施会把
那几个参数组合在同步展现,e.g:

四. 如何支配函数的推行时间

def calc_add(a, b):
 return a + b
calc_add(1, 2)

4858美高梅 1

 

可是现在又有新的要求,总括求和操作耗费时间,非常的粗略,求和前获得一下时间,求和后再取得一回,求差即可

log 方法第3个参数协助类似 C
语言 printf 字符串替换格局,Log 辅助下边两种替换格局:

1、总括函数执行次数

健康的艺术能够运用 console.log 输出来肉眼总结有稍许个出口

而是在Chrome中放置了3个 console.count
方法,能够总结一个字符串输出的次数。大家得以应用那几个来直接地总括函数的履行次数

function someFunction() {
    console.count('some 已经执行');
}

function otherFunction() {
    console.count('other 已经执行');
}

someFunction(); // some 已经执行: 1
someFunction(); // some 已经执行: 2
otherFunction(); // other 已经执行: 1

console.count(); // default: 1
console.count(); // default: 2

不带参数则为 default
值,不然将会输出该字符串的实行次数,观测起来照旧挺便宜的

 

理所当然,除了输出次数之外,还想博得1个纯粹的次数值,可以用装饰器将函数包装一下,内部接纳对象存款和储蓄调用次数即可

var getFunCallTimes = (function() {

    // 装饰器,在当前函数执行前先执行另一个函数
    function decoratorBefore(fn, beforeFn) {
        return function() {
            var ret = beforeFn.apply(this, arguments);

            // 在前一个函数中判断,不需要执行当前函数
            if (ret !== false) {
                fn.apply(this, arguments);
            }
        };
    }

    // 执行次数
    var funTimes = {};

    // 给fun添加装饰器,fun执行前将进行计数累加
    return function(fun, funName) {
        // 存储的key值
        funName = funName || fun;

        // 不重复绑定,有则返回
        if (funTimes[funName]) {
            return funTimes[funName];
        }

        // 绑定
        funTimes[funName] = decoratorBefore(fun, function() {
            // 计数累加
            funTimes[funName].callTimes++;

            console.log('count', funTimes[funName].callTimes);
        });

        // 定义函数的值为计数值(初始化)
        funTimes[funName].callTimes = 0;

        return funTimes[funName];
    }
})();

function someFunction() {

}

function otherFunction() {

}


someFunction = getFunCallTimes(someFunction, 'someFunction');

someFunction(); // count 1
someFunction(); // count 2
someFunction(); // count 3
someFunction(); // count 4

console.log(someFunction.callTimes); // 4



otherFunction = getFunCallTimes(otherFunction);
otherFunction(); // count 1
console.log(otherFunction.callTimes); // 1

otherFunction(); // count 2
console.log(otherFunction.callTimes); // 2

 

import datetime
def calc_add(a, b):
 start_time = datetime.datetime.now()
 result = a + b
 end_tiem = datetime.datetime.now()
 print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return result
calc_add(1, 2)
  • %s  代替字符串
  • %d  代替整数
  • %f  代替浮点值
  • %o  代替 Object

2、总结函数执行时间

Chrome中放置了 console.time 和 console.timeEnd 来打点总结时间

console.time();

for (var i = 0; i < 100000; ++i) {

}

console.timeEnd(); // default: 1.77197265625ms

不扩散参数的话,将以default输出飞秒值

小编们得以打包一下,传入函数名称,类似上边的做法,使用装饰器在函数执行前后开始展览处理

var getFunExecTime = (function() {

    // 装饰器,在当前函数执行前先执行另一个函数
    function decoratorBefore(fn, beforeFn) {
        return function() {
            var ret = beforeFn.apply(this, arguments);

            // 在前一个函数中判断,不需要执行当前函数
            if (ret !== false) {
                fn.apply(this, arguments);
            }
        };
    }

    // 装饰器,在当前函数执行后执行另一个函数
    function decoratorAfter(fn, afterFn) {
        return function() {
            fn.apply(this, arguments);
            afterFn.apply(this, arguments);
        };
    }

    // 执行次数
    var funTimes = {};

    // 给fun添加装饰器,fun执行前后计时
    return function(fun, funName) {
        return decoratorAfter(decoratorBefore(fun, function() {
            // 执行前
            console.time(funName);
        }), function() {
            // 执行后
            console.timeEnd(funName);
        });
    }
})();

那正是说调用的时候,就不需求理会如何计时了

function someFunction() {
    for (var i = 0; i < 100000; ++i) {

    }
}


function otherFunction() {
    for (var i = 0; i < 10000000; ++i) {

    }
}

someFunction = getFunExecTime(someFunction, 'someFunction');
someFunction(); // someFunction: 1.616943359375ms

otherFunction = getFunExecTime(otherFunction, 'otherFunction');
otherFunction(); // otherFunction: 18.157958984375ms

 

Chrome的Console API终究不是正规的,除了行使它之外,还能采取日期插件
Date 中的 getTime now 相关措施

不过使用Date对象来总括耗时并半间不界,推荐使用正式的 performance.now

var start = performance.now();

console.time();

for (var i = 0; i < 10000000; ++i) {

}

var end = performance.now();

console.timeEnd(); // default: 23.598876953125ms

console.log(end - start); // 23.600000015459955

能够观看,它们是离开非常小的

运用类似的形式,将它包裹起来以便有利于调用

var getFunExecTime = (function() {

    // 装饰器,在当前函数执行前先执行另一个函数
    function decoratorBefore(fn, beforeFn) {
        return function() {
            var ret = beforeFn.apply(this, arguments);

            // 在前一个函数中判断,不需要执行当前函数
            if (ret !== false) {
                fn.apply(this, arguments);
            }
        };
    }

    // 装饰器,在当前函数执行后执行另一个函数
    function decoratorAfter(fn, afterFn) {
        return function() {
            fn.apply(this, arguments);
            afterFn.apply(this, arguments);
        };
    }

    // 执行次数
    var funTimes = {};

    // 给fun添加装饰器,fun执行前后计时
    return function(fun, funName) {
        funName = funName || fun;

        if (funTimes[funName]) {
            return funTimes[funName];
        }

        // 绑定
        funTimes[funName] = decoratorAfter(decoratorBefore(fun, function() {
            // 执行前
            funTimes[funName].timestampStart = performance.now();
        }), function() {
            // 执行后
            funTimes[funName].timestampEnd = performance.now();

            // 将执行耗时存入
            funTimes[funName].valueOf = function() {
                return this.timestampEnd - this.timestampStart;
            };
        });

        return funTimes[funName];
    }
})();

function someFunction() {
    for (var i = 0; i < 100000; ++i) {

    }
}


function otherFunction() {
    for (var i = 0; i < 10000000; ++i) {

    }
}

// 包装
someFunction = getFunExecTime(someFunction);
// 执行
someFunction();
// 获取耗时,可直接使用函数的 valueOf
console.log(+someFunction); // 2.0999999847263098

otherFunction = getFunExecTime(otherFunction, 'otherFunction');
otherFunction(); 
console.log(+otherFunction); // 21.00000000745058

 

现在呢,函数calc_diff(a, b),总计a-b,也想计算减法操作的时光差,很好办,把那段代码复制过去.不过只要我们后天想编的是一个数学函数库,各类函数都想计算其推行耗费时间,总不能够叁个2个复制代码,想个更加好的办法.

e.g:

三、如何控制函数的调用次数

也足以通过闭包来控制函数的实践次数

function someFunction() {
    console.log(1);
}

function otherFunction() {
    console.log(2);
}


function setFunCallMaxTimes(fun, times, nextFun) {
    return function() {
        if (times-- > 0) {
            // 执行函数
            return fun.apply(this, arguments);
        } else if (nextFun && typeof nextFun === 'function') {
            // 执行下一个函数
            return nextFun.apply(this, arguments);
        }
    };
}

var fun = setFunCallMaxTimes(someFunction, 3, otherFunction);

fun(); // 1
fun(); // 1
fun(); // 1
fun(); // 2
fun(); // 2

 

大家清楚,在Python中等高校函授数也是被视为对象的,能够当作参数字传送递,那么一旦把总结耗费时间的独门为3个独自的函数calc_spend_time(),然后把须求总括耗费时间的函数例如calc_add的引用传递给它,在calc_spend_time中调用calc_add,那样全体的必要总括耗费时间的函数都无须修改本身的代码了.

4858美高梅 2

4、如何决定函数的施行时间

因为JS是单线程的,控制函数的进行时间相对来说挺麻烦

透过 async await yield 等异步本性,可能还是能够办到的

在React 16中的 Fiber
机制,在某种意义上是能操纵函数的进行时机,得空再去看看它是怎么落到实处的啊

def calc_spend_time(func, *args, **kargs):
 start_time = datetime.datetime.now()
 result = func(*args, **kargs)
 end_tiem = datetime.datetime.now()
 print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
def calc_add(a, b):
 return a + b
calc_spend_time(calc_add, 1, 1)
# calc_spend_time(calc_add, a=1, b=2)

 

看起来也情有可原,负责总计的函数不用更改,只需调用的时候作为参数字传送给总括时间差的函数.但正是那,调用的时候情势变了,不再是clac(一, 二),而是calc_spend_time(clac_add, 1,
2),万一calc_add大规模被调用,那么还得1处1处找,然后修改回复,照旧很麻烦.假使想不改动代码,就得使clac()calc_spend_time(clac)功用一样,那么能够在calc_spend_time()里把传播的clac包装一下,然后回到包装后的新的函数,再把再次来到的包裹好的函数赋给clac,那么calc()的效果就和上例calc_spend_time(calc())效率1样.

五  console.debug,info,warn,error
那 四 种艺术与 log 方法应用同样,只是显示的图标和文字颜色不一样.

import datetime
def calc_spend_time(func):
 def new_func(a, b):
  start_time = datetime.datetime.now()
  result = func(a, b)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
def calc_add(a, b):
 return a + b
calc_add = calc_spend_time(calc_add)
calc_add(1, 2)

 

语法糖

六  console.assert(expression[, object, …]) 

上边的例证就是装饰器的概念,包装函数的函数.事实上上边的事例仍是能够更简明

assert 方法类似于单元测试中的断言,当 expression 表明式为 false
的时候,输出后边的新闻,e.g:
 注:assert 方法在 firebuglite 不支持,Chrome 和 FireBug 支持
 
七  console.clear()
该格局清空 console 中的全数音讯 (Chrome中不扶助)
 

import datetime
def calc_spend_time(func):
 def new_func(a, b):
  start_time = datetime.datetime.now()
  result = func(a, b)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
@calc_spend_time
def calc_add(a, b):
 return a + b
calc_add(1, 2)

八  console.dirxml(node) 

@calc_spend_time就是语法糖,它的本色就是:calc_add = calc_spend_time(calc_add)

把 html 成分的html 代码打字与印刷出来,等同于log.
 
  console.trace()
trace 方法可以查看当前函数的调用堆栈音信,即日前函数是怎么样调用的,e.g:

无参数的函数装饰器

4858美高梅 3

import datetime
def calc_spend_time(func):
 def new_func(*args, **kargs):
  start_time = datetime.datetime.now()
  result = func(*args, **kargs)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
@calc_spend_time
def calc_add(a, b):
 return a + b
@calc_spend_time
def calc_diff(a, b):
 return a - b
calc_add(a=1, b=2)
calc_diff(1, 2)

 

注:

十  console.group(object[, object, …]4858美高梅,), groupCollapsed, groupEnd
那 三 个函数用于把 log 等输出的新闻进行分组,方便阅读查看。

*args:把具有的参数按出现顺序打包成list
**kargs:把持有的key=value情势的参数打包成1个dict

groupCollapsed 方法与 group 方法同样,只是展现的分组暗许是折叠的.
 
 十一
 console.time(name)/console.timeEnd(name)
我们日常索要测试 js 函数的实践时间,大概我们协调写代码在第二 条语句和
最后 一条语句取当前岁月相减。那组函数实际就达成了那样的职能,time(name)根据name 制造 1 个新
的计时器。timeEnd(name)甘休给定name 的计时器,并出示时间。

带参数的函数装饰器

 

比方大家须求掌握函数的一对优良音讯,例如函数小编,能够通过给装饰器函数扩张参数来达成.

十二  console.profile(name)/console.profileEnd() 

import datetime
def calc_spend_time(author):
 def first_deco(func):
  def new_func(*args, **kargs):
   start_time = datetime.datetime.now()
   result = func(*args, **kargs)
   end_tiem = datetime.datetime.now()
   print author, "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
  return new_func
 return first_deco
@calc_spend_time('author_1')
def calc_add(a, b):
 return a + b
@calc_spend_time('author_2')
def calc_diff(a, b):
 return a - b
calc_add(a=1, b=2)
calc_diff(1, 2)

那组方法用于打开浏览器的分析器,用于分析那组函数之间的 js 执市价况,
注:firebuglite 不协助 profile 功能,Chrome 帮助profile,但分析的始末不详。

Python内置装饰器

十三 
console.count([title])
count 方法用于总结当前代码被实践过些微次,title
参数能够在次数前边输出额外的标题以帮助阅读。e.g:
 

Python内置的装饰器有三个:staticmethodclassmethodproperty

4858美高梅 4

staticmethod:把类中的方法定义为静态方法,使用staticmethod装饰的措施能够使用类恐怕类的实例对象来调用,不须求传入self

 

class Human(object):
 """docstring for Human"""
 def __init__(self):
  super(Human, self).__init__()
 @staticmethod
 def say(message):
  if not message:
   message = 'hello'
  print 'I say %s' % message
 def speak(self, message):
  self.say(message)
Human.say(None)
human = Human()
human.speak('hi')

十四 console.table(data)
table 方法把data
对象用表格的法子显示出来,这在显示数组恐怕格式壹样的JSON
对象的时候尤其实用。
注:table 只支持 FireBug,而且是在 firebug一.6+版本后才有。

输出:


I say hello
I say hi

 

classmethod:把类中的方法定义为类措施,使用classmethod装饰的办法能够使用类恐怕类的实例对象来调用,并将该class对象隐式的当作第2个参数字传送入

再有局地小的家伙,例如能够经过 %c 控制输出文字的体裁

class Human(object):
 """docstring for Human"""
 def __init__(self):
  super(Human, self).__init__()
  self.message = '111'
 def say(message):
  if not message:
   message = 'hello'
  print 'I say %s' % message
 @classmethod
 def speak(cls, message):
  if not message:
   message = 'hello'
  cls.say(message)
human = Human()
human.speak('hi')

4858美高梅 5

出口同上例

总结:
  Console 是帮忙大家学习和调节和测试 JS的 1个要命好工具,若是您在此以前没用过,哪以往就起来用它呢。

property:把措施成为属性

  你会发觉它能帮你省很多开支时间的。

class Human(object):
 """docstring for Human"""
 def __init__(self, value):
  super(Human, self).__init__()
  self._age = value
 @property
 def age(self):
  return self._age
human = Human(20)
print human.age

越来越多关于Python相关内容可查看本站专题:《Python数据结构与算法教程》、《Python
Socket编制程序技巧总计》、《Python函数使用技巧计算》、《Python字符串操作技巧汇总》及《Python入门与进阶经典教程》

梦想本文所述对大家Python程序设计有着扶助。

你恐怕感兴趣的篇章:

  • python如何定义带参数的装饰器
  • 介绍Python的@property装饰器的用法
  • Python中的各个装饰器详解
  • 深深精通python中的闭包和装饰器
  • Python装饰器的函数式编制程序详解
  • 详解Python中的装饰器、闭包和functools的学科
  • 巧用Python装饰器
    免去调用父类构造函数的辛劳
  • Python中的多重装饰器
  • python重试装饰器示例
  • 实例讲解Python编制程序中@property装饰器的用法
  • Python自定义装饰器原理与用法实例分析

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有