面向对象+super函数的妙用？

关于创建类和引用类属性以及实例化

类变量：类内类方法外，公用可继承
局部变量：定义在方法中的变量，只作用于当前实例的类。
```
class MyClass:
  """一个简单的类实例"""
  i = 12345
  def f(self):
      return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
```
构造方法
init
关于参数，实例：
```
class Complex:
  def __init__(self, realpart, imagpart):
      self.r = realpart
      self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5
```
self代表类的实例而非类。类的方法与普通的函数只有一个特别的区别，他们必须有一个额外的第一参数的名称，按照惯例他的名称是self。
self代表类的实例，代表当前对象的地址，而self.class则指向类,类似C++的this指针，但又不完全相同。
self的名字并不是唯一的，可以换成其他名称

类的方法

用def定义

def fun(var):

继承

class son(f1,f2,f3)
    pass

需要注意括号中父类的顺序，当父类之间存在命名相同的方法，而子类中没有执行，则会从左至右搜索父类是否包含。
基类名必须与派生类定义在一个作用域内，除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用。
下面也包含了如何覆盖父类的构造

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

多继承

实例：

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

##多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

注意其中派生类构造方法的写法。

方法重写

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

注意与重载父类的构造函数方式不同。

类属性与方法

类的私有属性

_private_attrs:两个下划线开头，说明该属性为私有，不能再类的外部被直接使用或直接访问。在类内部的方法中使用时self._private_attrs.

类的方法

在类的内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数，self代表的是类的实例

类的私有方法

_private_method:两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能再类的外部调用。self._private_method

类的专有方法

init:构造函数，在生成对象时调用
del:析构函数，释放对象时使用
repr:打印，转化
setitem:按照索引赋值
getitem:按照索引获取值
len：获取长度
cmp:比较运算
call:函数调用
add:加运算
sub:减运算
mul:乘运算
truediv:除运算
mod:求余运算
pow:乘方
str:将对象可视化的体现出来，优先级最高，默认打印的对象的地址

运算符重载

实例：

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)

   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

关于以上实例有可以精简的部分

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
#可以写作
#class Vector:
#    def __int__(self,a,b):
#        x:int
#        y:int

类中的静态方法，普通方法，类方法

静态方法用@staticmethod装饰的不太self参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。
普通方法默认有个self参数，且只能被对象调用
类方法默认有个cls参数，可以被类对象调用，需要加上@classmethod装饰

class Classname:
    @staticmethod
    def fun():
        print('静态方法')

    @classmethod
    def a(cls):
        print('类方法')

    # 普通方法
    def b(self):
        print('普通方法')

Classname.fun()
Classname.a()
C = Classname()

C.fun()
C.a()
C.b()

super函数的妙用？