面向对象的三大特征

面向对象的三大特征

1. 封装
2. 继承
3. 多态

• super和mor的使用
• 派生

封装

封装指的就是把数据与功能都整合到一起，听起来是不是很熟悉，没错，我们之前所说的”整合“二字其实就是封装的通俗说法。
    
    什么是封装
在程序设计中，封装（Encapsulation）是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。

要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。

为什么要封装
封装数据的主要原因是：保护隐私（把不想别人知道的东西封装起来）

继承

什么是继承?

	  继承就是一种新建类的方式, 新建出来的类我们称为是'子类或者叫派生类'，被继承的类我们称为是'父类或者是基类'
      当然出来的类子类可以遗传父类的所有属性

为什么要用继承?

	  类解决了什么问题: 对象与对象之间的代码冗余问题
       继承解决了什么问题：类与类之间的代码冗余问题

怎么使用继承?

	 经典类：没有继承object类的子子孙孙类都是经典类
      新式类：继承了object类的子子孙孙类都是新式类
     """
     	再有在Python2中才区分经典类和新式类，如果是Python3的版本，所有的类都是新式类，也就是说在Python3中默认的类都是继承了object类，在Python3中没有了经典类和新式类的说法了.
     """

继承原理:

python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

查找顺序:

1.由对象发起的属性查找，会从对象自身的属性里检索，没有则会按照对象的类.mro()规定的顺序依次找下去，
2.由类发起的属性查找，会按照当前类.mro()规定的顺序依次找下去，

单继承

 class Parent1:
    pass


class Parent2(object):
    pass
class Sub1(Parent1):
    pass
"Sub1类继承了Parent1的类，Sub1就称为是子类，Parent1类就称为是父类或者叫基类"""
单继承：一个类只继承了一个类

单继承下的属性查找

单继承下的属性查找：先从对象自己名称空间中查找，然后去产生这个对象的类中查找，最后去继承的父类中查找.
#单继承
class Test1:
    def __f1(self):
        print('test.f1')
    def f2(self):
        print('test.f2')
        self.__f1()
class Test2(Test1):
    def __f1(self):
        print('Test.f1')

ser=Test2()
ser.f2()
test.f2
test.f1

##########
#单继承
class Test1:
    def f1(self):
        print('test.f1')
    def f2(self):
        print('test.f2')
        self.f1()
class Test2(Test1):
    def f1(self):
        print('Test.f1')

ser=Test2()
ser.f2()
test.f2
Test.f1

多继承

 class Parent1:
    pass


class Parent2(object):
    pass
class Sub2(Parent1, Parent2):
    pass
   
多继承的类: Sub2就是子类，Parent1和Parent2都是父类
一个类继承了两个或者两个以上的类就是多继承了
#多继承的优点：
一个类继承了多个父类
缺点：
1.多继承违背了人的思维习惯
2.多继承让代码的可读性差
如果必须要用多继承，应该用Mixins

多继承下的属性查找

多继承下分菱形查找和非菱形查找

菱形查找

经典类：按照深度优先的查找顺序

经典类：按照深度优先的查找顺序
 # 在python2中，未继承object的类及其子类，都是经典类
    
class G: # 在python2中，未继承object的类及其子类，都是经典类
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->G->C->F->D->object
# 可依次注释上述类中的方法test来进行验证,注意请在python2.x中进行测试

新式类：按照广度优先查找

"""python3中都是新式类，都是广度优先查询"""
class G(object):
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->C->F->D->G->object
# 可依次注释上述类中的方法test来进行验证

非菱形

class E:
    def test(self):
        print('from E')

class F:
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D:
    def test(self):
        print('from D')

class A(B, C, D):
    # def test(self):
    #     print('from A')
    pass


print(A.mro())
'''
[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.D'>, <class 'object'>]
'''

obj = A()
obj.test() # 结果为：from B
# 可依次注释上述类中的方法test来进行验证

super和mor的使用

class popro:#父类
    star='earth'
    def __init__(self,name,age,gander):
        self.name=name
        self.age=age
        self.gender=gander
class Chinses(popro):
    nation='China'
    def __init__(self,name,age,gander,rmb):
        super().__init__(name,age,gander)
        self.rmd=rmb
    def speak_english(self):
        print(f'{self.name}有多少{self.rmd}人民币')
str=Chinses('qwe',12,'男','1233')
str.speak_english()

class A:
    def test(self):
        super().test()


class B:
    def test(self):
        print('from B')


class C(A, B):
    pass

"""mro列表是通过一个C3算法得出来的，我们无需明白底层原理，只需要知道每个类的mro列表到底是什么，然后按照这个列表去查找就行"""
# 在打印mro列表的时候，一定是从起始类开始
# c = C()
# c.test()
# print(C.mro()) # [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
# print(C.__mro__)

"""mro列表，每个类都有自己的mro列表，怎么查看类的mro列表"""
a = A()
# a.test()
print(A.mro()) # (<class '__main__.A'>, <class 'object'>)
print(A.__mro__)

多态

什么是多态?
	同一种事物的多种形态
    
import abc # abstract class 抽象类   具体的Specific

class Animal(metaclass=abc.ABCMeta): # 把animal类变成了抽象类
    """父类中得方法不是为了实现逻辑的，实现功能的，而是单纯的为了限制子类的行为"""
    @abc.abstractmethod # 把抽象类中得方法变成抽象方法， 它不实现具体的功能，就是单纯的为了限制子类中的方法
    def speak(self):
        pass
    @abc.abstractmethod
    def jiao(self):
        pass


"""抽象类和普通类有什么区别? 抽象类只能够被继承、不能够被实例化"""

# Animal() # Can't instantiate abstract class Animal with abstract methods speak

鸭子类型

"""鸭子类型就是更多的关注的是对象的行为，而不是对象的类型"""

class People(Animal):
    def speak(self):pass
        # print('from People.speak')
    def jiao(self):
        pass

class Dog(Animal):
    def speak(self):
        pass


class Pig(Animal):
    def speak(self):
        pass

"""多态带来的特性：在不考虑对象类型的情况下，直接调用对象的方法或者属性"""
def animal(obj):
    return obj.speak()

animal(obj)
animal(obj1)
animal(obj2)

"""面试题：请举出Python中使用多态的例子：len"""

len('hello')
len([1,2,3,4])
len((1,2,3,4))


def len(obj):
    return obj.__len__
len('helloworld')
len([1,2,3,4])
len((1,2,3,4))

派生

派生：子类可以派生出自己新的属性，在进行属性查找时，子类中的属性名会优先于父类被查找

class popro:#父类
    star='earth'
    def __init__(self,name,age,gander):
        self.name=name
        self.age=age
        self.gender=gander
class Chinses(popro):
    nation='China'
    def __init__(self,name,age,gander,rmb):
        popro.__init__(self,name,age,gander)
        self.rmd=rmb
    def speak_english(self):
        print(f'{self.name}有多少{self.rmd}人民币')
str=Chinses('qwe',12,'男','1233')
str.speak_english()

调用super()会得到一个特殊的对象，该对象专门用来引用父类的属性，且严格按照MRO规定的顺序向后查找
class popro:#父类
    star='earth'
    def __init__(self,name,age,gander):
        self.name=name
        self.age=age
        self.gender=gander
class Chinses(popro):
    nation='China'
    def __init__(self,name,age,gander,rmb):
        super().__init__(name,age,gander)
        self.rmd=rmb
    def speak_english(self):
        print(f'{self.name}有多少{self.rmd}人民币')
str=Chinses('qwe',12,'男','1233')
str.speak_english()

这两种方式的区别是：方式一是跟继承没有关系的，而方式二的super()是依赖于继承的，并且即使没有直接继承关系，super()仍然会按照MRO继续往后查找
关于在子类中重用父类功能的这两种方式，使用任何一种都可以，但是在最新的代码中还是推荐使用super()