装饰器--

在这里插入代码片

#!/usr/bin/env python

-- coding:utf-8 --

@IDE : PyCharm

@Project ：test

@File : day15.py

@Time : 2019/8/9 8:03

@Author : wentao song

1. 函数中装饰器

2. 类中的装饰器

装饰器：

概念：

装饰器也是一种函数，它可以在其他函数不发生改变的情况下，额外加入功能。

特点：

装饰器是一个闭包，把一个函数当做参数返回一个替代版的函数

Python3支持用@符号直接将装饰器应用到函数。

应用：

应用场景：插入日志，做性能测试，可以做事务处理。

函数被装饰后，此函数属性发生变化。

time： time.sleep(second)

“”"
①函数的基本调用
import time
def myFunc():
‘’’
# time.time()打印时间
time1 = time.time()
# time.local()打印时间
time2 = time.localtime(time.time())
# time.asctime()打印时间
time3 = time.asctime(time2)
print(time1)
print(time2)
print(time3)
:return:
‘’’
print(time.asctime(time.localtime(time.time())))
time.sleep(3)
print(‘myFunc end!’)

myFunc()

def foo():
startTime = time.time()
myFunc()
endTime = time.time()
print(‘myFun run time is %f’%(endTime-startTime))

if name == ‘main’:,

仅在本文件中执行冒号后的代码， 用于代码调试时使用

if name == ‘main’:
foo()
print(foo.name)# 打印函数名
“”"
‘’’
装饰器处理无参函数：
import time

最原始的装饰器

def foo(f):
def wrapper():
startTime = time.time()
f()
endTime = time.time()
print(‘wrapper run time is %f’%(endTime-startTime))
return wrapper

@foo
def myFunc():
print(time.asctime(time.localtime(time.time())))
time.sleep(3)
print(‘myFunc end!’)

def fib():
a,b = 0,1
while b<1000:
print(b)
a,b = b,a+b

def foo():

def wrapper():

startTime = time.time()

print(‘hello Python’)

endTime = time.time()

print(‘wrapper run time is %f’%(endTime-startTime))

return wrapper

#任务：调用wrapper函数

foo()()

一、原始调用方式(高阶函数调用方式）

foo(myFunc)()

foo(fib)()

二、装饰器的专用方式

    myFunc()
    # 装饰器须放在调用函数之前
    
    # 装饰器处理带参数的函数
    import time
    
    def foo(f):
        def wrapper(n):
            startTime = time.time()
            f(n)
            endTime = time.time()
            print('wrapper run time is %f'%(endTime-startTime))
        return wrapper
    @foo
    def fib(n):
        a,b = 0,1
        while b<n:
            # print(b)
            time.sleep(0.05)
            a,b = b,a+b
    fib(50)
    
    import time
    
    def foo(f):
        def wrapper(*args,**kwargs):
            print('run in foo1-wrapper')
            startTime = time.time()
            f(*args,**kwargs)
            endTime = time.time()
            print('wrapper run time is %f'%(endTime-startTime))
        return wrapper
    
    def foo2(f):
        def wrapper(*args, **kwargs):
            print('run in foo2-wrapper ')
            f(*args, *kwargs)
            print('foo2-wrapper end!')
        return wrapper
    #装饰器叠加，
    # 装饰器中函数执行前，调用顺序依次按照先后执行，
    #   装饰器内部函数执行后，按照相反顺序依次执行装饰器中代码
    @foo2
    @foo
    def sumFun(a,b):
        print(a**2+b**3)
        time.sleep(0.5)
    @foo
    def avgFun(a,b, c):
        print((a+b+c)/3)
        time.sleep(0.2)
    # sumFun(3,2)
    # avgFun(3*2,2**3,3**2)
    sumFun(3,2)

‘’’

‘’’
练习题：
1.写出完整的装饰器(不用开了带参装饰器，就是普通装饰器)语法
def foo(f):
def wrapper(*args, **kwargs):
pass
result = f(*args,**kwargs)
pass
return result
return wrapper
2.有一个计算两个数和的方法，为其添加一个确保两个参数都是
int或float类型的装饰器，保证运算不会抛异常
def CheckSum(f):
def Inner(a, b):
if isinstance(a, int)and isinstance(b,int)
or isinstance(a, float) and isinstance(b, float):
result = f(a,b)
print(‘SUM A,B=’,result)
else:
print(‘不能求和’)
return Inner

@CheckSum
def AddFunc(a,b):
    return a + b
AddFunc(1,2.5)    

3.有一个一次性录入人名并返回人名的方法(人名只考虑存英文)，
为其添加一个装饰器，确保人名首字母大写
title(…)
| S.title() -> str
|
| Return a titlecased version of S, i.e. words start with title case
| characters, all remaining cased characters have lower case.
def titleName(f):
def Inner():
result = f()
# return result.title()
print(result.title())
return Inner
@titleName
def getName():
name = input(‘请输入一个名字：’)
return name
# print(getName())
getName()
‘’’

‘’’
类的特殊方法： @classmethod @staticmethod @property

1. 类方法@classmethod，只能访问类的变量，不能访问实例变量。
   通过实例化传参无法引入构造函数中设置的参数。
   该方法，不需要实例化，仅通过【类名.方法名（）】

2. 静态方法@statticmethod， 方法参数与实例没关系，
   相当于与类的关联关系被截断了。是类中的单独函数，不可以传递参数
   也无需实例化
   class Demo():
   name = ‘橙汁’
   def init(self, name):
   self.name = name
   def objPrint(self, other):
   print(’%s 是实例化方法，%s’%(self.name, other))
   @classmethod
   def classPrint(self, other):
   print(’%s 是类方法，%s’%(Demo.name, other))
   @staticmethod
   def staticPrint(other):
   print(‘我是静态方法：%s’%other)

   obj = Demo(‘橙子’)
   obj.objPrint(‘包子’)
   obj.classPrint(‘烧饼’)
   obj.staticPrint(‘油条’)

#property属性方法,将类方法转为属性，并且可以进行赋值
class test():
def init(self, name):
self.name = name
self.__food = None
@property
def wangluyu(self):
print(’%s is eating %s’%(self.name, self.__food))
@wangluyu.setter
def wangluyu(self,food):
print(‘set to food:’,food)
self.__food = food

a = test('王璐宇')
a.wangluyu
a.wangluyu='羊肉串'
a.wangluyu       

‘’’