oop三大特征之多态

1.多态的概念

　　多个不同类对象可以响应同一个方法，进而产生不一样的结果，也可以理解为多个不同的对象有着相同的使用方法。多态不是一种语法，而是一种状态，特征。其优点是对于使用者而言，大大的降低了使用难度，我们之前写的USB接口下的鼠标，键盘，移动硬盘都属于多态。一般通过鸭子类型来实现多态。

class Cat:
    def talk(self):
        print('ccc')

class Pig:
    def talk(self):
        print("ppp")

class Dog:
    def talk(self):
        print('ddd')

c = Cat()       #类所对应的的对象
d = Dog()
p = Pig()

def speak(obj):     #调取类里面的talk函数
    obj.talk()

speak(c )   # >>>:ccc
speak(d)    # >>>:ddd
speak(p )   # >>>:ppp

2.多种应用

1）.isinstance

　　判断一个对象是否是某个类的实例，参数1表示要判断的对象，参数2 表示要判断的类型。

2）.issubclass.

　　判断一个类是否为另一个类的子类，参数1便是子类，参数2表示父类。

3）.str.

　　执行时机：对象在被转换为字符串时，转换出来 的结果就是这个函数的返回值。

　　使用场景：我们可以利用该函数来定义对象的打印格式

4）.del

　　执行时机：手动删除对象时立马执行，或是程序运行结束时也会自动执行。

　　使用场景：当你的对象在使用过程中，打开了不属于解释器的资源

class FileTool:
    def __init__(self,path):
        self.file = open(path,'rt',encoding='utf-8')
        self.a = 100
    def read(self):
        return self.file.read()
tool = FileTool("a.txt")
print(tool.read())

5）.call

　　执行时机：在调用对象时自动实行。

6）.slots.

　　该属性是一个类属性，用于优化对象内存占用。优化的原理是将原本不固定的属性数量变得固定了，然后解释器就不再为这个对象创建名称空间，因此__dict__也就没了，从而达到减少内存开销的结果。另外当类中出现了slots时也会导致这个类的对象无法再添加新的属性。

class Person:
    # __slots__ = ['name']
    def __init__(self,name):
        self.name = name
p = Person("jack")

print(sys.getsizeof(p))

sys
print(p.__dict__) #__slots__一出现，字典自动关闭

7）.getattr ,setattr , delattr

getattr 
    当用点访问属性时，如果属性不存在时执行
setattr 
    用点设置属性时
delattr  
    用del 对象.属性  删除属性时执行

 

　　这几个函数反应了python解释器是如何实现用点来访问属性。

　　getattribute  该函数也是用来获取属性。在获取属性时如果存在getattribute则先执行该函数，如果没有拿到属性则继续调用getattr函数，如果拿到了则直接返回

8.[ ]的实现原理

　　任何的符号，都会被解释器解释成特殊含义，例如[],()

9）.getitem  setitem  delitem

getitem  
    当你用综括号去获取属性时执行

setitem 
    当你用综括号去设置属性时执行

delitem  
    当你用括号去删除属性时执行

 

10）.运算符重载

　　当我们在使用某个符号时，python解释器都会为这个符号定义一个含义，同时调用对应的处理函数，当我们需要自定义对象的比较规则时，就可以子类中覆盖 大于，等于，等一系列方法。

class Student(object):
    def __init__(self,name,height,age):
        self.name = name
        self.height = height
        self.age = age

    def __gt__(self,other):
        # print('__gt__')
        # print(self)     #和stu1的地址一致
        # print(other)    #和stu1的地址一致
        # print(other)
        return self.height > other.height # 这个函数的比较值决定函数的返回值

    def __lt__(self,other):
        return self.height < other.height

    def __eq__(self,other):
        if  (self.height == other.height and
             self.name == other.name and
             self.age == other.age
                ):
            return True
        return False

stu1 = Student('jack',182,20)  #创建对象
stu2 = Student('li',168,20)
print(stu1 > stu2)    #>>>:True
print(stu1 < stu2)     #>>>:False
print(stu1 == stu2)    #>>>:False

11).迭代器协议

　　迭代器是指具有__ter__和__next__的对象，我们可以为对象增加这两个方法来让对象变成一个迭代器。

class My_range:
    def __init__(self,start,end,step):
        self.start = start
        self.end = end
        self.step = step

    def __iter__(self):#生成迭代对象时调用，返回值必须是对象自己,然后for可以循环调用next方法
        return self

    def __next__(self):    #每一次for循环都调用该方法
        a = self.start
        self.start += self.step
        if a < self.end:
            return  a
        else:
            raise StopIteration    #终止循环

for i in My_range(1,10,2):
    print(i)