OOP的三大特征之多态 | 面向对象高级知识,内置魔法函数,点语法和[ ]取值的实现,运算符重载,迭代器协议,上下文管理

今日内容

多态

一种食物具备多种不同的形态,例如:水的固态,气态,液态

官方解释:

  • 多个不同的对象可以响应同一个方法,产生不同的结果

注意:

  • 多态不是一种特殊的语法,而是一种状态,特性(即多个不同的对象可以响应同一个方法,产生不同的结果)

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

  • 优势:
    • 对于使用者而言,大大降低了使用难度
  • 我们之前写的USB接口下的鼠标,键盘,就属于多态

多态性的实现:

# 要管理鸡鸭鹅,如何能够最方便的管理,就是我说同一句话,他们都能理解
# 他们拥有相同的方法
class JI:
    def bark(self):
        print('咯咯咯')
    def spawn(self):
        print('下鸡蛋')
​
class Duck:
    def bark(self):
        print('嘎嘎嘎')
    def spawn(self):
        print('下鸭蛋')
​
class Er:
    def bark(self):
        print('鹅鹅鹅')
    def spawn(self):
        print('下鹅蛋')
        
j = JI()
y = Duck()
e = Er()
​
def mange(obj):
    obj.spawn()
​
mange(j)  # 下鸡蛋
mange(y)  # 下鸭蛋
mange(e)  # 下鹅蛋

总结:接口,抽象类,鸭子类型,都可以写出具备多态的代码,其中最简单的是鸭子类型,python中到处都有多态

 

面向对象高级

一对函数:

isinstance:

  • 判断一个对象是否是某个类的实例
  • 用法:
    • isinstance(要判断的对象,要判断的数据类型)

issubclass:

  • 判断一个类是否是另一个类的子类
  • 用法:
    • issubclass(子类,父类)
# isinstance
def add_num(a,b):
    if isinstance(a,int) and isinstance(b,int):
        return a+b
    return None
​
print(add_num('100',10))  # None


​
# issubclass
class Animal:
    def eat(self):
        print('动物得吃东西...')
​
class Pig(Animal):
    def eat(self):
        print('猪要吃猪食...')
        
class Tree:
    def light(self):
        print('植物要光合作用')
​
pig = Pig()
t = Tree()
        
def mange(obj):
    if issubclass(type(obj),Animal):
        obj.eat()
    else:
        print('不是动物!')
    
mange(pig)  # 猪要吃猪食
mange(t)  # 不是动物!

内置的魔法函数:

str

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

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

# 类中的魔法函数
class Person(object):
    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',18)
print(p)

del

执行时机:手动删除对象时,立马执行;或是程序运行结束时,也会自动执行

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

import time
​
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __del__(self):
        print('del run')
        
p =Person('jack',18)
​
del p
​
time.slepp(5)
print('over')
​
# del run 过5秒后 over

call

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

class A:
    def __call__(self,*args,**kwargs):
        print('call run')
        
a = A()
a(1,a=100)  # {1:100}

注意:python是动态语言,可以在运行期间,动态的修改对象的属性

如何能存储更多属性呢?

  • 需要开启更大的内存区域,将原始的属性赋值过去;但是,有个问题,就是如果开启的容量太大,将造成内存的浪费

解决方案:

  • 就是在创建对象时告诉系统,这个对象只有哪些属性,也就是固定了对象的属性数量,这样就可以要多少空间开多少空间,一个都不会浪费

__ slots __

定义:该属性是一个类属性,用于优化对象内存

优化的原理是:

  • 将原本不固定的属性数量,变得固定了,这样的解释器就不会为这个对象创建名称空间,所以__ dict __也没了,从而达到减少内存开销的效果
  • 另外,当类中出现了slots时,将导致这个类的对象无法再添加新的属性
# slots未使用时
import sys
​
class Person:
    def __init__(self,name):
        self.name = name
        
p = Person('jack')
print(sys.getsizeof(p))  # 56  字节数
​
# 开始使用slots
class Person:
    __slots__ = ['name']
    def __init__(self,name):
        self.name = name
        
p = Person('jack')
print(sys.getsizeof(p))  # 48  字节数
p.age = 20  # 这时候打印,会直接报错,因为这个类的对象无法再添加新的属性
print(p.__dict__)  # 直接报错 'Person' object 没有'__dict__'

点语法的实现:

getattr:

  • 用'点'访问属性时如果属性不存在,则执行

setattr:

  • 用'点'来设置属性时执行

delattr:

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

总结:

  • 这几个函数反映了,python解释器是如何实现 用'点'来访问属性
  • getattribute函数也是用来获取属性的,在获取属性时,如果存在getattribute则先执行该函数,如果没有拿到属性则继续调用getattr函数,如果拿到了则直接返回
# 属性的get set del
class A:
    def __getattr__(self, item):
        print('__getattr__')
        
    def __setattr__(self,key,value):
        super().__setattr__(key,value)
        print('__setattr__')
        
    def __delattr__(self, item):
        print('__delattr__')
        
a =A()
a.name = 'jack'
print(a.name)  # 'jack'


​
# 重点关注setattr与delattr
class A:
    def __getattr__(self, item):
        print('__getattr__')
        
    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'
print(a.name)  # '__setattr__' 'jack'
​
del a.name
print(a.name)  # None


​
# __getattr__与__getattribute__同时出现时,会先调用__getattribute__方法
class A:
    def __getattr__(self, item):
        print('__getattr__')
        
    def __getattribute__(self, item):
        print('__getattribute__')
　　　　 return super().__getattribute__(item)

[ ]取值的实现:

. 与 [ ]的实现原理:

  • getitem setitem deltiem

任何的符号,都会被解释器解释成特殊函数,例如 . 与 [ ]

# getitem,  setitem, delitem
# 第一种情况
class A:
    def __getitem__(self, item):
        print('__getitem__')
        
    def __setitem__(self,key,value):
        print('__setitem__')
        self.__dict__[key] = value
        
    def __delitem__(self, item):
        print('__delitem__')
        
a = A()
a.['name'] = 'jack'  # '__setitem__'
print(a.name)  # 报错
​
# 第二种情况
class A:
    def __getitem__(self, item):
        print('__getitem__')
        retuan self.__dict__[item]
        
    def __setitem__(self,key,value):
        print('__setitem__')
        self.__dict__[key] = value
        
    def __delitem__(self, item):
        del self.__dict__[key]
        print('__delitem__')
​
a = A()
a.['name'] = 'jack'
print(a.['name'])  # '__setitem__'
del a['name']
print(a.['name'])

来个案例:

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

class MyDict(dict):
    def __getattr__(self, key):
        return  self.get(key)
    
    def __setattr__(self,key,value):
        self[key] = value
        
    def __delattr__(self, item):
        def self[item]
​
a = MyDict()
a['name'] = 'jack'
print(a.['name'])  # 'jack'
​
a.['age'] = 20
print(a.['age'])  # 'jack' 20

运算符重载

定义:

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

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

# 对象比较大小,__gt__为大于greater than,等于Be equal to,小于less than
# 下面的代码中,other指的是另一个参与比较的对象,大于和小于只要实现一个即可,符号如果不同,解释器会自动交换两个对象的位置
# 大于和小于的情况
class Student:
    def __init__(self,name,height,age):
        self.name = name
        self.height = height
        self.age = age
        
    def __gt__(self, other):
        print('__gt__')
        return self.height > other.height
        
stu1 = Student('jack',180,28)
stu2 = Student('rose',145,27)
​
print(stu1 > stu2)  # True
print(stu1 < stu2)  # False
​
​
# 等于的情况
class Student:
    def __init__(self,name,height,age):
        self.name = name
        self.height = height
        self.age = age
        
    def __eq__(self,other):
        print('__eq__')
        return self.name == other.name
        
stu1 = Student('jack',180,28)
stu2 = Student('rose',145,27)
​
print(stu1 == stu2)  # False

迭代器协议

定义:迭代器是指具有__ iter__ 和 __ next __ 的对象,我们可以为对象增加这两个方法来让对象变为一个迭代器

案例:

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.mnum:
            return 'hahaha'
        else:
            raise StopIteration
  
for i in MyIter(10):
    print(i)  # 返回10个'hahaha'


# 实现一个自定义的range
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)  # 1 3 5 7 9

上下文管理:

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

上下文 context:

  • 可以实现自动清理

与del的区别:

  • del管理的时对象的生命周期,会在对象销毁时执行清理
  • 上下文管理它管理的是一个代码范围,出了范围自动清理

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

with open('XXXX')as f:
    pass

它涉及到的两个方法:

  • enter:

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

  • exit:

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

总结:

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

案例:

# 第一种情况
class MyOpen:
    def __enter__(self):
        print('enter...')
    
    def __exit__(self,exc_type,exc_val,exc_tb):
        print('exit...')
        print(exc_type,exc_val,exc_tb)
        
with MyOpen() as m:
    pass
# enter...  exit... None None None


​
​
# 第二种情况
class MyOpen:
    def __enter__(self):
        print('enter...')
    
    def __exit__(self,exc_type,exc_val,exc_tb):
        print('exit...')
        print(exc_type,exc_val,exc_tb)
        
with MyOpen() as m:
    print('start')  # 'start' 'exit'
    '123' + 1  # 报错
    print('over')  # 'enter' 'over'


    
​
# 第三种情况
class MyOpen:
    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  # 这里表示异常是否被处理,True为已处理,False为未处理
        
        
with MyOpen('a.txt')as m:
    print(m.file.read())
# 如果仍然报错,返回错误信息与Process finished with exit code 1,则异常未被处理
# 如果未报错,返回Process finished with exit code 0,则异常已被处理

注意:

  • enter函数应该返回对象自己
  • exit函数,可以有返回值,是一个bool类型,用于表示异常是否被处理,仅在上下文管理中使用
  • 如果为True,则意味着,异常已经被处理了
  • 如果为False,异常未被处理,程序将中断报错
posted @ 2019-07-29 16:56  泡泡茶壶i  阅读(187)  评论(0)  编辑  收藏  举报