Python闭包装饰器使用方法汇总

闭包内容:

匿名函数:能够完成简单的功能,传递这个函数的引用,只有功能

普通函数:能够完成复杂的功能,传递这个函数的引用,只有功能

闭包:能够完成较为复杂的功能,传递这个闭包中的函数以及数据,因此传递是功能+数据

对象:能够完成最复杂的功能,传递很多数据+很多功能,因此传递的是数据+功能

———————————————————

对全局函数进行修改:在函数当中加global,在闭包中外边中的变量加nonlocal

闭包定义:有两个函数嵌套使用,里面的函数可以使用外面函数所传输的参数,最后可传递的是里面函数的结构与数据(个人理解)。

最后闭包可以在python中引申出装饰器 ———————————————————

def closure():
  # 在函数内部再定义一个函数,
  # 并且这个函数用到了外边函数的变量,那么将这个函数以及用到的一些变量称之为闭包
  def closure_in(x):
    print('---------我是打不死的%s--------' %x)
  return closure_in
​
x = closure()
x('小强')
​
print('*'*20)
# -----加餐---------
def closure_1(a,b,c):
  def closure_on(x):
    print('-----%s加餐-------' %b)
    print(a*x + c)
  return closure_on
​
demo = closure_1(2,'小强',3) #传closure_1函数
demo(4) #传clsure_on函数
​
#注:函数不加括号,调用的是函数本身【function】;函数加括号,调用的是函数的return结果。

装饰器内容:

代码要遵守‘开放封闭'原则;对已经写好的函数遵守封闭,对功能扩展遵守开放;

# 装饰器的作用:为了对原来的代码上进行扩展
def decoration(func):
  def call_func():
    print('-------正在装饰 -------' )
    func()
  return call_func
​
#@decoration   #--->demo_new = decoration(demo)
def demo():
  print('demo----')
​
demo_new = decoration(demo)
demo_new()

使用装饰器来测试一个函数的运行时:

import time
def set_func(func):
  def call_func():
    start_time = time.time()
    func()
    stop_func = time.time()
    print(‘alltimes is %f' %(stop_func-start_fun))
  return call_func
@set_func
def test1():
  print(‘——-test1———')
test1()
​
#等价于:
@set_func==test1 = set_func(test1)

1. 没有参数,没有返回值的函数进行装饰:

def set_func(func):
  def call_func():
    print(‘———test2——-')
    print(‘———-test3——')
    func()
  return call_func

@set_func
def test1():
  print(‘——test1——-  ')

2. 对有参数无返回值的函数进行装饰:

def set_func(func):
  def call_func(a): #变
    print(‘———test2——-')
    print(‘———-test3——')
    func(a) #变
  return call_func

@set_func
def test1(num):
  print(‘——test1——- %d  ' %num)
​
test1(100) —->call_func(100)
test1(200)——>call_func(200)

复现装饰器原理:

————————————————————————-

只要遇到@函数 装饰器(这句话),在程序中就已经执行了!!

3. 不定长参数的函数装饰:

def set_func(func):
  def call_func(*args,**kwargs): #变
    print(‘———test2——-')
    print(‘———-test3——')
    func(*args,**kwargs) #(拆包)将元祖拆开,每个进行传输;
    #func(args,kwargs)—>不行,相当于传递了两个参数:一个元祖,一个字典。
  return call_func
@set_func
def test1(num,*args,**kwargs):
  print(‘——test1——- %d  ' %num)
  print(‘——test1——-  ' , args)
  print(‘——test1——- ' ,kwargs )
test1(100)
test1(100,200)
test1(100,200,300,mm=100)

注意:*args保存不定长参数,以元祖保存,**kwargs保存字典形式(mm=...)

4.对应的返回值参数进行装饰、通用装饰器:

#通用装饰器
def set_func(func):
  print(“开始进行装饰———-”)
  def call_func(*args,**kwargs): #变
    print(‘———test2——-')
    print(‘———-test3——')
    return func(*args,**kwargs) #(拆包)将元祖拆开,每个进行传输;如果没有return ret返回none。
    #func(args,kwargs)—>不行,相当于传递了两个参数:一个元祖,一个字典。
  return call_func

@set_func
def test1(num,*args,**kwargs):
  print(‘——test1——- %d  ' %num)
  print(‘——test1——-  ' , args)
  print(‘——test1——- ' ,kwargs )
  return ‘ok'  #—-返回给上面的func(),然后return func—ret
ret = test1(100)

5. 多个装饰器对同一个函数进行装饰:

def add_qx(func):
  print(“——开始进行装饰权限1———-”)
  def call_func(*args,**kwargs): #变
    print(‘这是权限验证1')
    return func(*args,**kwargs)
  return call_func

​
def add_xx(func):
  print(“——开始进行装饰xx功能———-”)
  def call_func(*args,**kwargs): #变
    print(‘这是xx权限验证')
    return func(*args,**kwargs)
  return call_func
@add_qx
@add_xx
def test1():
  print(‘——test1——-')
test1()

首先执行第一个,但是第一个装饰器下面不是函数(装饰器原则:下面必须是函数,否则不执行),所以第一个函数先等待,等第二个装饰器执行后形成函数在交给第一个装饰器;所以运行结果是:

开始进行装饰xx的功能,

开始进行装饰权限1,

这是权限验证1,

这是xx权限验证,

——-test1——-,

——————装饰器练习—————- 输出格式:<td><h1>haha</h1></td>

def set_func_1(func):
  def call_func():
    return ‘<h1>' + func() + '</h1>'
  return call_func

​
def set_func_2(func):
  def call_func():
    return ‘<td>' + func() + '</td>'
  return call_func

@set_func_1()
@set_func_2()
def get_str():
  return ‘haha'

print(get_str())
最后执行的效果: <h1><td>haha</td></h1>

6. 用类对函数进行装饰(了解):

class Test(object):
  def __init__(self,func):
    self.func = fun

  def __call__(self):
    print(‘这里是装饰器的功能。。。。')
    return self.func()

@Test
def get_str():
  return ‘haha'

print(get_str())

以上就是装饰器与闭包的全部内容

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • 详解 Python中LEGB和闭包及装饰器

    详解 Python中LEGB和闭包及装饰器 LEGB L>E>G?B L:local函数内部作用域 E:enclosing函数内部与内嵌函数之间 G:global全局作用域 B:build-in内置作用域 python 闭包 1.Closure:内部函数中对enclosing作用域变量的引用 2.函数实质与属性 函数是一个对象 函数执行完成后内部变量回收 函数属性 函数返回值 passline = 60 def func(val): if val >= passline: print (

  • 深入理解python中的闭包和装饰器

    python中的闭包从表现形式上定义(解释)为:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure). 以下说明主要针对 python2.7,其他版本可能存在差异. 也许直接看定义并不太能明白,下面我们先来看一下什么叫做内部函数: def wai_hanshu(canshu_1): def nei_hanshu(canshu_2): # 我在函数内部有定义了一个函数 return canshu_1*canshu_2 return

  • python中函数总结之装饰器闭包详解

    1.前言 函数也是一个对象,从而可以增加属性,使用句点来表示属性. 如果内部函数的定义包含了在外部函数中定义的对象的引用(外部对象可以是在外部函数之外),那么内部函数被称之为闭包. 2.装饰器 装饰器就是包装原来的函数,从而在不需要修改原来代码的基础之上,可以做更多的事情. 装饰器语法如下: @deco2 @deco1 def func(arg1,arg2...): pass 这个表示了有两个装饰器的函数,那么表示的含义为:func = deco2(deco1(func)) 无参装饰器语法如下:

  • Python的几个高级语法概念浅析(lambda表达式闭包装饰器)

    1. 匿名函数 匿名函数(anonymous function)是指未与任何标识符绑定的函数,多用在functional programming languages领域,典型应用场合: 1) 作为参数传给高阶函数(higher-order function ),如python中的built-in函数filter/map/reduce都是典型的高阶函数 2) 作为高阶函数的返回值(虽然此处的"值"实际上是个函数对象) 与命名函数(named function)相比,若函数只被调用1次或有

  • 详解Python中的装饰器、闭包和functools的教程

    装饰器(Decorators) 装饰器是这样一种设计模式:如果一个类希望添加其他类的一些功能,而不希望通过继承或是直接修改源代码实现,那么可以使用装饰器模式.简单来说Python中的装饰器就是指某些函数或其他可调用对象,以函数或类作为可选输入参数,然后返回函数或类的形式.通过这个在Python2.6版本中被新加入的特性可以用来实现装饰器设计模式. 顺便提一句,在继续阅读之前,如果你对Python中的闭包(Closure)概念不清楚,请查看本文结尾后的附录,如果没有闭包的相关概念,很难恰当的理解P

  • Python闭包及装饰器运行原理解析

    一.闭包 闭包从形式上来说是在外部函数中定义内部函数,并且内部函数引用了外部函数的变量,此变量叫做自由变量. 或者说是将组成函数的语句和这些语句的执行环境打包在一起. 闭包满足的条件: 必须有一个内嵌函数 内嵌函数必须使用外部函数的变量 外部函数的返回值必须是内嵌函数 def closure(): value = [] def fun(tmp): value.append(tmp) return value return fun cc = closure() cc(0) #[0] 等同于clos

  • 简析Python的闭包和装饰器

    什么是装饰器? 装饰器(Decorator)相对简单,咱们先介绍它:"装饰器的功能是将被装饰的函数当作参数传递给与装饰器对应的函数(名称相同的函数),并返回包装后的被装饰的函数",听起来有点绕,没关系,直接看示意图,其中 a 为与装饰器 @a 对应的函数, b 为装饰器修饰的函数,装饰器@a的作用是: 简而言之:@a 就是将 b 传递给 a(),并返回新的 b = a(b) 栗子: 上面使用@dobi来表示装饰器,其等同于:qinfeng = dobi(qinfeng) 因此装饰器本质

  • Python闭包装饰器使用方法汇总

    闭包内容: 匿名函数:能够完成简单的功能,传递这个函数的引用,只有功能 普通函数:能够完成复杂的功能,传递这个函数的引用,只有功能 闭包:能够完成较为复杂的功能,传递这个闭包中的函数以及数据,因此传递是功能+数据 对象:能够完成最复杂的功能,传递很多数据+很多功能,因此传递的是数据+功能 ------------------- 对全局函数进行修改:在函数当中加global,在闭包中外边中的变量加nonlocal 闭包定义:有两个函数嵌套使用,里面的函数可以使用外面函数所传输的参数,最后可传递的是

  • Python函数装饰器实现方法详解

    本文实例讲述了Python函数装饰器实现方法.分享给大家供大家参考,具体如下: 编写函数装饰器 这里主要介绍编写函数装饰器的相关内容. 跟踪调用 如下代码定义并应用一个函数装饰器,来统计对装饰的函数的调用次数,并且针对每一次调用打印跟踪信息. class tracer: def __init__(self,func): self.calls = 0 self.func = func def __call__(self,*args): self.calls += 1 print('call %s

  • python @propert装饰器使用方法原理解析

    这篇文章主要介绍了python @propert装饰器使用方法原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 首先,@propert的作用是把类中的方法『变成』了属性,方便通过实例访问.propert可以有两种用法:可以把一个方法变成只读属性:可以对一些属性进行过滤. 想象这样一个场景,在实例化一个类之后,需要对类的一个属性进行赋值,这时候是没有对属性属性被赋予的值进行判断的,如果属性被赋予了一个不合适的值,那么代码在后面执行的时候就会

  • Python类装饰器实现方法详解

    本文实例讲述了Python类装饰器.分享给大家供大家参考,具体如下: 编写类装饰器 类装饰器类似于函数装饰器的概念,但它应用于类,它们可以用于管理类自身,或者用来拦截实例创建调用以管理实例. 单体类 由于类装饰器可以拦截实例创建调用,所以它们可以用来管理一个类的所有实例,或者扩展这些实例的接口. 下面的类装饰器实现了传统的单体编码模式,即最多只有一个类的一个实例存在. instances = {} # 全局变量,管理实例 def getInstance(aClass, *args): if aC

  • Python实现对一个函数应用多个装饰器的方法示例

    本文实例讲述了Python实现对一个函数应用多个装饰器的方法.分享给大家供大家参考,具体如下: 下面的例子展示了对一个函数应用多个装饰器,可以加多个断点,在debug模式下,查看程序的运行轨迹... #!/usr/bin/env python #coding:utf-8 def decorator1(func): def wrapper(): print 'hello python 之前' func() return wrapper def decorator2(func): def wrapp

  • Python函数装饰器常见使用方法实例详解

    本文实例讲述了Python函数装饰器常见使用方法.分享给大家供大家参考,具体如下: 一.装饰器 首先,我们要了解到什么是开放封闭式原则? 软件一旦上线后,对修改源代码是封闭的,对功能的扩张是开放的,所以我们应该遵循开放封闭的原则. 也就是说:我们必须找到一种解决方案,能够在不修改一个功能源代码以及调用方式的前提下,为其加上新功能. 总结:原则如下: 1.不修改源代码 2.不修改调用方式 目的:在遵循1和2原则的基础上扩展新功能. 二.什么是装饰器? 器:指的是工具, 装饰:指的是为被装饰对象添加

  • python通过装饰器检查函数参数数据类型的方法

    本文实例讲述了python通过装饰器检查函数参数数据类型的方法.分享给大家供大家参考.具体分析如下: 这段代码定义了一个python装饰器,通过此装饰器可以用来检查指定函数的参数是否是指定的类型,在定义函数时加入此装饰器可以非常清晰的检测函数参数的类型,非常方便 复制代码 代码如下: def accepts(exception,**types):     def check_accepts(f):         assert len(types) == f.func_code.co_argco

  • python装饰器使用方法实例

    什么是python的装饰器? 网络上的定义:装饰器就是一函数,用来包装函数的函数,用来修饰原函数,将其重新赋值给原来的标识符,并永久的丧失原函数的引用. 最能说明装饰器的例子如下: 复制代码 代码如下: #-*- coding: UTF-8 -*-import time def foo():    print 'in foo()' # 定义一个计时器,传入一个,并返回另一个附加了计时功能的方法def timeit(func): # 定义一个内嵌的包装函数,给传入的函数加上计时功能的包装    d

  • python使用装饰器和线程限制函数执行时间的方法

    本文实例讲述了python使用装饰器和线程限制函数执行时间的方法.分享给大家供大家参考.具体分析如下: 很多时候函数内部包含了一些不可预知的事情,比如调用其它软件,从网络抓取信息,可能某个函数会卡在某个地方不动态,这段代码可以用来限制函数的执行时间,只需要在函数的上方添加一个装饰器,timelimited(2)就可以限定函数必须在2秒内执行完成,如果执行完成则返回函数正常的返回值,如果执行超时则会抛出错误信息. # -*- coding: utf-8 -*- from threading imp

随机推荐

其他