7.29多态

多态

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

　　例如:水  固态 气态 液态

2.官方解释: 多个不同类对象可以响应同一个方法,产生不同的结果

　　首先强调多态不是一种特殊的语法,而是一种状态,特性(即多个不同对象可以响应同一个方法,产生不同的结果)，即多个对象有相同的使用方法

3.好处

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

　　我们之前写的USB接口下的鼠标,键盘,就属于多态

4.实现多态

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

"""
要管理 鸡 鸭 鹅
如何能够最方便的管理,就是我说同一句话,他们都能理解
既它们拥有相同的方法
"""
class Chicken:
    def bark(self):
        print("咯咯咯")

    def spawn(self):
        print("下鸡蛋..")

class Duck:
    def bark(self):
        print("嘎嘎嘎")

    def spawn(self):
        print("下鸭蛋..")

class Goose:
    def bark(self):
        print("鹅鹅鹅....")

    def spawn(self):
        print("下鹅蛋..")

j = Chicken()
y = Duck()
e = Goose()

def mange(obj):
    obj.spawn()

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

5.python中到处都有多态

a = 10
b = "10"
c = [10]

print(type(a))
print(type(b))
print(type(c))
# type就是多态的体现

OOP相关内置函数

1.isinstance

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

　　参数1：要判断的对象　　参数2：要判断的类型

def add_num(a,b):
    if isinstance(a,int) and isinstance(b,int):  # 判断传入的a是否为整型
        return a+b  # 是就相加
    else:
        return None

print(add_num(20,10))
print(add_num('a',10))

2.issubclass

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

　　参数1是子类　　参数2是父类

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

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

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

pig = Pig()
t = Tree()

def manage(obj):
    if issubclass(type(obj),Animal):  # 判断对象的类是不是另一个类的子类
        obj.eat()
    else:
        print("不是一头动物!")

manage(pig)
manage(t)

print(issubclass(Pig,object))  # True，新式类都是object的子类
print(issubclass(Tree,object))  # True，新式类都是object的子类

类中的魔法函数

　　应该写在类里面的函数，有一些奇怪行为的函数

1.__str__

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

class  Person:
    def __str__(self):
        print('run...')
        return '字符串'  # 必须返回字符串
p = Person()
str(p)  # __str__会在对象被转换为字符串时执行
print(p)  # 转换的结果就是这个函数的返回值

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

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("jack",20)
print(p)  # 这是一个person对象 name:jack age:20
# 因为print会自动调用__str__，把要打印的对象转为字符串再打印

2.__del__

　　执行时机: 手动删除对象时立马执行,或是程序运行结束时也会自动执行（因为程序运行结束时对象会被自动删除来释放内存空间）

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

    def __del__(self):
        print("del run")

p = Person("jack",20)
del p  # 可有可无，不主动删除也会执行__del__，因为程序结束时会自动删除对象

　　使用场景：当你的对象在使用过程中,打开了不属于解释器的资源,例如：文件,网络端口

# 该类用于简化文件的读写操作
class FileTool:
    def __init__(self,path):
        self.file = open(path,"rt",encoding="utf-8")  # 执行完__del__后不会自动关闭
        self.a = 100  # 执行完__del__后会被自动删除

    def read(self):
        return self.file.read()
    # 在这里可以确定一个事,这个对象肯定不使用了，所以可以放心的关闭问文件了
    def __del__(self):
        self.file.close()
        print('文件已关闭')

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

3.__call__

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

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

a = A()
a()  # 对象加括号调用的时候会执行__call__
a(1,a=100)  # 对象加括号调用的时候会执行__call__

4.__slots__

　　该属性是一个类属性,用于优化对象的内存占用

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

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

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

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

import sys
class Person:
    __slots__ = ["name"]  # 声明对象固定只有一个属性name
    def __init__(self,name):
        self.name = name

p =  Person("francis")
print(sys.getsizeof(p))
# p.age = 20  # 报错，无法再添加新的属性
# print(p.__dict__)  # 报错，也无法查看对象名称空间了

属性的__getattr__、__setattr__、__delattr__

1.执行时机

　　getattr：用点访问属性时，如果属性不存在时执行（对象.属性）

　　setattr：用点设置属性时（对象.属性 = 值）

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

class A:
    def __getattr__(self, item):
        print("__getattr__")
        return 1

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

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

a = A()
a.name = "jack"  # 设置属性时,执行__setattr__
print(a.age)  # 访问不存在的属性时，执行__getattr__，并返回值
del a.name  #  删除属性时,执行__delattr__

　　这几个函数反映了：python解释器是如何实现用点(.)来访问属性的

2.__getattribute__

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

class A:
    def __getattr__(self, item):
        print("__getattr__")
        return 1

    def __getattribute__(self, item):
        print("__getattribute__")
        return super().__getattribute__(item)

a = A()
print(a.name)

字典用[ ]取值的实现原理

1.实现原理：__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["name"] = "jack"  # 当你用中括号去设置属性时，执行__setitem__
print(a["name"])  # 当你用中括号去获取属性时，执行__getitem__
del a["name"]  # 当你用中括号去删除属性时，执行__delitem__

2.用处

# 需求让一个对象支持 点语法来取值 也支持括号取值
class MyDict(dict,list):
    def __getattr__(self, key):
        return self.get(key)

    def __setattr__(self, key, value):
        self[key] = value

    def __delattr__(self, item):
        del self[item]

a = MyDict()
a["name"] = "jack"
print(a["name"])
print(a.name)

a.age = 20
print(a["age"])

运算符重载

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

1.案例：

　　原本自定义对象无法直接使用大于、小于来进行比较 ,我们可自定义运算符来实现,让自定义对象也支持比较运算符

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

    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.age == other.age and self.height == other.height:
            return True
        return False

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

stu3 = Student("jack",180,28)
stu4 = Student("jack",180,28)
print(stu3 == stu4)

　　上述代码中,other指的是另一个参与比较的对象,大于和小于只要实现一个即可,符号如果不同,解释器会自动交换两个对象的位置

迭代器协议

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

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

1.实现：

class MyIter:
    # num传入，用来指定迭代次数
    def __init__(self,num):
        self.num = num  # 最大值，用来指定最大迭代次数
        self.c = 0  # 初始值

    def __iter__(self):
        return self

    def __next__(self):
        self.c += 1
        if self.c <= self.num:
            return "哈哈"
        else:
            raise StopIteration  # 返回错误

for i in MyIter(10):
    print(i)

2.如何实现一个自定义的range

class MyRange:
    def __init__(self,start,end,step=1):
        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)

上下文管理

　　上下文：context

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

1.涉及到的两个方法:

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

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

class MyOpen(object):
    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.file = open(self.path)
        print("enter...")
        return self  # enter函数应该返回对象自己

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("exit...")
        self.file.close()
        return True
        # exit函数，可以有返回值,是一个bool类型,用于表示异常是否被处理,仅在上下文中出现异常有用
        # 如果为True，则意味着，异常以及被处理了
        # 如果为False，则意味着，异常未被处理，程序将中断报错

with MyOpen("a.txt") as m:
    print(m)
    print(m.file.read())
    "123"+1  # 错误信息，被exit处理了