多态

多态

概念
一种事物具备多种不同的形态 例如 水 固态 液态 气态 离子态
大黄蜂 汽车人 汽车
官方解释 多个不同对象可以响应同一个方法 产生不同的结果
首先强调多态不是一种特殊的语法 而是一种状态 特性(既多个不同对象可以响应同一个方法 产生不同的结果)
多个对象有相同的使用方法
好处 对于使用者而言 大大降低了使用难度
我们之前写的USB接口下的鼠标,键盘就属于多态

接口 抽象类 鸭子类型 都可以写出具备多态的代码 最简单就是鸭子类型

多态的实现

python中多态的体现

a = 10
b = '10'
c = [10]

print(type(a))
print(type(b))
print(type(c))

动物管理系统(案例)

class Ji:
    def bark(self):
        print('咯咯咯')
    def spawn(self):
        print('下鸡蛋')
class Duck:
    def bark(self):
        print('嘎嘎嘎')
    def spawn(self):
        print('下鸭蛋')
class E:
    def bark(self):
        print('鹅鹅鹅')
    def spawn(self):
        print('下鹅蛋')

j = Ji()
y = Duck()
e = E()

def mange(obj):
    obj.spawn()

mange(j)
mange(y)
mange(e)

isinstance 判断一个对象是否是某个类的实例 参数1 是判断的对象 参数2 是要判断的类型

def add(a,b):
    if isinstance(a,int) and isinstance(b,int):
        return a+b
    return None

print(add('100',100))

issubclass 判断一个类是否是另一个类的子类 参数1 是子类 参数2 是父类

class Animal:
    def eat(self):
        print('动物得吃东西')

class Pig(Animal):
    def eat(self):
        print('猪得吃   猪食')

class Tree:
    def light(self):
        print('植物光合作用')

tree = Tree()

pig = Pig()
def mange(obj):
    if issubclass(type(obj),Animal):
        obj.eat()
    else:
        print('不是动物')

mange(pig)
mange(tree)

str

__str__ 会在对象被转换为字符串时    转换的结果就是这个函数的返回值
使用场景    我们可以利用该函数来自定义对象的打印格式
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return '这是一个person对象 name:%s age: %s'%(self.name,self.age)

p = Person('james',22)
print(p)

del

__del__
执行时机    手动删除对象时立马执行   就是程序运行结束时也会自动执行
使用场景    当你的对象 在使用过程中 打开了不属于解释器的资源  例如文件 网络端口

class FileTool:
    '''    该类用于简化文件的读写操作    '''

    def __init__(self,path):
        self.file = open(path,'rt',encoding='utf-8')

    def read(self):
        return self.file.read()
    # 在这里可以确定一个是  这个对象肯定不使用了  所以可以方形的关闭文件了
    def __del__(self):
        self.file.close()
tool = FileTool(r'E:\程序\第六周\a.txt')
print(tool.read())

call

__call__
执行时机    在调用对象时自动执行  (包括对象加括号)

class A:
    def __call__(self, *args, **kwargs):
        print('call run')
        print(args)
        print(kwargs)
a = A()
a(1,a=1000)

slots

__slots__ 该属性是一个类属性   用于优化对象内存
优化的原理  将原本的不固定的属性数量变得固定
这样的话解释器就不会为这个对象创建名称空间,所以__dict__也没了
从而达到减少内存开销的效果

另外当类中出现了slots属性的时候	无法有新的属性添加


import sys


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

p = Person('james')

print(sys.getsizeof(p))
# p.age = 20   # 没有该对象    报错

# print(__dict__)  # 没有名称空间  报错

python是动态语言 可以再运行期间动态修改对象属性 如何能存储更多的属性呢?
需要开启更大的内存区域 将原始的属性赋值过去
问题 如果开启的容量太大 将造成内存的浪费
解决方案 就是在创建对象时候告诉系统这个对象只有那些属性 也就是固定了对象的属性数量
这样就能要多少开多少,不浪费

getattr setattr delattr

获取属性 修改属性 删除属性

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

就是解释器告诉我么点语法的实现原理

getattribute  该函数也使用类获取对象属性
在获取属性的时候   如果存在getattribute  则先执行该函数   如果没有拿到属性则继续调用   getattr函数,如果拿到了则直接返回

[] 的实现原理 getitem setitem 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):
        del self.__dict__[key]
        print('__delitem__')


a = A()
a.__dict__['name'] = 'james'     # 这样不行
a['name'] = 'james'  # __setitem__
print(a['name'])
del a['name']
print(a['name'])

运算符重载

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

案例 :    原本自定义对象无法直接使用大于小于来比较   我们可以自定义来实现    让自定义对象也支持比较富哈
class Student:
    def __init__(self,name,height,age):
        self.name = name
        self.height = height
        self.age = age

    # def __gt__(self, other):
    #     # print(self)
    #     # print(other)
    #     # print('__gt__')
    #     if self.height > other.height:
    #         return True

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

    def __eq__(self, other):
        return self.name == other.name

stu1 = Student('jack',180,28)
stu2 = Student('rose',140,27)

# print(stu1 > stu2)
# print(stu1 < stu2)
print(stu1 == stu2)

上述代码中  oyter   指的是另一个参与比较的对象
大于小于只要实现一个既可   符号不同自动交换对象的位置

迭代器协议

迭代器是指具有__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,22,2):
    print(i)

上下文管理

上下文context

这个感念属于语言学科 值得是一段话的意义 要参考当前的场景 就是上下文
在python中 上下文可以理解为一个代码区间 一个范围 例如with open 打开的文件静载这个上下文中有效

涉及到的两个方法:

enter

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

exit

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

当执行with 语句的时候 会先执行enter
当代码执行完毕后执行exit 或者代码遇到了一场会立即执行exit 并传入错误信息
包含错误的类型 错误的信息 错误的追踪信息

注意

enter 函数应该返回对象自己 
exit函数 可以有返回值,是一个bool类型,用于表示异常是否被处理,仅在上下文中出现异常有用
如果为True 则意味着,异常以及被处理了 
False,异常未被处理,程序将中断报错