• 上海 day23 -- 面向对象三大特征---多态 和 内置魔法函数


    目  录

    一、多态

    什么是多态?

    多态是指多个不同类的对象能够响应同一个方法,并产生不同的结果。

    多态不是一种语法,而是一种状态,拥有一种特性(不同的类型的对象能够响应同一种方法,并产生不同的结果),即多个对象有共同的使用方法。

    多态的好处?

    能够方便使用者使用,大大降低使用难度。例如:我们写的USB接口协议,包含的鼠标,键盘等都拥有共同的功能,它们就是属于多态。

    多态的实现?

    方法:接口、抽象类(两者属于继承)和鸭子类型,都可以实现具备多态功能的代码,其中最简单的是鸭子类型。

    案例:

    """
    要管理 鸡 鸭 鹅
    如何能够最方便的 管理,就是我说同一句话,他们都能理解
    他们拥有相同的方法
    
    """
    class J:
        def jiao(self):
            print('jjj...')
    
        def xidan(self):
            print('鸡蛋。。。')
    
    class Y:
        def jiao(self):
            print('yyy...')
    
        def xidan(self):
            print('鸭蛋。。。')
    
    class E:
        def jiao(self):
            print('eee...')
    
        def xidan(self):
            print('鹅蛋。。。')
    
    j = J()
    y = Y()
    e = E()
    
    def func(obj):
        obj.xidan()
    
    func(j)
    func(y)
    func(e)

    python 中包含的多态,如type() 方法     

    # python中到处都有多态
    a = 10
    b = "10"
    c = [10]
    
    print(type(a))
    print(type(b))
    print(type(c))

    二、OOP相关的内置函数

    isinstance ()  和 issubclass()

    ## isinstance
    
    判断一个对象是否是某个类的实例
    
    参数1 要判断的对象 
    
    参数2 要判断的类型 
    
    
    
    ## issubclass 
    
    判断一个类是否是另一个类的子类 
    
    参数一是子类
    
    参数二是父类  

    案例1:

    def add_num(x,y):
        # if type(x) == int and type(y) == int:
        if isinstance(x,int) and isinstance(y,int):
            return x+y
        return None
    print(add_num(10,20))  #30
    print(add_num('10',20))  # None

    案例2:

    class Animal:
        def eat(self):
            print('吃东西')
    
    class Pig(Animal):
        def eat(self):
            print('猪就知道吃东西。。。')
    
    class Tree:
        def light(self):
            print('光合作用。。')
    
    p = Pig()
    t = Tree()
    
    
    def manage(obj):
        if issubclass(type(obj),Animal):  # issubclass判断是否是一个子类
            print(' 就知道吃。。。')
        else:
            print('不属于动物类!')
    
    manage(p)
    manage(t)

    三、类中的魔法函数

    1、__str__

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

    案例:

    import time
    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('jaosn',29)
    # del p
    print(str(p))   # 当我们对象p转换成str字符串格式时,会自动触发__str__,结果就是该函数的返回值
    time.sleep(2)
    print('over')

    2、析构方法  __del__

    什么是析构方法?

    __init__ 是构建函数,一个东西从无到有就是构建;析构就是让一个东西从有到无,如__del__

    析构方法有什么特点?

    当对象在内存中被释放时,会自动触发执行。

    为什么需要析构方法?

    如果产生的对象仅仅是用户级别的程序,那么无须定义 __del__ ,因为Python内部有自动回收资源的机制;

    但是当产生对象的同时还向操作系统发起系统调用,即一个对象有用户级和内核级两种资源,如打开一个文件,创建一个数据库链接,就必须在清楚对象的同时回收系统资源,这就用到了__del__。

    __del__触发的两种方式:

    1、当程序出现错误会触发__del__     

    class File:
        def __init__(self,name):
            self.name = name
    
        def say(self):
            print('hello my name is %s'%name)  # name写错了,当遇到报错的时候会自动触发__del__
    
        def __del__(self):
            print('__del__是什么玩意?')
    
    f = File('jason')
    f.say()
    
    # 结果:
    # NameError: name 'name' is not defined
    # __del__是什么玩意?
    # 结论:当程序出现错误时,会自动触发__del__

    2、当程序正常运行结束后自动触发__del__ 

    class File:
        def __init__(self,name):
            self.name = name
    
        def say(self):
            print('hello my name is %s'%self.name)  # name写错了,当遇到报错的时候会自动触发__del__
    
        def __del__(self):
            print('__del__是什么玩意?')
    
    f = File('jason')
    f.say()
    '''
    结果:
    hello my name is jason
    __del__是什么玩意?
    结论:当程序正常运行结束后会自动触发 __del__
    '''

    3、__call__

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

    案例:

    class A:
       def __call__(self,*args,**kwargs):
           print('warning!run...')
           print(*args)
           print(**kwargs)
    
    a = A()
    a(1,(2,3))  # 对象a 加括号自动调用__call__
    '''
    结果:
    warning!run...
    1 (2, 3)
    '''

    4、__slots__     —— 内存优化方法

    前提知识:

    动态容器的实现原理:

    关于__slots__:

    该属性是一个类属性,用于优化对象内存占用
    优化的原理,将原本不固定的属性数量,变得固定了
    这样的解释器就不会为这个对象创建名称空间,所以__dict__也没了  
    从而达到减少内存开销的效果 
    
    另外当类中出现了slots时将导致这个类的对象无法在添加新的属性 

    案例:

    # 原式
    import sys
    class Person:
        def __init__(self,name):
            self.name = name
            print(self.__dict__)
    
    p = Person('jason')  # {'name': 'jason'}
    p.age = 20  # 自己添加属性
    print(p.__dict__)  # {'name': 'jason', 'age': 20}
    print(sys.getsizeof(p))   # 以字节(byte)为单位返回对象大小  32
    
    # 加入 __slots__ 对比
    import sys
    class Person:
        __slots__= ['name']
        def __init__(self,name):
            self.name = name
            print(self.name)
    
    p = Person('jason')  # {'name': 'jason'}
    # p.age = 20  # 无法在添加属性
    # print(p.__dict__)  # 没有__dict__属性
    print(sys.getsizeof(p))   # 以字节(byte)为单位返回对象大小  28

    四、属性的get 、set 和 del

    1、getattr setattr delattr     ——反映了python中点语法的实现原理

    '''
    getattr 用点访问属性的时如果属性不存在时执行
    setattr 用点设置属性时
    delattr 用del 对象.属性  删除属性时 执行
    
    
    这几个函数反映了 python解释器是如何实现 用点来访问属性 
    
    getattribute 该函数也是用来获取属性
    在获取属性时如果存在getattribute则先执行该函数,如果没有拿到属性则继续调用 getattr函数,如果拿到了则直接返回 
    
    '''

    案例:

    class A:
        def __setattr__(self,key,value):
            print('__setattr__')
    
        def __getattr__(self, item):
            print('__getattr__')
            return 1
    
        def __delattr__(self, item):
            print('__delattr__')
    
    a = A()
    a.name = 'jason'  # 在设置属性时,自动执行 __setattr__
    print(a.xxx)  # 结果:__getattr__ 1  在对象访问属性的时候自动执行 __getattr__
    del a.yyy    # 结果:__delattr__     在删除对象属性的时候自动执行 __delattr__

    2、getitem、setitem、delitem     —— 反映了Python中 [ ] 取值的实现原理

    小总结: —— 任何的符号 都会被解释器解释成特殊含义 ,例如 . [] ()

    getitem 当你用中括号去获取属性时 执行
    setitem  当你用中括号去设置属性时 执行
    delitem 当你用中括号去删除属性时 执行

    另一种解释用法:

    '''
    __setitem__
    
    ​ 使用key的形式添加/修改属性时触发
    
    __getitem__
    
    ​ 使用key的形式获取属性时触发
    
    __delitem__
    
    ​ 使用key的形式删除属性时触发
    
    '''

    案例:

    class A:
        def __getitem__(self, item):
            print("__getitem__")
            # return self.__dict__[item]  # 因为self.__dict__[key] = value为执行,所以不会取到self.__dict__[item]的值
    
        def __setitem__(self, key, value):
            print("__setitem__")
            # self.__dict__[key] = value  # 当这句话被注释时所添加的键值对不会被保存
    
        def __delitem__(self, key):   
            # del self.__dict__[key]  # 因为self.__dict__[key] = value未执行,所以没有元素可以被删除
            print("__delitem__")
    
    a = A()
    # 用字典键值对的形式赋值
    a['name'] = 'jason'  # __setitem__ 当添加键值对时会触发__setitem__方法
    
    print(a['name'])  # 当按照key取值时会触发__getitem__方法
    
    del a['name']  # 当按照key值删除keys所对应的值时会触发__delitem__方法
    
    '''
    综上代码可知:[]取值的原理就是self.__dict__在对象的名称空间(名称空间是字典的形式)中按key value 的形式进行取值操作
    '''

    小练习:

    """需求让一个对象支持 点语法来取值 也支持括号取值"""
    class MyDict(dict):
        def __getattr__(self,item):
            return self[item]
    
        def _setattr__(self,key,value):
            self[key] = value
    
    
        def __delattr__(self,item):
            del self[item]
            return 999
    
    d = MyDict()
    d.name = ['jason']  # 根据__setattr__特性 自定触发并执行 self[key] = value 代码来实现,本质是字典添加键值对
    # print(d.name)  # 触发__getattr__
    del d.name

    五、运算符重载

    __gt__ 、 __lt__ 、__eq__   分别对应 大于号>  小于号<   和等于号 eq

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

    案例:

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

    class Student:
        def __init__(self,name,age,height):
            self.name = name
            self.age = age
            self.height = height
    
        def __gt__(self,other):  # 指定比较的属性 height  大于号 __gt__
            return self.height > self.height
    
        def __lt__(self,other):  # 指定比较的属性 height  小于号 __lt__
            return self.height < other.height
    
        def __eq__(self,other):   # 指定比较的属性 height  等于号 __eq__
            if self.name == other.name and self.age == other.age and  self.height == other.height:
                return True
            return False
    stu1 = Student('egon',28,180)
    stu2 = Student('tank',25,188)
    # 开始比较大小
    print(stu1>stu2)  # False
    print(stu1<stu2)  # True
    
    stu3 = Student('jason',28,180)
    stu4 = Student('jason',28,180)
    print(stu3 == stu4)   # True

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

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

    六、迭代器协议

    '''
    迭代器是指具有__iter__和__next__的对象
    我们可以为对象增加这两个方法来让对象变成一个迭代器 
    '''

    案例1:将对象变成迭代器对象

    '''
    迭代器是指具有__iter__和__next__的对象
    我们可以为对象增加这两个方法来让对象变成一个迭代器 
    '''
    class MyIter:
        def __init__(self,num):
            self.num = num
            self.c = 0  # 自定义属性值的默认值
    
        def __iter__(self):  # 迭代器调用 __iter__还是迭代器本身
            return self
    
        def __next__(self):
            self.c += 1
            if self.c < self.num:
                return '嘿嘿'
            else:
                raise StopIteration  #  异常处理   注意:当调用__next__取不到值的时候会报错 StopIteration
    
    m = MyIter(10)
    # 迭代器的取值方式不依赖索引,可以用for循环取值。。。
    for i in m:
        print(i)  # 

    小练习:

    """实现一个自定义的range"""
    class MyRange:
        def __init__(self,start_num,end_num,step):
            self.start_num = start_num - 2
            self.end_num = end_num
            self.step = step
    
        def __iter__(self):
            return self
    
        def __next__(self):
            self.start_num += self.step
            if self.start_num < self.end_num:
                return self.start_num
            else:
                raise StopIteration    # 处理异常
    
    mr = MyRange(1,10,2)
    # for循环取值迭代器对象
    for i in mr:
        print(i)

    七、上下文管理

    上下文 context

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

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

    涉及到的两个方法:enter()   exit()

    enter

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

    exit

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

     

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

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

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

    注意:

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

    案例:

    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()
  • 相关阅读:
    Sql Serer 常用函数
    分享5个viewport相关的jQuery插件 java程序员
    struts2.xml中使用chain和redirectAction这两个类型结果(typeresult)时,报检查错误(validation) java程序员
    Android开发之Intent跳转到系统应用中的拨号界面、联系人界面、短信界面 java程序员
    详解struts2中struts.properties java程序员
    Struts2输入校验总结 java程序员
    struts.xml配置文件中result的语法:<result name="" type="">xxxxx</result> java程序员
    挺立在孤独,失败与屈辱的废墟上(俞敏洪) 读书心得 java程序员
    超棒的响应式jQuery网格布局插件 grida licious java程序员
    struts2国际化 java程序员
  • 原文地址:https://www.cnblogs.com/qinsungui921112/p/11265343.html
Copyright © 2020-2023  润新知