面向对象之多态以及进阶

一.多态

1.什么是多态？

多态是一种事物具备多种不同的形态

官方解释：多个不同类对象可以响应同一个方法，产生不同的结果

2.多态的好处：

　　对于使用者而言，大大的降低了使用难度

3.怎么实现多态：

python中处处都是多态，例如：接口，抽象类，鸭子类型，都可以写出具备多态的代码，其中最简单的就是鸭子类型。

案例：

class Ji:
    def bark(self):
        print('咯咯咯..')
   
class Duck:
    def bark(self):
        print('嘎嘎嘎...')

class E:
    def bark(self):
        print('鹅鹅鹅...')
j = Ji()
y = Duck()
e = E()

def manage(obj):
    obj.bark()
manage(j)
manage(y)
manage(e)

二.进阶部分

1.isinstance

　判断一个对象是否是某个类的实例

class A:
    pass
a = A()
isinstance(a,A)

 参数1：要判断的对象

参数2：要判断的类型

2.issubclass

　判断一个类是否是另一个类的子类

class A:
    pass

class B(A):
    pass
issubclass(B,A)

　　参数1：是子类

　　参数2：是父类

3.__str__

在对象被转换为字符串时，转换的结果就是这个函数的返回值

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

class B:

    def __str__(self):
        return '是一个对象'
b = B()
print(b)
#是一个对象

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()

    def __del__(self):
            self.file.close()

tool = FileTool('a.txt')
print(tool.read())

5.__call__

执行时机：在调用对象时自动执行（就是对象加括号时）

class A:
    def __call__(self,*args,**kwargs):
            print("call run")
            print(args)
            print(kwargs)

a = A()
a(1,a=100)

6.__slots__

这是一个类属性，用于优化对象内存占用

优化的原理：将原本不固定的属性数量，变得固定了

这样的解释器就不会为这个对象创建名称空间，所以__dict__也没了

从而达到减少内存开销的效果

另外当类中出现了slots时将导致这个类的对象无法在添加新的属性

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

#查看内存的占用
print(sys.getsizeof(p))
p.age = 20  #无法添加，因为已经被限制死了，只有一个name属性
print(p.__dict__) #此时的dict也没有了

7.点方法  getattr setattr delattr

getattr 用点访问属性的时候如果属性不存在时执行

setattr 用点设置属性时执行

delattr 用del 对象.属性 时 删除属性时执行

class A:

    def __getattr__(self, item):
        print('__getattr__')

    def __setattr__(self, key, value):
        print('__setattr__')

    def __delattr__(self, item):
        print('__delattr__')

a = A()
a.age = 16
print(a.age)
del a.age
#执行结果：
#__setattr__
#__getattr__
#None
#__delattr__

class A:

    def __getattr__(self, item):
        print('__getattr__')
        return self.item

    def __setattr__(self, key, value):
        print('__setattr__')
        self.__dict__[key] = value

    def __delattr__(self, item):
        print('__delattr__')
        self.__dict__.pop(item)

a = A()
a.age = 16
print(a.__dict__)
del a.age
print(a.__dict__)
#执行结果：
#__setattr__
#{'age': 16}
#__delattr__
#{}

getattribute 该函数也是用来获取属性

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

8.[]的实现原理 getitem setiteem delitem

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

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

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

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

class A:
    def __getitem__(self,item):
        print('__getitem__')
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print('__setitem__')
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('__delitem__')
        self.__dict__.pop(key)

a = A()
a['name'] = 'jack'
print(a['name'])
print(a.__dict__)
del a['name']
print(a.__dict__)
#执行结果：
__setitem__
__getitem__
jack
{'name': 'jack'}
__delitem
{}

9.运算符重载

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

案例：

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

    def __gt__(self, other):
        return self.height>other.height

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

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

stu1 = Student("jack",180,28)
stu2 = Student("jack",180,28)
print(stu1 < stu2)
print(stu1 == stu2)

10.迭代器协议

迭代器是指具有__iter__和__next__的对象

我们可以为对象增加这两个方法来让对象变成一个迭代器

class MyRange:

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

    def __iter__(self):
        return self

    def __next__(self):
        a = self.start
        self.start += self.step
        if a < self.end:
            return a
        else:
            raise StopIteration
            
for i in MyRange(1,10,2):
    print(i)

11.上下文管理

在python中，上下文可以理解为是一个代码区间，一个范围，例如with open 打开的文件尽在这个上下文中有效

涉及到两个方法：

　　enter

　　　　表示进入上下文,(进入某个场景了)

　　exit

　　　　表示退出上下文，(退出某个场景)

class MyOpen(object):


    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.file = open(self.path)
        print("enter.....")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("exit...")
        # print(exc_type,exc_val,exc_tb)
        self.file.close()
        return True


with MyOpen("a.txt") as m:
    # print(m)
    # print(m.file.read())
    "123"+1

# m.file.read()

当执行with语句时，会先执行enter

当代码执行完毕后执行exit，或者代码遇到了异常会立即执行exit，并传入错误信息，包含错误的类型，错误的信息，错误的追踪信息

注意：

　　enter函数应该返回对象自己

　　exit函数可以有返回值，是一个bool类型，用于表示异常是否被处理，仅在上下文中出现异常有用，如果为True,则意味着异常已经被处理了  如果为 False 异常未被处理，程序将终端报错