类的高级主题

1.通过在自定义类中嵌入内置类型，类似委托；这样自定义类就可以实现内置类型的接口。
这些接口在内部通过操作嵌入的内置类型来实现。

这是一种扩展内置类型的方式

2.通过子类扩展内置类型：所有内置类型都可以直接创建子类，如list、str、dict、tuple、set等

  • 内置类型的子类实例可以用于内置类型对象能够出现的任何地方

3.在Python3中所有的类都是新式类。

Python2.2之前的类不是新式类

  • 所有的类都是从object内置类派生而来
  • type(obj)返回对象实例所属的类对象

    对于实例对象的type(obj)返回值也是obj.__class__

  • type(classname)返回"type"，因为所有class对象都是type的实例
  • 由于所有class均直接或者间接地派生自object类，因此每个实例对象都是object类的实例

  • object是type类的实例，但是同时type又派生自object

    新式类

4.Python3中的类有一个.__slots__属性，它是一个字符串列表。这个列表限定了类的实例对象的合法属性名。如果给实例赋了一个.__slots__列表之外的属性名会引发异常

  • 虽然有了.__slots__列表，但是实例对象的属性还是必须先赋值才存在

    .__slots__属性

  • 当有.__slots__列表存在时，默认会删除.__dict__属性，而getattr()，setattr() 以及dir()等函数均使用.__slots__属性，因此仍旧可以正常工作

    • 可以在.__slots__列表中添加.__dict__字符串， 因此对于使用.__dict__的地方均能正常工作

    .__slots__和 .__dict__

  • .__slots__属性的使用可以优化内存和读取速度

  • 在继承中:

    • 若子类继承自一个没有.__slots__的超类，则超类的.__dict__属性可用，则子类中的.__slots__ 没有意义。因为子类继承了超类的.__dict__属性

      .__slots__和 .__dict__

    • 若子类有.__slots__，超类也有.__slots__，子类的合法属性名为父类和子类的.__slots__列表的并集

      超类子类都有`.__slots__`

    • 若超类有.__slots__，子类未定义.__slots__，则子类将会有一个.__dict__属性

      超类有`.__slots__`子类没有

5.Python3的property机制：
property是一个对象，通过它给类变量名赋值。

  1.   class A:
  2.     age=property(getMethod,setMethod,delMethod,docMethod)
  3.                                      # 或者直接指定docstring
  4.     def getMethod(self):
  5.         pass
  6.     def setMethod(self,val):
  7.         pass
  8.     def delMethod(self):
  9.         pass
  10.     def docMethod(self):
  11.         ...
  12.         # return a string
  • property优点：代码简单，运行速度更快;缺点：当类编写时可能还无法确定property名字，因此无法提供动态的接口

  • 如果property的docstring或者docMethod为None，则Python使用getMethod的docstring。

    property

一个添加了语法糖的方案为：

  1.   class A:
  2.         def __init__(self):
  3.             self._x = None
  4.         @property #定义了一个property get函数，必选
  5.         def x(self): # property name 就是 get函数的函数名
  6.             """I'm the 'x' property."""
  7.             return self._x
  8.         @x.setter #定义了一个property set函数，可选
  9.         def x(self, value):
  10.             self._x = value
  11.         @x.deleter #定义了一个property del函数，可选
  12.         def x(self):
  13.             del self._x

6.Python类中有两种特殊的方法：staticmethod方法和classmethod方法

  • staticmethod方法：当以实例对象调用staticmethod方法时，Python并不会将实例对象传入作为参数；而普通的实例方法，通过实例对象调用时，Python将实例对象作为第一个参数传入

    • 定义staticmethod方法：

      1.   class A:
      2.       @staticmethod #定义一个staticmethod
      3.       def func(*args,**kwargs)
      4.           pass

  • classmethod方法：当以实例对象或者类对象调用classmethod方法时，Python将类对象（如果是实例对象调用，则提取该实例所属的类对象）传入函数的第一个参数cls中

    • 定义classmethod方法：

      1.   class A:
      2.       @classmethod #classmethod
      3.       def func(cls,*args,**kwargs)
      4.           pass

总结一下，类中可以定义四种方法：

  • 普通方法：方法就是类对象的一个属性，执行常规函数调用语义classname.method(args)
  • 实例方法：传入一个实例作为方法的第一个实参。调用时可以：
    • obj.method(args):通过实例调用
    • classname.method(obj,args)：通过类调用
  • staticmethod方法：* obj.method(args)通过实例调用时，执行的是classname.method(args)语义

  • classmethod方法：* obj.method(args)执行的是classname.method(classname,args)语义

    Python类中四种方法

7.类的实例方法中，用哪个实例调用的该方法，self就是指向那个实例对象
类的classmethod方法中，用哪个类调用该方法，cls就指向那个类对象

实例方法和类方法中的self、cls

8.类对象与实例对象都是可变对象，可以给类属性、实例属性进行赋值，这就是原地修改。这种行为会影响对它的多处引用
任何在类层次所作的修改都会反映到所有实例对象中

类对象与实例对象都是可变对象

9.若类的某个属性是可变对象（如列表、字典），则对它的修改会立即影响所有的实例对象

类属性为可变对象

10.多重继承中，超类在class语句首行内的顺序很重要。Python搜索继承树时总是根据超类的顺序，从左到右搜索超类。

多重继承超类定义顺序

11.类的.__mro__属性：类对象的.__mro__属性。它是一个tuple，里面存放的是类的实例方法名解析时需要查找的类。Python根据该元组中类的前后顺序进行查找。类对象的.__mro__列出了getattr()函数以及super()函数对实例方法名字解析时的类查找顺序。

类的 __mro__属性

  • 类的.__mro__是动态的，当继承层次改变时它也随之改变
  • 元类可以重写一个类的.mro()方法来定义该类的__.mro__属性。该方法在类被创建时调用，结果存放在类的.__mro__属性中

12.super()函数：super()返回一个super实例对象，它用于代理实例方法/类方法的执行

  • super(class,an_object)：要求isinstance(an_object,class)为真。代理执行了实例方法调用
  • super(class,class2)：要求 issubclass(class2,class)为真。代理执行了类方法调用

有两种特殊用法：

  • super(class)：返回一个非绑定的super对象
  • 在类的实例方法中，直接调用super()，等价于super(classname,self)（这里self可能是classname子类实例）
  • 在类的类方法中，直接调用super()，等价于super(classname,cls)（这里cls可能是classname子类）

原理：super的原理类似于：

  1. def super(cls,instance):
  2.     mro=instance.__class__.__mro__ #通过 instance生成 mro
  3.     return mro[mro.index(cls)+1] #查找cls在当前mro中的index,饭后返回cls的下一个元素

示例：

  1. class Root:
  2.     def method1(self):
  3.         print("this is Root")
  4. class B(Root):
  5.     def method1(self):
  6.         print("enter B")
  7.         print(self)
  8.         super(B,self).method1() #也可以简写为 super().method1()
  9.         print("leave B")
  10. class C(Root):
  11.     def method1(self):
  12.         print("enter C")
  13.         print(self)
  14.         super().method1() #也可以写成super(C,self).method1()
  15.         print("leave C")
  16. class D(B,C):
  17.     pass
  • 调用D().method1()—> D中没有method1
  • B中找到（查找规则：D.__mro__) —> 执行B中的method1。此时self为D实例。D.__mro__中，B的下一个是C，因此super(B,self）.method1()从类C中查找method1。
  • 执行C的method1。此时self为D实例。D.__mro__中，C的下一个是Root，因此super(C,self）.method1()从类Root中查找method1。
  • 执行Root的method1。

  • print(self)可以看到，这里的self全部为 D的实例

    类的classmethod依次类推

    类、实例的属性查找规则没有那么复杂。因为属性变量只是一个变量，它没办法调用super(...)函数。 只有实例方法和类方法有能力调用super(...)函数，才会导致这种规则诞生

    super()和self