python基础学习之类的继承、魔法方法

• 什么是继承

  即类A可以使用类B的方法，即B是A的父类，A是B的子类，AB之间是继承关系

  class Father():  # 父类

  def __init__(self,name,age):

  self.name= name

  self.age= age

  def myself(self):

  print('大家好！我是%s,今年%s岁'%(self.name,self.age))

  class Son(Father):      # 子类

  pass

  格式如此，子类的（）内写上父类的类名，子类的运行的时候，会现在自己内部寻找方法，如果找不到，则会去父类中寻找，如果父类中没有，则回去父类的父类中寻找，所有类的总父类（最上一级的父类，唯一没有父类的类）是系统内部定义的object类

• 如何查看类的父类情况

  使用内置函数"__bases__"方法

  Father. __bases__  --结果-->  (<class 'object'>,)

  Son. __bases__      --结果--> (<class '__main__.Father'>,)

• 什么是多继承

  多继承，就是A类在继承B类的同时，还继承了C类，但与此同时，B,C两个类之间，并没有关联

• 示例如下，Base为定义类，其父类为object，A,B均继承Base，C同时继承A,B

  class Base:

  def play(self):
          print('这是Base')
  class A(Base):

  def play(self):
          print('这是A')
  class B(Base):

  def play(self):
          print('这是B')
  class C(A, B):
      pass
  c = C()

  在C类实例化的时候，会调用C中方法，如果没有，则去父类中寻找，这时候，会按照你C（）内的顺序去寻找，即想寻找A中方法，再去B，如果是（B,A）则先找B中寻，当A,B均没有的时候，会去A,B的父类Base中找寻，但是多继承，不建议多层环绕，容易乱。。。。。。

  多继承有先后顺序，执行也会按照顺序，当子类中存在和父类中一样的方法时候，会执行子类中的方法，而忽略掉父类中的方法，即被称作，子类方法覆盖了父类同名方法。

• 如果在多继承中，子类覆盖父类方法后，仍然调用父类的方法呢？

  class Base:

  def play(self):
          print('这是Base')
  class A(Base):

  def play(self):
          print('这是A')
  class B(Base):

  def play(self):
          print('这是B')

  方法1：在子类中的方法内使用【类名.方法(self)】的方式调用

  class C(A, B):

  def play(self):

  A.play(self)

  print('这是C')

  方法2：使用super().方法（），这是python的内置方法super即指改类的父类【为了方便编写，减少代码的修正，建议使用该方法】

  class C(A, B):

  def play(self):

  super().play()

  print('这是C')

  结果输出如下：

  这是Base

  这是B

  这是A

  这是C

  emmmm，为什么多来了个B？

• super函数方法

  super的好处显而易见，但是为什么上述代码结果多了个B的运行结果，按照子父类的运行顺序，A运行后，应该是调用的Base啊

  super函数的运行顺序，是按照内置的mro规则运行，可以使用类.mro查看。

  当我们使用C.mro的时候，回到的结果如下：

  [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>]

  那么此时，我们的函数会按照这个顺序来调用类的方法，可以看到，顺序为C--->A--->B--->Base--->object，因为Base没有使用super方法，所以跟object无关。

• 最好，多继承就一层，且是最后一层

  多继承的下面，别再写继承了，脑壳儿疼

• 魔法方法

  在某些特定情况下会被触发运行的方法

• 了解运算符的魔法方法

• __add__(self,other)----------->x+y

  __sub__(self,other)----------->x-y

  __mul__(self,other)----------->x*y

  __mod__(self,other)---------->x%y

  __iadd__(sellf,other)---------->x += y

  __isub__(self,other)----------->x -= y

  __imul__(self,other)----------->x *= y

  __imod__(self,other)---------->x %= y

  __radd__(self,other)----------->y + x

  __rsub__(self,other)----------->y - x

• __init__方法，初始化

• 当类在实例化的同时，被传入参数，会直接触发__init__方法，当然，在类中，你需要提前定义好__init__方法，然后实例化的括号内被传入参数，会触发这个方法，不需要再去调用

• __str__和__repr__方法

  默认情况下，打印实例对象的时候，输出的是内存地址，可以通过修改__str__或者__repr__方法来调整输出内容

• class Person:

  pass

  a = Person()

  print(a)        #得到内存地址内容

  class Person:

  def __repr__(self):

  return '这里是__repr__返回值'

  a = Person()

• __call__方法，调用或者叫唤醒

  这个方法可以让类如同函数一样被调用

  函数怎么调用的来着？函数名+（）

  当定义了__call__方法后，我们可以使用类名+（）的方法调用

  进阶下，如果内部含有__init__方法的时候，你在括号内传入参数，也可以触发。

• __new__方法，这个方法比较抽象，是针对的内存空间进行操作的

  他会在类实例化操作的同时，在内存中开辟一个空间来防止这个类的内容

  1、__new__方法是在类创建实例化时被调用的

  2、在类实例化时，__new__会在内存中开辟一个空间来，这之后，类的实例化才被完全创建完成

  3、__init__初始化方法是实例化完成后的操作，也就是__new__方法，还在__init__之前执行

  4、__new__(cls,*args,**kwargs)，cls参数即class，类本身

• 学函数的时候我们就知道，我们需要尽可能少的去占用内存，每次实例化，都相当于调用了一次默认的__new__函数，开辟了一个空间，占用了部分内存，假使我们有100000个实例化，内存不是要炸？怎么做可以减少内存占用

  我们可以通过改写魔法方法来使其每次调用的内存空间固定，这样一来，我们每次实例化，都是使用同一块内存空间

• class A:
      def __new__(cls, *args, **kwargs):
          if not hasattr(cls,'instance'):
          cls.instance = super.__new__(cls)
          return cls.instance
      return instance

  解释下，这段代码：

  定义一个类A，重写__new__方法，在下面写一个判断语句，我假使我要使用的内存空间名字为instance，我就用hasattr（查看参数类中有无该属性）函数判断下定义类A中有没有这个instance的函数属性，有的话，我就拿来用，没有，我就调用他的父类（或者其他某个不变类，一般默认总父类为object，一般不会有傻子去改这个类的方法吧？）的__new__方法创建一个空间，来命名为‘instance’，当下一次实例化的时候，再次判断，会发现已经有这个空间了，就直接拿来覆盖内容使用。

• 上述内容中__new__,__init__,__str__,__repr__等常用的魔法方法，需要掌握