面向对象的三大特性
封装：继承：多态：
封装
对象的属性：封装目的
1.对象的属性值一般都来源于外界，外界是有权力再次访问的
2.封装的目的不是让外界无法访问，而且不让其直接访问，可以在完成安全处理后再访问
3.如何做到外界还是通过变量名来对属性进行取值赋值，但是是走的方法间接拿到的值
封装: 对外隐藏类中一些属性与方法的实现细节
优点：外界不能直接访问，让内部的属性与方法具有安全保障
class A:
# 类的属性：__开头的属性，在外界不能通过 cord | __cord 直接访问：对外隐藏了
__cord = '01012300'
# 类的方法：__开头的方法，在外界不能通过 get_money | __get_money 直接访问：对外隐藏了
@classmethod
def __get_money(cls):
print('输入密码，取出100w零花钱')
# 对象的方法：一般的实现需求都是，这些方法只在内部使用
def __test(self):
pass
# __money被封装，外界还是可以通过 对象.money 取值赋值
def __init__(self, money)
self.__money = money
# 取值
@property # 在外界可以 对象.money 进行取值
def money(self):
# print('走方法拿到的money')
return self.__money
# 赋值
@money.setter # 在外界可以 对象.money = 新值 进行赋值
def money(self, money):
self.__money = money
# 删除
@money.deleter
def money(self):
del self.__money
继承
抽离：先定义子类，由子类的共性抽离出父类
派生：父类已经创建，通过父类再去派生子类
单继承：一个类只继承一个父类
抽离：先有多个有共同点的类，抽离出共性形成的类 => 父类
派生：通过已有的父类，再去定义该类的子类，这种方式就叫做派生
继承：继承是一种关系，子类可以通过父类获取属性和方法，能获取的根据就是继承
继承的语法：
# class 父类名:pass
# class 子类名(父类名): pass
class Sup:
pass
class Sub(Sup):
pass
继承的规则
1.父类的所有未封装的属性和方法，子类都能访问
2.父类的所有封装的属性和方法，子类都不能访问
-- 在外界通过子类或子类对象，不能访问
-- 在子类内部通过子类或子类对象也不能访问
class Sup:
__num = 10 # 封装被更名为_Sup__num
class Sub(Sup):
def test(self):
print(self.__num) # 本质去访问_Sub__num，所以不能访问
继承父类的方法：子类没有明文书写父类的方法，通过继承关系拿到
class Sup:
def test(self):
print(self) # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象
class Sub(Sup):
pass
Sub().test()
重写父类的方法：子类明文书写父类同名的方法，并且实现体自定义
class Sup:
def test(self):
print(self) # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象
class Sub(Sup):
def test(self):
print('自己的方法', self)
Sub().test()
重用父类的方法：子类明文书写父类同名的方法，有自己的实现体，但也用父类原有的功能
class Sup:
def test(self):
print(self) # 父类对象调用就是父类对象，子类对象调用就是当前调用的子类对象
class Sub(Sup):
def test(self):
super().test() # 本质 super(Sub, self).test() py2必须这么写
print('自己的方法', self)
Sub().test()
super关键字
重点：super() 可以得到调用父级功能的对象，调用者还是子类对象
– super()只能在子类的方法中使用
– super()本质 super(子类类名, 当前对象)
– super().父类普通方法 | super().__ init __ () | super()能调用父类所有可继承方法
class Sup:
def __init__(self, name):
self.name = name
def test(self):
print(self)
class Sub(Sup):
# 默认父级的__init__可以被继承过来，
# 但是会出现子类对象的属性比父类多
def __init__(self, name, salary):
super().__init__(name) # 父级有的共性功能通过super()交给父级做
self.salary = salary # 子类特有的自己来完成
# 有继承关系下，只要名字相同，即使参数不同，还是属于同一个方法
def test(self, num):
super().test() # 使用父级的方法
print(num)
外界通过Sub对象来调用test方法，一定找自己的test方法(属性的查找顺序)
多继承
复杂继承：一个类可以继承多个类，查找顺序是根据继承父类从左往右的顺序，并且在查找第一个父类时，将父类的父类也进行查找(一个父类分支全部查找完毕才去查找下一个父类分支)
属性的查找顺序：优先找自己的，如果没有，按照继承先后查找父级
class A:
name = 'A'
num = 10
class B:
name = 'B'
count = 100
子类可以继承所有父类的所有可继承属性
class C(A, B): # 自己 => A => B
# name = 'C'
pass
class A:
def f1(self):
print('A.f1')
有super()时，虽然没有继承关系，但是要按照C.mro()的查找顺序来查找对象
super().f2()
class B:
def f2(self):
print('B.f2')
class C(A,B):
def f2(self):
print('c.f2')
obj = C()
print(C.mro())
obj.f1()
'''
输出：
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
A.f1
B.f2
'''
复杂多继承
class A:
name = "A"
class B(A):
name = "B"
class C:
name = "C"
class D(C):
name = "D"
class E(B, D): # 先将B的所有父级们找完再找D的分支
name = "E"
print(E.mro()) # E => B => A => D => C
菱形继承
经典类：python2中才有，没有继承任何类的类 - 深度优先
深度优先，在查找第一个分支是就将菱形的头查找了
新式类：python2中直接或间接继承object的类，python中所定义的所有类 - 广度优先
广度优先，菱形的头在所有分支查找接收后再被查找
1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
3.在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
3.在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类
前提：父类中有共有属性或方法，子类没有自己去定义这些属性和方法，必须从父类中获取，到底从哪个父类中获取
-- 经典类：深度查找 a -> b -> d -> c
-- 新式类：广度优先 a -> b -> c -> d
d
b c
a
多态
多态：对象的多种状态 - 父类对象的多种(子类对象)状态
import abc
class People(metaclass=abc.ABCMeta):
def __init__(self, name):
self.name = name
@abc.abstractmethod
def speak(self): pass
class Chinese(People):
def speak(self):
print('说中国话')
class England(People):
def speak(self):
print('说英国话')
if __name__ == '__main__':
多态的体现：功能或是需求，需要父类的对象，可以传入父类对象或任意子类对象
注：一般都是规定需要父类对象，传入子类对象
def ask_someone(obj):
print('让%s上台演讲' % obj.name) # 父类提供，自己直接继承
obj.speak() # 父类提供，只不过子类重写了
ch = Chinese('王大锤')
en = England('Tom')
# 传入Chinese | England均可以，因为都是People的一种状态(体现方式)
ask_someone(ch)
ask_someone(en)
# 传入str不可以，因为str的对象没有name和speak
# s = str('白骨精')
# ask_someone(s)
# p = People('kkk')
鸭子类型
1.先规定：有什么属性及什么方法的类的类型叫鸭子类型
2.这些类实例化出的对象，都称之为鸭子，都可以作为需求对象的一种具体体现
需求：需要一个对象，该对象有name属性及speak方法，就可以作为一种状态的体现被传入
def ask_someone(obj):
print('让%s上台演讲' % obj.name)
obj.speak()
class A:
能有自己特有的属性和方法，可以和B完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型
def __init__(self, name):
self.name = name
def speak(self):
print('说AAAA')
class B:
能有自己特有的属性和方法，可以和A完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型
def __init__(self, name):
self.name = name
def speak(self):
print('说BBBB')
ask_someone(B('B'))