类的多态性

类的多态性

概念：

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

例如：水 固态 气态 液态

​ 大黄蜂：汽车人，汽车，飞机

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

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

既等多个对象有相同的使用方法

类的多态性是指多个不同的对象之间具有相同的使用方法。

好处

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

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

实现多态

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

案例：

"""
要管理 鸡 鸭 鹅
如何能最方便的 管理，就是我说一句话，他们都能理解
即它们拥有相同的方法
"""
class JI:
    def jiao(self):
        print('咯咯咯')
    
   	def lay_egg(self):
        print('鸡下蛋了')
    
class Duck:
    def jiao(self):     
    	print('嘎嘎嘎')
    
    def lay_egg(self):
        print('鸭下蛋了')
    
class E:
    def jiao(self):
        print('鹅鹅鹅....')
   	
    def lay_egg(self):
        print('鹅下蛋了')
     
j = JI()
y = Duck()
e = E()

def manage(obj):
    obj.jiao()
    obj.lay_egg()

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

# pyhton中到处都有多态
# 多个不同的对象之间具有相同的使用方法
a = 10
b = "10"
c = [10]

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

isinstanse

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

参数1 要判断的对象

参数2 要判断的类型

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

print(add_num(20,10))

issubclass

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

参数1 是子类

参数2 是父类

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

class Pig(Animal):

    def eat(self):
        print('猪得吃主食.....')

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


pig = Pig()
t = Tree()

def manage(obj):
    # 判断obj的类型那个是不是Animal的子类
    if issubclass(type(obj),Animal):
        obj.eat()

    else:
        print('不是一头动物')

manage(pig)  # 猪得吃主食.....
#
manage(t)  # 不是一头动物
# 每个类都市object的子类
print(issubclass(Tree,object))  # True

str:打印对象的类型为字符串

__str__  会在对象被转换为字符时，转换的结果就是这个函数的返回值
使用场景：我们可以利用该函数来自定义，对象的时打印格式

import sys
import time

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
	# __str__,是覆盖了父类object类中的__str__方法，可以自定义对象，的打印格式返回值是对象，
    def __str__(self):
        return f"这是一个person对象，名字为{self.name},年龄为{self.age}"

    # 在程序运行结束才会执行
    def __del__(self):
        print('del run')

# 将对象由内存地址转化为了字符串，
p = Person("jack",20)  # 这是一个person对象，名字为jack,年龄为20

time.sleep(2)
s = str(p)
print(s)
print("over")

# Person中没有__str__函数，默认使用object类中的__str__方法，即str(obj)对象的结果是一堆字符串，
p = Person("jack",20)
print(p)  # <__main__.Person object at 0x025B8C30>

time.sleep(2)
s = str(p)
print(s)  # <__main__.Person object at 0x025B8C30>
print("over")

del：在程序运行结束时执行

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

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

# del自动删除使用案例

class FileToll:

    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 = FileToll('a.txt')

print(tool.read())  # 12345678

# del手动删除使用案例
import sys
import time

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

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


p = Person("jack",20)
# 手动删除了，先运行__del__函数
del p  # del run
time.sleep(2)

print("over")  # over

call

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

测试：

# call 的执行时机

class A:
	# 只有在调用对象时自动执行，(即对象加括号)
    def __call__(self, *args, **kwargs):
        print('run')
        print(args)
        print(kwargs)
# 实例化a
a = A()
# 调用对象
a(1,a=100)

run
(1,)
{'a': 100}

slots

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

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

[https://www.cnblogs.com/zuihoudebieli/gallery/image/252164.html]

# slots的使用
class Person:
    __slots__=['name']
    def __init__(self,name):
        self.name = name 
p = Person('jack')

# 查看内存占用
# print(sys.getizeof(p))
# p.age = 20

# dict 没有了
print(p.__dict__)

# slots的使用
import sys
class Person:
    # __slots__ = ["name"]
    def __init__(self,name):
        self.name = name
        print(self.__dict__)  # {'name': 'jason'}

p = Person("jason")
print(sys.getsizeof(p))  # 32
p.age = 20
print(p.age)  # 20

# slots
import sys
class Person:
    # 限制对象的属性个数，节省内存占用
    __slots__ = ["name"]
    def __init__(self,name):
        self.name = name
        # print(self.__dict__)  # 无法打印

p = Person("jason")
print(sys.getsizeof(p))  # 28
# p.age = 20  # 无法添加属性
# print(p.age)
# dict 没有了
# print(p.__dict__)

getattr setattr delattr

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

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

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

# setattr使用案例
class A:
    def __setattr__(self, key, value):
        print(key)
        print(value)
        print("__setattr__")
        # 将变量名和变量值添加到对象的属性的字典中
        self.__dict__[key] = value

a = A()
# 设置属性，添加属性时，执行__setattr__
a.name = "jack"
print(a.name)   # jack
print(a.__dict__)  # {'name': 'jack'}

class A:
    def __setattr__(self, key, value):
        print(key)
        print(value)
        print("__setattr__")

        self.__dict__[key] = value


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


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

    # def __getattribute__(self, item):
    #     print("__getattribute__")
    #
    #     # return self.__dict__[item]
    #     return super().__getattribute__(item)

a = A()
# 设置属性，触发__setattr__
a.name = "jack" 
# 打印结果
name
jack
__setattr__
# print(a.name)
# print(a.__dict__)

# 删除 属性时，触发__delattr__
del a.name
__delattr__
# 打印删除的属性名对应的值，由于对象中没有属性，查看没有的属性时，会自动触发__getattr__
print(a.name)
name
__getattr__
1
# 由于对象中没有属性，查看没有的属性时，会自动触发__getattr__
print(a.xxx)
__getattr__
1
# 设置属性，触发__setattr__
a.name = "xxx"
name
xxx
__setattr__
# 打印属性名对应的值
print(a.name)
xxx

class A:
    def __setattr__(self, key, value):
        print(key)
        print(value)
        print("__setattr__")

        self.__dict__[key] = value


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


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

    def __getattribute__(self, item):
        print("__getattribute__")

        # return self.__dict__[item]
        return super().__getattribute__(item)

a = A()
# 获取对象的属性，先执行__getattribute__，如果获取不到，执行__getattr__，如果获取到了直接返回。
print(a.name)

__getattribute__
__getattr__
1

a.name = "xxx"
# 获取对象的属性，先执行__getattribute__，获取到了属性，直接返回属性的值
print(a.name)

__getattribute__
xxx


b = A()
# 使用__dict__添加属性
b.__dict__["name"] = "jack"
# 获取对象的属性，先执行__getattribute__，添加属性后，在执行__getattribute__
print(b.name)

__getattribute__
__getattribute__
jack

[]的实现原理

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.name = "jack"  程序不执行
# 使用[]给对对象设置属性，触发__setitem__
a['name'] = "jack"
__setitem__
# 使用[]查看对象那个的属性，触发__getitem__
print(a['name'])

__getitem__
jack
# 使用[]删除对象的属性时，触发__delitem__
del a['name']
__delitem__
# print(a['name'])  对象没有名字属性，报错

"""需求让一个对象支持 点语法来取值 也支持括号取值"""

class MyDict(A):
    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"])
print(a.name)

运算符重载

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

案例：

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

class Student(object):
    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 = Studnt("jack",180,28)
# print(stu1 < stu2)
print(stu1 < stu2)

上述代码中，other指的是另一个参与比较的对象，

大于和小于只要是实现一个即可，符号如果不同，解释器会自动交换两个对象的位置

class Student(object):
    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__")
        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

s1 = Student("jack",180,28)
s2 = Student("jack",180,28)
# s2 = Student("nick",160,25)

print(s1 < s2)  # False
print(s1 == s2)  # True

迭代器协议

迭代器是指具有__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)
    

上下文管理

上下文context

这个概念属于语言学科，指的是一段话的意义，要参考当前的场景，既上下文

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

涉及到的两个方法：

enter

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

exit

​ 表示退出了上下文,(推出了某个场景了)

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

当代码执行完毕后执行exit，或者代码遇到了异常会立即执行exit，并传入错误信息

包含错误的类型.错误的信息.错误的追踪信息

注意：

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

接口抽象类，鸭子类型，