Python面向对象高级

直接调用父类方法

class A:
    def __init__(self):
        print("hello")
class B(A):
    def __init__(self):
        A.__init__()

多继承

class C(A,B):
    # ...
# 多继承的查找循序是从左往右，注意继承顺序。
# 比如调用某个方法，A中也有B中也有，那么默认就用的A的方法。

slots

class Student:
    __slots__ = ('name','age')
s = Student()
s.name = "ar" # 正确
s.score = 95 # 报错，attribute err

slots限定只允许动态加name和age这两个实例属性。在子类中会继承slots，子类自身定义slots的时候两者取并集。

@property

property装饰器用来解决反复调用麻烦的问题，简化了函数调用。

# 直接抄例子了
# 不加装饰器
class Student(object):

    def get_score(self):
         return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
        
 # 加装饰器
class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
        
# 直接调用函数就可以检验

super

在pytorch和mxnet中继承的时候都有这个东西，一探究竟。

# 举个例子
class A:
  def __init__(self):
    print("Enter A")
    print("Leave A")
class B(A):
  def __init__(self):
    print("Enter B")
    super(B, self).__init__()
    print("Leave B")
class C(A):
  def __init__(self):
    print("Enter C")
    super(C, self).__init__()
    print("Leave C")
class D(A):
  def __init__(self):
    print("Enter D")
    super(D, self).__init__()
    print("Leave D")
class E(B, C, D):
  def __init__(self):
    print("Enter E")
    super(E, self).__init__()
    print("Leave E")
E()
'''
Enter E
Enter B
Enter C
Enter D
Enter A
Leave A
Leave D
Leave C
Leave B
Leave E
'''

首先我们要知道，python是解释型语言，执行到哪里就开始解释然后得到结果，所以我们从程序运行处开始看。

1. 实例化对象E，调用构造函数
2. 输出Enter E
3. 开始调用父类init，调用B的init，输出Enter B,发现要掉B的父类，super特殊就在这，要按照mro顺序来调用，所以走到这里要调B的父类A的init时，发现A之前还有CD没有调用，那么此时要去先调用CD的init
4. 调用C的init，输出Enter C，同样的，发现A之前还有D
5. 调用D的init，输出Enter D，A之前没有人了
6. 调用A的init，输出Enter A，输出leave A
7. 从D返回，输出leave D
8. ...

所以super的好处是，当多个类继承自同一类的时候，调用父类函数的时候会有一个mro查找顺序，以防止父类的函数被多次调用。至于mro，可以调用E.MRO()来查看。

[Python]面向对象近期笔记-super

原文：https://www.cnblogs.com/aoru45/p/10622435.html