继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指：可以使用现有类的所有功能，并无需重新编写原来的类的情况下对这些功能进行扩展。
面向对象编程代码的最大好处就是代码的重用，实现代码重用典型的操作就是代码的继承，其中被继承的类叫做父类(基类)或超类，继承的类称之为子类。
注：所有的类都继承自一个object类

(1) 类的单一继承

class 类名(被继承的类名):
      pass

实例：

class A:
    def speak(self):
        print('我是父类')
# 定义子类
class B(A):
    def Bspeak(self):
        print('我是子类')
b = B()
b.speak()  # 我是父类 --- 调用继承的A类的方法
b.Bspeak()  # 我是子类   --- 调用B类的方法

## 带构造方法的继承
class A:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def speak(self):
        print('我是父类,name=%s，age=%d' % (self.name, self.age))
# 定义子类
class B(A):
    def __init__(self, name, age, sex):  # 不写构造方法会报错
        A.__init__(self, name, age)  # 继承父类的构造方法,需要手动调用
        # super(B,self).__init__(name,age)  # 同上,推荐的写法
        self.sex = sex    # 定义类的本身属性
b = B('张三', 18, '男') # 如果子类没有重写父类的init的方法，会自动调用父类的init的方法， 如果不传递参数,对类进行初始化, 会保错
b.speak()  # 我是父类,name=张三，age=18----调用父类的方法

## 子类对父类方法的重写
class A:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def speak(self):
        print('我是父类,name=%s，age=%d' % (self.name, self.age))
# 定义子类
class B(A):
    def __init__(self, name, age, sex):  # 不写构造方法会报错
        super(B,self).__init__(name,age) # 继承父类的构造方法
        self.sex = sex    # 定义类的本身属性
    def speak(self):
        print('我是子类,name=%s，age=%d，sex=%s' % (self.name, self.age, self.sex))
b = B('张三', 18, '男')
b.speak()  # 我是子类,name=张三，age=18，sex=男----- 由于子类重写了speak方法, 因此调用的时候子类会调用重写后的方法.

注意：
1> 类的单一继承, 子类会继承父类私有以外的属性和方法
2>如果在子类里存在和父类同名的属性和方法叫做方法或属性的重写,子类对象会调用子类的方法或属性
3>在子类里调用父类的方法, 可以通过类名.方法名(self,[参数..]) self代表当前类的实例化对象
4>基类的构造__init__()方法不会被自动调用, 需要在其派生类的构造中手动调用

使用类名.__init__()和使用super()的比较：

• 在单一继承,使用类名.__init__()和使用super()几乎没有区别
• 在多重继承中, 使用类名.__init__(),除了修改代码修改继承类名时很不爽,还有可能会造成公共父类多次被调用；使用super(),它会把当前的类返回一个父类的对象,注意你在体系中使用了super()那么所有的地方都要使用super(),否则可能造成父类多次被调用或者不能调用所有的父类方法,super()保证所有父类只会执行一次, 因此推荐使用super()

(2) 类的多重继承

在Python中的解决多重继承方案是MRO即Method Resolution Order，方法解析顺序，主要是通过super方法实现的。

class 类名(继承的父类1,继承的父类2, [,父类3..]):
    pass

实例：

class A:
    def speak(self):
        print('我是A类的speak方法')
    def a(self):
        print('a')
class B:
    def speak(self):
        print('我是B类的speak方法')
    def b(self):
        print('b')
class C(A,B):  # 继承A和B类
    def speak(self):
        super(C, self).speak()  # 打印我是A类的speak方法 ---  即调用父类的speak方法,
        print('我是C类的speak方法')
c = C()
c.speak()   # 打印A类speak方法和C类speak方法
c.a()  # ok 调用父类的方法
c.b()  # ok

注意：
super函数与父类的继承顺序有关，会从继承顺序中从左向右依次查找是否有speak方法，如果找到会调用第一个speak方法。

(3) 类的私有属性和私有方法

在默认情况下，Python中没有类似public、private等关键词来修饰成员函数和成员变量。而且其实，Python并没有真正的私有化支持，对于私有属性(方法)还是可以在外部获取到，下面我们会学到，首先看一些简单的概念。
类的私有属性
__属性名：两个下划线开头，可以声明该属性为私有，私有属性不能在类的外部被使用或直接访问，在类内部的方法中使用时 self.__属性名。
类的私有方法
__方法名：两个下划线开头，声明该方法为私有方法，不能在类地外部调用，在类的内部调用 self.__方法名。
实例：

class A:
    __name = '私有类型的变量'
   def fun(self):
        print(self.__name)
a = A()
print(a.__name)  # error 找不到，只能允许这个类本身进行访问了，连子类也不可以使用
a.fun()  # ok 打印私有类型的变量 --- 可以调用

# 私有方法
class A:
      __name = '私有类型的变量'
      def func(self):
          print('我是一个公有的方法')
          self.__demo()
       def __demo(self):
           print('我是一个私有的方法')   
a = A()
a.func()  # 方法调用 打印我是一个公有的方法，我是一个私有的方法
a.__demo()  # error 找不到该方法, 其实在python中的私有化，是通过在类的内部将我们定义的【__私有属性】和【__私有方法】的名字替换成为【_类名__名字】，因此，当我们在外部访问【__名字】的时候就会提示找不到相应的变量。 
print(A.__dict__)  # 将类的所有属性以字典的形式打印出来{..., '_A__name': '私有类型的变量', '_A__demo': <function A.__demo at 0x00xxx>...} 可以看到只是将名字改为_类名__名字(注：类名前面一个下划线，后面是两个下划线)
print(A._A__name)  # ok 私有类型的变量 --还是可以访问的, 因此说python并没有真正的私有化支持。

# 如果对象在外部定义【__名字】的变量呢？
class A(object):
    __name = '张三'        
    def func(self):
        print(self.__name)
a = A()
a.__name = '李四'
a.func()  # 会打印私有的__name即张三

# 如果将类内部的私有属性注释会打印什么？
class A(object):
    # __name = '张三'        # 注释这行
    def func(self):
        print(self.__name)
a = A()
a.__name = '李四'
a.func()  # 报错 提示找不到 '_A__name', 所以如果在类的内部使用【__变量名】，只会找类的私有属性，类外部定义的属性，为对象的普通属性。

总结：

• 在python中的私有变量和私有方法仍然是可以访问的:
  私有变量:实例._类名__变量名
私有方法:实例._类名__方法名()

(4) 魔术方法总结