面向对象具有三大特性：继承，多态以及封装。
继承分为单继承和多继承：
单继承：
语法：父类，子类
继承与重用：
子类可以使用父类中的名字（变量和方法）
继承与派生：
子类在父类的基础上又新创建了自己想要的方法和属性
父类有的子类没有：子类对象直接调用就会直接执行父类的方法
父类有的子类也有：子类对象调用直接执行子类中的方法
想在子类中使用父类的名字：父类名.super() 去调用
规范的编程模式：
抽象类。
多继承：
语法：
接口：
新式类和经典类：
新式类：
-
-
- 所有的多继承关系寻找方法的顺序 ：遵循广度优先算法
- 继承object
- mro方法
- super：super不是单纯的找父类，而是遵循mro顺序
-
经典类：
-
-
- python2.x
- 不主动继承object
- 经典类在在父类中方法的过程中，遵循：深度优先
- 不提供mro方法和super
-
一、继承
继承与重用：父类中所有的属性和方法都可以被子类使用
class Foo:
def __init__(self):
self.func()
def func(self):
print('in Foo')
class Son(Foo):
def func(self):
print('in Son')
s1 = Son() # in Son
当子类中有要被调用的方法的时候，子类的对象会直接选择子类中的方法、变量。父类中的方法不会被自动执行。
如果既要执行子类的方法，也要执行父类的方法，那么需要在子类的方法中调用父类的方法。
父类名.方法名(self,...) super().方法名(...)
1 # class Foo: 2 # def __init__(self): 3 # self.func() 4 # def func(self): 5 # print('in Foo') 6 # 7 # class Son(Foo): 8 # def func(self): 9 # print('in Son') 10 # 11 # s1 = Son() # in Son 12 13 # class Foo: 14 # Country = 'China' 15 # def func(self): 16 # print(self.Country) 17 # 18 # class Son(Foo): 19 # Country = 'English' 20 # def func(self): # 走这个方法 21 # print(self.Country) 22 # 23 # s = Son() 24 # s.func() # English 25 26 # class Foo: 27 # Country = 'China' 28 # def func(self): # 走这个方法 29 # print(self.Country) 30 # 31 # class Son(Foo): 32 # Country = 'English' 33 # 34 # s = Son() 35 # s.func() # English 36 37 # class Foo: 38 # Country = 'China' 39 # def func(self): 40 # print(self.Country) 41 # 42 # class Son(Foo):pass 43 # 44 # s = Son() 45 # s.func() # 'China'
二、抽象类
规范
多人开发、复杂的需求、后期的扩展
手段 来帮助我们完成规范
抽象类
抽象类是一个规范，它基本不会实现什么具体的功能，抽象类是不能被实例化
要想写一个抽象类
from abc import ABCMeta,abstractmethod
在这个类创建的时候指定 metaclass = ABCMeta
在你希望子类实现的方法上加上一个 @abstractmethod装饰器
使用抽象类
继承这个类
必须实现这个类中被@abstractmethod装饰器装饰的方法
# 支付功能
from abc import ABCMeta, abstractclassmethod
class Payment(metaclass=ABCMeta):
@abstractclassmethod
def pay(self): pass
@abstractclassmethod
def shouqian(self): pass
class Alipay(Payment):
def pay(self, money):
print('使用支付宝支付了%s元' % money)
class Wechatpay(Payment):
def pay(self, money):
print('使用微信支付了%s元' % money)
class ApplePay(Payment):
def pay(self, money):
print('使用applepay支付了%s元' % money)
def pay(obj, money):
obj.pay(money)
p = Payment()
# a = Alipay()
# # a.pay(100)
# pay(a,100)
#
# we = Wechatpay()
# # we.pay(200)
# pay(we,200)
#
# ap = ApplePay()
三、多继承
class Animal:
def __init__(self, name):
self.name = name
class FlyAnimal(Animal):
def fly(self):
print('%s 在飞' % self.name)
class WalkAnimal(Animal):
def walk(self):
print('%s 在走路'% self.name)
class SwimAnimal(Animal):
def swim(self):
print('%s在游泳'%self.name)
class Tiger(SwimAnimal,WalkAnimal):
pass
class Swan(SwimAnimal,WalkAnimal,FlyAnimal):
pass
class Parrot(FlyAnimal,WalkAnimal):
def talk(self):
print('%s说话了'%self.name)
swan = Swan('天鹅')
swan.fly()
swan.walk()
四、接口类
# 接口 Interface 接口可以被多继承
# Interface FlyAnimal: # 规范继承我的类必须实现这个方法
# def fly():pass
# Interface WalkAnimal:
# def walk():pass
# Interface SwimAnimal:
# def swim():pass
# class Tiger(WalkAnimal,SwimAnimal): 继承了一个规范
# def walk():代码
# def swim():代码
# 抽象类
# 接口
五、新式类与经典类
新式类 在python3.x版本中 所有的类都是新式类 所有的新式类都有一个默认的父类 ： object class Person1:pass class Person2():pass class Person3(object):pass # p = Person2() # __init__ 初始化方法 print(Person1.__bases__) print(Person2.__bases__) print(Person3.__bases__) python 2.7 经典类 和 新式类 并存 class Student:pass # 经典类 class Student(object):pass 继承了object的类就是新式类 在py3中所有的类都是新式类 在py2中既有新式类又有经典类
区别：
新式类中
所有的多继承关系寻找方法的顺序 - 遵循广度优先算法
继承object
mro方法
super : super不是单纯的找父类，而是遵循mro顺序的
经典类
python2.x
不主动继承object
经典类在找父类中方法的过程中 遵循 —— 深度优先
不提供mro方法和super
class A: def func(self): print('A') class B(A): def func(self): print('B') class C(A): def func(self): print('C') class D(B, C): def func(self): print('D') class E(B, C): def func(self): print('E') class F(D, E): def func(self): print('F') F().func() # 新式类 F-->D-->E-->B-->C-->A 经典类：F-->D-->B-->A-->E-->C print(F.mro())