Python深入类和对象-01

学习导图：

1.鸭子类型和多态

• 多态的是应用于Java和C#这一类强类型语言中，而Python崇“鸭子类型”’
• 动态语言调用实例方法时不检查类型，只要方法存在，参数正确，就可以调用。这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
• 所谓多态：定义时的类型和运行时的类型不一样，这时就称为多态。

2.抽象基类(abc模块)

• 抽象基类（abstract base class,ABC）：抽象基类就是类里定义了纯虚成员函数的类。纯虚函数只提供了接口，并没有具体实现。抽象基类不能被实例化(不能创建对象)，通常是作为基类供子类继承，子类中重写虚函数，实现具体的接口。
• 抽象基类就是定义各种方法而不做具体实现的类，任何继承自抽象基类的类必须实现这些方法，否则无法实例化。

应用场景：

• 判断某个对象的类型
• 我们需要强制某个子类必须实现某些方法

import abc
class CacheBase(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod
    def get(self,key):
        # raise ValueError
        pass
        #self.key=key
    @abc.abstractclassmethod
    def set(self,key,value):

        # raise NotADirectoryError
        pass
class RedisBase(CacheBase):
    #重写父类中的方法
    def get(self,key):
        pass
    def set(self,key,value):
        pass
r=RedisBase()
r.get('lizhe')

3.使用isinstance和type的区别

i = 1
s = 'a'
isinstance(i,int)   
isinstance(s,str)  
isinstance(s,int)  

类对象和对象变量

class A:
    aa = 1
    
    def __init__(self,x,y):
        self.x = x
        self.y = y

class A():
	pass
class B(A):
	pass
b=B()
print(isinstance(b,B))
print(isinstance(b,A))  #True考虑继承关系
print(type(b) is B)
##is 和 ==  区别
#== value
#is 判断的是内存地址id

4.类属性和实例属性以及查找顺序

MRO算法：
Python2.2之前的算法:金典类
DFS(deep first search)：A->B->D->C->E

Python2.2版本之后,引入了BFS(广度优先搜索)

BFS:A->B->C->D

在Python2.3之后,Python采用了C3算法

Python新式类继承的C3算法：https://www.cnblogs.com/blackmatrix/p/5644023.html

class D(object):
    pass
class B(D):
    pass
class  E():
    pass
class C(E):
    pass
class A(B,C):
    pass

print(A.__mro__)  #查看执行的顺序

5.Pyhton对象的自省机制

• 自省是通过一定的机制查询到对象的内部结构

• Python中比较常见的自省（introspection）机制(函数用法)有： dir()，type(), hasattr(), isinstance()，通过这些函数，我们能够在程序运行时得知对象的类型，判断对象是否存在某个属性，访问对象的属性。

class Person(object):
    name='lizhe'
class Student(Person):
    def __init__(self,school_name):
        self.school_name=school_name

user=Student('logic')
print(user.__dict__)
print(dir(user))
print(user.name)


a=[1,2,3,4]
# print(a.__dict__)  #会报错
print(dir(a))   #没有
print(list.__dict__)

6.super()函数

在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了，可通过使用 super 来实现

class A:
    def __init__(self):
        print('AAA')
class B(A):
    def __init__(self):
        print('BBBB')
        #super(B,self).__init__
        super().__init__()
b=B()


class Person(object):
    def __init__(self,name,age,weight):
        self.name=name
        self.age=age
        self.weight=weight
    def speak(self):
        print('%s 说：我%d岁了'%(self.name,self.age))
class Student(Person):
    def __init__(self,name,age,weight,grade):
        # self.name = name
        # self.age = age
        # self.weight = weight
        # super().__init__(name,age,weight,grade)
        Person.__init__(self,name,age,weight)
        self.grade=grade
    def speak(self):
        print('%s 说：我%d岁了  我在读第 %d 学期'%(self.name,self.age,self.grade))

s=Student('LOGIC',20,30,3)
s.speak()

class A:
    def __init__(self):
        print('AAAA')
        super().__init__()
class B(A):
    def __init__(self):
        print('BBBB')
        super().__init__()
class C(A):
    def __init__(self):
        print('CCCC')
        super().__init__()
class E:
    pass
class D(B,C):
    def __init__(self):
        print('D')
        super().__init__()
d=D()
print(D.__mro__)
#super调用父类中的方法   而是按照mro 算法来调用的
#深度 广度