关于python类的一些东拼西凑的基础知识

Python classmethod 修饰符（摘自python菜鸟教程）

不需要实例化，只要用类名就可以调用的函数， 用法：在定义函数之前加上@classmethod

描述

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

输出结果：

func2
1
foo

python @abstractmethod

参考链接：https://blog.csdn.net/xiemanR/article/details/72629164

抽象方法表示基类的一个方法，没有实现，所以基类不能实例化，子类实现了该抽象方法才能被实例化。

实例

关于super类的一系列乱七八糟的事

super继承自己

class SongBird(Bird):
     def __init__(self):
          super(SongBird,self).__init__()
          self.sound = 'Squawk'
     def sing(self):
          print self.song()

super菱形继承案例

关于如何计算super的MRO

参考链接：https://mozillazg.com/2016/11/python-mro-compute.html

实例

>>> O = object
>>> class F(O): pass
>>> class E(O): pass
>>> class D(O): pass
>>> class C(D,F): pass
>>> class B(D,E): pass
>>> class A(B,C): pass

根据链接的方法计算

L[O] = O = object
L[F] = L[F(O)] = F  O
L[E] = L[E(O)] = E  O
L[D] = L[D(O)] = D  O

L[C] = L[C(D, F)]
     = C + merge(L[D], L[F], DF)
     # 从前面可知 L[D] 和 L[F] 的结果
     = C +  merge(DO, FO, DF)
     # 因为 D 是顺序第一个并且在几个包含 D 的 list 中是 head，
     # 所以这一次取 D 同时从列表中删除 D
     = C + D + merge(O, FO, F)
     # 因为 O 虽然是顺序第一个但在其他 list (FO)中不是 head, 跳过,
     # 改为检查第二个list FO
     # F 是第二个 list 和其他 list 的 head,
     # 取 F同时从列表中删除 F
     = C + D + F + merge(O)
     = C D F O

>>> C.mro()
[<class '__main__.C'>, <class '__main__.D'>, <class '__main__.F'>, <type 'object'>]

菱形继承实例

class A():
    def __init__(self):
        print('enter A')
        print('leave A')


class B(A):
    def __init__(self):
        print('enter B')
        super().__init__()
        print('leave B')


class C(A):
    def __init__(self):
        print('enter C')
        super().__init__()
        print('leave C')


class D(B, C):
    def __init__(self):
        print('enter D')
        super().__init__()
        print('leave D')


d = D()

根据上面的方法计算D的MRO应该为（D,B,C,A）
执行结果：

enter D
enter B
enter C
enter A
leave A
leave C
leave B
leave D

构造方法中的初始值无法继承问题

参考链接： https://www.cnblogs.com/liyichen/p/5931840.html

实例

class Bird:
    def __init__(self):
          self.hungry = True
    def eat(self):
          if self.hungry:
               print 'Ahahahah'
          else:
               print 'No thanks!'

class SongBird(Bird):
     def __init__(self):
          self.sound = 'Squawk'
     def sing(self):
          print self.song()

sb = SongBird()
sb.sing()    # 能正常输出
sb.eat()     # 报错，因为 songgird 中没有 hungry 特性

解决办法

1、调用未绑定的超类构造方法（多用于旧版 python 阵营）

class SongBird(Bird):
     def __init__(self):
          Bird.__init__(self)
          self.sound = 'Squawk'
     def sing(self):
          print self.song()

原理：在调用了一个实例的方法时，该方法的self参数会自动绑定到实例上（称为绑定方法）；如果直接调用类的方法（比如Bird.init），那么就没有实例会被绑定，可以自由提供需要的self参数（未绑定方法）。

2、使用super函数（只在新式类中有用）

class SongBird(Bird):
     def __init__(self):
          super(SongBird,self).__init__()
          self.sound = 'Squawk'
     def sing(self):
          print self.song()

原理：它会查找所有的超类，以及超类的超类，直到找到所需的特性为止。