d23 多态,oop中常用的内置函数类中常用内置函数

布满荆棘的人生 2023-08-17 17:48 17阅读 0赞

# 多态 #

:一种事务具有多种不同的形态

官方解释:多种不同类型对象,可以同时响应一种方法,产生不同结果.

例如 水: 气态 固态 液态  
动物: 人 猫 猪  
汽车人: 汽车 飞机 人型

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

好处:

对于使用者而言,大大的降低了使用难度  
只需要学习基类中的使用方法即可, 不需要关心具体的哪一个类 以及实现的 以不变应万变 提高了灵活性  
提高扩展性  
  
如果没有多态 需要分别学习不同使用方法 这对于使用者而言太麻烦了

实现多态:

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

例子:

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class Chicken:
        def bark(self):
            print('gegege')
    
        def spawn(self):
            print('下鸡蛋')
    class Duck:
        def bark(self):
            print('gagaga')
        def spawn(self):
            print('下鸭蛋')
    
    class Goose:
        def bark(self):
            print('eee')
        def spawn(self):
            print('下鹅蛋')
    
    j = Chicken()
    d = Duck()
    g = Goose()
    
    def mange(obj):
        obj.spawn()
    
    mange(j)
    mange(d)
    mange(g)

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

a = 20
    b = '20'
    c = [20]
    
    print(type(a))
    print(type(b))
    print(type(c))

# oop中常用内置函数 #

## isinstance ##

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

def add_num(a,s):
        if isinstance(a,int) and isinstance(s,int):
            return a + s
        return None
    print(add_num(199,286))

例子

## issubclass ##

判断一个类是否是另一个类的子类
    
    参数一是子类
    
    参数二是父类

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class Person:
        def sleep(self):
            print('早睡早起')
    
    class Xiaoming(Person):
        def sleep(self):
            print('早点睡')
    
    class Flower:
        def take_in_sunlight(self):
            print('吸收阳光')
    
    mingming = Xiaoming()
    f = Flower()
    
    def manage(obj):
        if issubclass(type(obj),obj):
            obj.sleep()
        else:
            print('不是一类')
    # manage(f)
    # manage(mingming)
    
    print(issubclass(Flower,Person))
    print(issubclass(Xiaoming,Person))
    print(issubclass(Flower,object))
    print(issubclass(Person,object))

例子

# 类中常用内置函数 #

## \_\_str\_\_ ##

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class Person:
    
        def __init__(self,name,pwd):
            self.name = name
            self.pwd = pwd
    
        def __str__(self):
            return '这是一个person对象 name:%s pwd:%s '% (self.name,self.pwd)
    
    p = Person('小兰',123)
    print(p)

例子

## \_\_del\_\_ ##

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

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

例子

## \_\_call\_\_ ##

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

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

例子

\_\_slocts\_\_

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class Person:
    
        __slots__ = ["name"]
        def __init__(self,name):
            self.name = name
    
    p =  Person("jck")
    
    # 查看内存占用
    # print(sys.getsizeof(p))
    # p.age = 20 # 无法添加
    
    # dict 没有了
    print(p.__dict__)

例子

## \_\_getattr\_\_  \_\_setattr\_\_  \_\_delattr\_\_ ##

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

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)
            pass
        def __getattr__(self, item):
            print("__getattr__")
            return 1
    
        def __getattribute__(self, item):
            print("__getattribute__")
            # return self.__dict__[item]
            return super().__getattribute__(item)
    
    #
    a = A()
    a.name = "jack"
    # print(a.name)
    
    # del a.name
    print(a.name)
    print(a.xxx)
    a.name = "xxx"
    print(a.name)
    
    
    b =A()
    b.__dict__["name"] = "jack"
    print(b.name)

例子

## \[\] 的实现原理 ##

## getitem setitem delitem
    
    任何的符号 都会被解释器解释成特殊含义 ,例如 .  [] () 
    
    getitem 当你用中括号去获取属性时 执行
    setitem  当你用中括号去设置属性时 执行
    delitem 当你用中括号去删除属性时 执行

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

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"
    a["name"] = "jack"
    print(a["name"])
    del a["name"]
    print(a["name"])

可乐

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class MyDict(dict,list):
    
        # pass
        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"])
    a.name
    
    a["name"] = "jack"
    
    a.append(10)
    print(a)

雪碧

## 运算符重载 ##

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

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

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
    
    
    
    stu1 = Student("jack",180,28)
    stu2 = Student("jack",180,28)
    
    
    # print(stu1 < stu2)
    print(stu1 == stu2)
    
    上述代码中,other指的是另一个参与比较的对象,
    
    大于和小于只要实现一个即可,符号如果不同  解释器会自动交换两个对象的位置

烧鸭

## 迭代器协议 ##

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

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

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,异常未被处理,程序将中断报错

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

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

炒鸡

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

with MyOpen("a.txt") as m:
        print(m)
        print(m.file.read())
        "123"+1
    
    m.file.read()

小鸡炖蘑菇

上下文管理   可以实现自动清理     与del的区别 del管理的是对象的生命周期  会在对象销毁时执行清理  
    
    上下文管理,管理的是一个代码范围 ,出了范围自动清理

转载于:https://www.cnblogs.com/komorebi/p/11266510.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20230808/29c7d2cd1be34098bec05d561f14ebe3.png

发表评论取消回复

表情：

评论列表（有 0 条评论，17人围观）

还没有评论，来说两句吧...

相关阅读

相关 Python中常用的内置函数集合

这篇文章主要介绍了Python中常用的内置函数，主要介绍内容有map()、filter()、all()、int()等更多相关函数，需要的小伙伴可以看看。一、map()

水深无声/ 2024年03月31日 16:49/ 0 赞/ 155 阅读

相关 Python中常用的内置函数集合

一、map() `map`(func,iterable)，其中func为函数名，可为lambda匿名函数，iterable为可迭代对象。此函数会将可迭代对象中的每一位元素

分手后的思念是犯贱/ 2024年03月30日 11:38/ 0 赞/ 91 阅读

相关 d23 多态,oop中常用的内置函数类中常用内置函数

多态 :一种事务具有多种不同的形态官方解释:多种不同类型对象,可以同时响应一种方法,产生不同结果. 例如水: 气态固态液态动物: 人猫猪汽车人

布满荆棘的人生/ 2023年08月17日 17:48/ 0 赞/ 18 阅读

相关 Python常用内置函数

1.常用内置函数：(不用import就可以直接使用) help(obj) 在线帮助, obj可是任何类型 callable(obj) 查看一个ob

港控/mmm°/ 2022年08月07日 06:57/ 0 赞/ 269 阅读

相关 python内置函数|类中的内置方法|字符串内置方法大全

一、数学运算类 <table style="border:1px solid rgb(204,204,204); color:rgb(0,0,0); font-fa

r囧r小猫/ 2022年07月15日 06:08/ 0 赞/ 388 阅读

相关 Mysql常用内置函数

字符串函数： concat(s1,s2,....,sn):字符串的连接 insert(str,x,y,insert):将字符串从x位置开始，y个字符串长度替换为字符串i

梦里梦外;/ 2022年05月21日 13:47/ 0 赞/ 311 阅读

相关 MySQL常用内置函数

文章目录数学函数 \` abs(X)\` 返回X的绝对值 \`mod(N,M)\` 或 \`%\` 返回 N 被 M 除的余数

叁歲伎倆/ 2022年02月02日 04:19/ 0 赞/ 794 阅读

相关 MySQL 常用内置函数与所有内置函数

[MySQL函数大全及用法示例][MySQL] 1、字符串函数 ascii(str) 返回字符串str的第一个字符的ascii值(str是空串时返回0) my

蔚落/ 2021年12月18日 07:25/ 0 赞/ 863 阅读

相关 Oracle常用内置函数

[https://blog.csdn.net/yihuiworld/article/details/44701561][https_blog.csdn.net_yihuiwor

た入场券/ 2021年12月17日 02:21/ 0 赞/ 375 阅读

相关 Python常用内置函数

Python 解释器内置了很多函数和类型，可以在任何时候使用它们。下面按字母表顺序列出它们。 -------------------- abs(x)：返回一个数（

快来打我*/ 2021年11月02日 09:14/ 0 赞/ 499 阅读