python装饰器

1.高阶函数 将函数作为参数传入 1）map/reduce map:传入两个参数，一个是函数，一个是迭代器，主要作用是将运算规则抽象化表达，如： >>> def f(x): return x * x >>> r = map(f,[1,2,3,4,5,6,7]) >>> list(r) [1, 4, 9, 16, 25, 36, 49] reduce：传入两个参数，做累计效果 将[1,3,5,6]变成1356 >>> from functools import reduce >>> def fn(x,y): return x*10 + y >>> reduce(fn,[1,3,5,6]) 1356 也可将str转换成int from functools import reduce DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} def str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return DIGITS[s] return reduce(fn, map(char2num, s)) 2)fliter:用于过滤序列 def is_odd(n): return n % 2 == 1

一、叠加装饰器 定义：在同一个被装饰对象，添加多个装饰器，并执行。 叠加装饰器的装饰顺序与执行顺序 装饰顺序：由下往上装饰。 执行顺序：由上往下执行。 注意：装饰器在调用被装饰对象时才会执行添加功能。 def wrapper1(func): def inner1(*args,**kwargs): print('1') res = func(*args,**kwargs) print('2') return res return inner1 def wrapper2(func): def inner2(*args,**kwargs): print('3') res = func(*args,**kwargs) print('4') return res return inner2 def wrapper3(func): def inner3(*args,**kwargs): print('5') res = func(*args,**kwargs) print('6') return res return inner3 @wrapper1 #inner1 = wrapper1(inner2) @wrapper2 #inner2 = wrapper2(inner3) @wrapper3 #inner3 = wrapper3(foo) def foo(): print('from

无参装饰器： 在调用无参装饰器时，不需要在外层传递参数。 适用于例如： 　　- 为某个函数增加统计运行时间功能 　　- 为某个函数运行前增加登录认证功能 有参装饰器： 在调用有参装饰器时，对其传入一个或多个参数。 适用于例如： 　　- 验证用户类型 def user_auth(user_group): def wrapper(func): def inner(*args, **kwargs): if user_group == 'SVIP': print('Dear SVIP') res = func(*args, **kwargs) return res elif user_group == 'General': res = func(*args, **kwargs) return res else: print('Please login first!') login() return inner return wrapper @user_auth(user_group='SVIP') def welcome(): print('Welcome to the index') welcome() 来源： https://www.cnblogs.com/Ghostant/p/11850842.html

D11 闭包、装饰器 1、闭包 　　参考 http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 阮一峰网络日志 　　闭包概念： 　　闭包就是能够从外部读取目标函数内部变量的函数。在一些编程语言中，只有函数内部的子函数才能读取局部变量， 　　因此可以把闭包简单理解成"定义在一个函数（目标函数）内部的函数（闭包函数）"。 　　所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。 　　关于判断是否是闭包： 　　如果此函数拥有自由变量，那么就可以侧面证明其是否是闭包函数了。 def wrapper(): a = 1 def inner(): b = 2 print('使用函数内部变量a：',a) return inner ret = wrapper() ret() # 函数名.__code__.co_freevars 查看函数的自由变量 print(ret.__code__.co_freevars) # 函数名.__code__.co_varnames 查看函数的局部变量 print(ret.__code__.co_varnames) # 函数名.__closure__ 获取具体的自由变量对象，也就是cell对象。 print(ret.__closure__) # cell

装饰器 什么是装饰器？ ​ 装饰器是一个函数，主要作用是用来给包装另一个函数或者类 包装的目的是不改变原函数名(或类名)的情况下改变或添加被包装对象的功能 函数装饰器 是指装饰器是一个函数，传入的是一个函数，返回的也是一个函数 语法： def 装饰器函数名(参数): 语句块 return 函数对象 @张诗琪函数名 def 函数名(形参列表）： 语句块 示例： # 此示例示意装饰器函数的定义方式及装饰器来装饰另一个函数 # 的语法 def mydeco(fn): def fx(): print("++++++++++++++++") print('----------------') return fx def myfunc(): '''此函数将作为被装饰函数''' print("myfunc被调用") # 原理是让myfunc重新绑定mydeco返回回来的函数 myfunc = mydeco(myfunc) myfunc() myfunc() myfunc() # 此示例示意装饰器函数的定义方式及装饰器来装饰另一个函数 # 的语法 def mydeco(fn): def fx(): print("++++++++++++++++") print('----------------') return fx @mydeco def myfunc(): '''此函数将作为被装饰函数'''

再不影响函数的情况下，提供更多的功能。 本质：python函数或类。　　让其他函数或类在不需要做任何代码修改的前提下增加额外功能，返回值也是函数或类对象。 插入日志、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计。 我们可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。 def foo(): print("foo") logging.info("foo is running")　　　　#新的需求，希望可以记录下函数的执行日志 def bar(func):　　　　　　#Python 中的函数可以像普通变量一样当做参数传递给另外一个函数 func() bar(foo) 减少重复代码： def use_logging(func): logging.warn("%s is running" % func.__name__) func() def foo(): print('i am foo') use_logging(foo) 1 来源： https://www.cnblogs.com/zhang1422749310/p/11825952.html

说到装饰器，就不得不说python自带的三个装饰器： 1、@property 将某函数，做为属性使用 @property 修饰，就是将方法，变成一个属性来使用。 class A(): @property def pfunc(self): return self.value @pfunc.setter def pfunc(self,value): self.value = value @property def pfunc1(self): print('this is property') if __name__=="__main__": A.pfunc = 9 print A.pfunc A.pfunc1 2、@classmethod 修饰类的方式 带修饰类方法：cls做为方法的第一个参数，隐式的将类做为对象，传递给方法，调用时无须实例化。 普通函数方法：self做为第一个参数，隐式的将类实例传递给方法，调用方法时，类必须实例化。 class A(): def func(self,x,y): return x * y @classmethod def cfunc(cls,x,y): return x * y if __name__=="__main__": print A().func(5,5) print A.cfunc(4,5) 3、@staticmethod 修饰类的方式 1

Python中的装饰器是你进入Python大门的一道坎，不管你跨不跨过去它都在那里。 为什么需要装饰器 # 我们假设你的程序实现了 say_hello() 和 say_goodbye() 两个函数。 Copy def say_hello(): print "hello!" def say_goodbye(): print "hello!" # bug here if __name__ == '__main__': say_hello() say_goodbye() 但是在实际调用中，我们发现程序出错了，上面的代码打印了两个hello。经过调试你发现是 say_goodbye() 出错了。老板要求调用每个方法前都要记录进入函数的名称，比如这样： Copy [DEBUG]: Enter say_hello() Hello! [DEBUG]: Enter say_goodbye() Goodbye! 好，小A是个毕业生，他是这样实现的。 Copy def say_hello(): print "[DEBUG]: enter say_hello()" print "hello!" def say_goodbye(): print "[DEBUG]: enter say_goodbye()" print "hello!" if __name__ == '__main__': say

收拾了一下自己学习Python过程中的笔记，将Python面试过程中经常涉及到的一些问题整理出来。没有总结到的知识点，欢迎大家在评论里提出来，本文长期更新。 1、Python基本语法 1、@staticmethod 和 @classmethod Python中有三种方法，实例方法、类方法(@classmethod)、静态方法(@staticmethod)。 类方法的第一个参数是cls，表示该类的一个实例，静态方法基本上和一个全局函数相同 class A(object): def foo(self, x): print("executing foo(%s,%s)" % (self, x)) print('self:', self) @classmethod def class_foo(cls, x): print("executing class_foo(%s,%s)" % (cls, x)) print('cls:', cls) @staticmethod def static_foo(x): print("executing static_foo(%s)" % x) a = A() print(a.foo(1)) print(a.class_foo(1)) print(a.static_foo(1)) 2、迭代器和生成器 迭代器：是访问集合元素的一种方式

1.执行顺序 当一个程序里面有多个装饰器的时候如何执行的呢，借助一个程序来理解一下 def decorator_a(func): print('Get in decorator_a') def inner_a(*args,**kwargs): print('Get in inner_a') res = func(*args,**kwargs) return res return inner_a def decorator_b(func): print('Get in decorator_b') def inner_b(*args,**kwargs): print('Get in inner_b') res = func(*args,**kwargs) return res return inner_b @decorator_b @decorator_a def f(x): print('Get in f') return x * 2 f(1) 这段程序的运行结果是 在这个函数还未执行的时候，解释器会从上到下的读取函数，读到@decorator_b @decorator_a在这个时候，会从上到下的执行decorator_b和decorator_a函数，这个顺序是按照代码从上到下的顺序执行的，执行结果为下 然后在进一步执行@decorator_b @decorator_a装饰器内部函数