继承
面向对象编程 (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) 魔术方法总结
| 方法 | 描述 |
|---|---|
__init__ |
构造方法 作为类的初始化 |
__del__ |
析构方法 在当前文件执行完毕之前去执行 或者有时候用del 对象名 触发 |
__str__ |
在打印对象的时候， 用于转换为人能够阅读的形式 |
__repr__ |
在打印对象的时候， 转换为解释器查看的形式 |
__add__ |
运算符重载 |
__getattr__ |
调用不存在的属性的时候会触发 |
__len__ |
返回集合中所含元素的数量 |
__getitem__ |
返回与所给键对应的值 |
__setitem__ |
按一定的方式存储和key相关的value |
网友评论