9159金沙游艺场


理解SVG坐标系和变换:视窗,viewBox和preserveAspectRatio
9159金沙游艺场 1
JavaScript 深入之bind的模拟实现

Python基础(七) python自带的三个装饰器

说到装饰器,就不得不说python自带的三个装饰器:

内容包含:

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

1、@property  
将某函数,做为属性使用

  • 元类
  • python 对象和类的绑定以及类方法,静态方法
  • python 子类调用父类方法总结
  • python 方法解析顺序MRQ
  • python定制类和魔法方法
  • 关于用法__slots__
  • @property使用
  • 修饰器

什么是装饰器(decorator)

 @property 修饰,就是将方法,变成一个属性来使用。

0、元类

元类就是类的类,所体现的终极思想就是一切皆对象。

9159金沙游艺场 1

image.png

关于深层次,待使用到在总结。

简单来说,可以把装饰器理解为一个包装函数的函数,它一般将传入的函数或者是类做一定的处理,返回修改之后的对象.所以,我们能够在不修改原函数的基础上,在执行原函数前后执行别的代码.比较常用的场景有日志插入,事务处理等.

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

1、python 对象和类的绑定以及类方法,静态方法

通常我们要使用一个类中的方法时,都需要实例化该类,再进行调用,那类中
self 和 cls
有什么含义,能不能不初始化一个实例而直接调用类方法,对象方法和类方法,静态方法又有什么关系。是本篇文章思考的问题。

类的调用有以下两种方法:

>>>class Test:
...    def func(self, message):
...        print message
...
>>>object1=Test()
>>>x=object1.func
>>>x('abc')
abc
>>>t=Test.func
>>>t(object1,'abc')
abc

但是对于 t=Test.func 来说,变量名 t 是关联到了类 Test 的func
方法的地址上,t是非绑定的,所以在调用t(object1, ‘abc’)
时,必须显式的将实例名与 self 关联,否则将会报出”TypeError: unbound
method func() must be called with Test instance as first argument (got
str instance instead)” 的错误。

装饰器

 

参考学习

明白以下几点:
1、类默认的方法都是绑定对象的,而self参数也是指向该对象,没有实例化对象时,类中方法调用会出错,也涉及到python自动传递self参数。
2、若想不实例化而直接通过 类名.方法
来调用,需要指定该方法绑定到类,如下,一要使用@classmethod
装饰器,二方法中第一个参数为cls,而不是self。

>>> class Foo(object):          
...     @classmethod                #定义类方法要点1
...     def foo(cls):               #定义类方法要点2
...             print 'call foo'
... 
>>> Foo.foo()
call foo
>>> Foo().foo()
call foo

类也是对象,因此和下面的静态方法还是有不一样。类中直接定义的属性如下,在类方法中也是可以直接使用的。

class pizza(object):
    radius = 42
    @classmethod
    def get_radius(cls):
        return cls.radius
print pizza.get_radius()

类方法对于创建工厂函数最有用,如下

class pizza(object):
    def __init__(self,ingre):
        self.ingre = ingre

    @classmethod
    def from_other(cls,fridge):
        return cls(fridge.juice()+fridge.cheese())  
    def get_ingre(self):
        return self.ingre

cls代表该类,cls()也是用来创建对象,和pizza(fridge.juice()+fridge.cheese())效果一样。待理解,工厂方法是什么?
3、若只想当成一个普通函数,定义不包含self和cls,则可以使用静态方法,如下:

>>> class Foo(object):
...     @staticmethod
...     def foo():
...             print 'call foo'
... 
>>> Foo.foo()
call foo
>>> Foo().foo()
call foo

作者:_Zhao_
链接:http://www.jianshu.com/p/4b871019ef96
來源:简书

最简单的函数,返回两个数的和

2、@classmethod
 修饰类的方式

2、python 子类调用父类方法总结

9159金沙游艺场,参考来源

talk is weak,从程序开始:

class Person(object):
    def __init__(self):
        self.name = "Tom"
    def getName(self):
        return self.name

class Student(Person):
    def __init__(self):
        self.age = 12
    def getAge(self):
        return self.age

if __name__ == "__main__":
    stu = Student()
    print stu.getName()

作者:nummy
链接:http://www.jianshu.com/p/dfa189850651

9159金沙游艺场 2

image.png

上面只是说明一个常用的子类调用父类场景,即调用父类的初始化函数。
直接运行以上代码会出错,因为尽管Student类继承了Person类,但是并没有调用父类的init()方法,因为子类中对init函数进行了重写,若没有重写会直接继承父类的init函数自动运行。有以下两种方法:

参考
1、super方法

class Base:
    def __init__(self):
        print('Base.__init__')

class A(Base):
    def __init__(self):
        # super().__init__()
        super(A,self).__init__()
        print('A.__init__')

class B(Base):
    def __init__(self):
        # super().__init__()
        super(B,self).__init__()
        print('B.__init__')

class C(A,B):
    def __init__(self):
        # super().__init__()  # Only one call to super() here  python3
        super(C,self).__init__()
        print('C.__init__')

运行结果

>>> c = C()
Base.__init__
B.__init__
A.__init__
C.__init__
>>>

2、调用未绑定的父类构造方法

class Person(object):
    def __init__(self):
        self.name = "Tom"
    def getName(self):
        return self.name

class Student(Person):
    def __init__(self):
        Person.__init__(self)
        self.age = 12
    def getAge(self):
        return self.age

if __name__ == "__main__":
    stu = Student()
    print stu.getName()

作者:nummy
链接:http://www.jianshu.com/p/dfa189850651

非绑定方法不经常用到,上述场景却使用的比较多(即子类覆盖父类的方法)。运行时没有父类person的实例,需要显示地进行传递,但有Student的实例,可以用来进行代替。
这种方法叫做调用父类的未绑定的构造方法。在调用一个实例的方法时,该方法的self参数会被自动绑定到实例上(称为绑定方法)。但如果直接调用类的方法(比如Person.__init),那么就没有实例会被绑定。这样就可以自由的提供需要的self参数,这种方法称为未绑定unbound方法。
通过将当前的实例作为self参数提供给未绑定方法,Student类就能使用其父类构造方法的所有实现,从而name变量被设置。

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

带修饰类方法:cls做为方法的第一个参数,隐式的将类做为对象,传递给方法,调用时无须实例化。

3、python 方法解析顺序

但是现在又有新的需求,计算求和操作耗时,很简单,求和前获取一下时间,求和后再获取一次,求差即可

普通函数方法:self做为第一个参数,隐式的将类实例传递给方法,调用方法时,类必须实例化。

参考

上述博文具有很强的参考意义,转述如下:
在类的多继承中,方法解析顺序MRQ具有很重要的意义,比如对以下菱形继承,D的实例调用show方法,是调用A的还是C的show。

9159金沙游艺场 3

image.png

python解析顺序的规范化也是一个不断发展的过程,主要有以下两个阶段:

  • 2.2之前的经典类。经典类中多继承方法解析采用深度优先从左到右搜索,即D-B-A-C-A,也就是说经典类中只采用A的show方法。
  • 经典类对单层继承没有什么问题,但是对上述来说,我们显然更愿意使用C的show方法,因为他是对A的具体化,但是经典类比并不能实现,于是在2.2中引入新式类(继承自object),它仍然采用从左至右的深度优先遍历,但是如果遍历中出现重复的类,只保留最后一个。并且在定义类时就计算出该类的
    MRO 并将其作为类的属性。因此新式类可以直接通过 mro 属性获取类的
    MRO。
    举个例子:

9159金沙游艺场 4

image.png

按照深度遍历,其顺序为 [D, B, A, object, C, A,
object],重复类只保留最后一个,因此变为 [D, B, C, A, object]

这样看起来好像么有问题,但是会有潜在的问题,比如破坏了单调性原则,因此在2.3中引入了
__ C3 算法__。

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)
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)
C3 MRQ

我们把类 C 的线性化(MRO)记为 L[C] = [C1, C2,…,CN]。其中 C1 称为
L[C] 的头,其余元素 [C2,…,CN] 称为尾。如果一个类 C 继承自基类
B1、B2、……、BN,那么我们可以根据以下两步计算出 L[C]:
1、L[object] = [object]
2、L[C(B1…BN)] = [C] + merge(L[B1]…L[BN], [B1]…[BN])
这里的关键在于 merge,其输入是一组列表,按照如下方式输出一个列表:
检查第一个列表的头元素(如 L[B1] 的头),记作 H。
若 H
未出现在其它列表的尾部,则将其输出,并将其从所有列表中删除,然后回到步骤1;否则,取出下一个列表的头部记作
H,继续该步骤。
重复上述步骤,直至列表为空或者不能再找出可以输出的元素。如果是前一种情况,则算法结束;如果是后一种情况,说明无法构建继承关系,Python
会抛出异常。

举例:

9159金沙游艺场 5

image.png

根据C3,计算过程为:

9159金沙游艺场 6

image.png

现在呢,函数calc_diff(a, b),计算a-b,也想计算减法操作的时间差,很好办,把那段代码复制过去.但是假如我们现在想编的是一个数学函数库,各种函数都想计算其执行耗时,总不能一个一个复制代码,想个更好的办法.

 

4、python定制类和魔法方法

我们知道,在Python中函数也是被视为对象的,可以作为参数传递,那么假如把计算耗时的独立为一个单独的函数calc_spend_time(),然后把需要计算耗时的函数例如calc_add的引用传递给它,在calc_spend_time中调用calc_add,这样所有的需要计算耗时的函数都不用修改自己的代码了.

3、@staticmethod
 修饰类的方式

参考学习

形如__xxx__的变量或者函数名要注意,这些在Python中是有特殊用途。常见的就是__inint__()函数了,在对象创建后用来初始化,类似的还有__new()__
和__del__函数。用的不是很多,不做细节深入。

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)

1)是把函数嵌入到类中的一种方式,函数就属于类,同时表明函数不需要访问这个类

__str__ 和 __rerp__
class yuan(object):
    def __init__(self):
        self.name = 'yuanqijie'
        self.age = 22
        self.ambition = 'yes'
    def __str__(self):
        return 'object name: %s'  % self.name

qijie = yuan()
print qijie

输出为:
object name: yuanqijie

若没有重写 __str__ 则输出为 <main.Student object at
0x109afb310>
但注意到,若直接输出变量而不是用print在提示符下还是上述信息,因为直接显示变量调用的不是str(),而是repr(),两者的区别是str()返回用户看到的字符串,而repr()返回程序开发者看到的字符串,也就是说,repr()是为调试服务的。可以类似上述方法进行重写,作为了解即可。

看起来也不错,负责计算的函数不用更改,只需调用的时候作为参数传给计算时间差的函数.但就是这,调用的时候形式变了,不再是clac(1, 2),而是calc_spend_time(clac_add, 1,
2),万一calc_add大规模被调用,那么还得一处一处找,然后修改过来,还是很麻烦.如果想不修改代码,就得使clac()calc_spend_time(clac)效果一样,那么可以在calc_spend_time()里把传入的clac包装一下,然后返回包装后的新的函数,再把返回的包装好的函数赋给clac,那么calc()的效果就和上例calc_spend_time(calc())效果一样.

 2)使用修饰服,修饰方法,不需要实例化

5、__slots__

当定义一个类时,可以动态的给该类绑定一个属性和方法,比如:

>>> class Student(object):
...     pass

>>> s = Student()
>>> s.name = 'Michael' # 动态给实例绑定一个属性
>>> print s.name
Michael

>>> def set_age(self, age): # 定义一个函数作为实例方法
...     self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s, Student) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法
>>> s.age # 测试结果
25

注意的是,上面是给一个实例绑定的相应的方法,也就是说当在生成一个实例时,上述增加的属性和方法就不起作用了。可以给class绑定方法:

>>> def set_score(self, score):
...     self.score = score
...
>>> Student.set_score = MethodType(set_score, None, Student)

只需将MethodType第二个参数改为None就行。

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)

相关文章

No Comments, Be The First!
近期评论
    功能
    网站地图xml地图