您的位置: 首页  >  IT文章  >  面向对象(多态,类方法,魔法方法)

面向对象(多态,类方法,魔法方法)

分类: IT文章 • 2024-02-02 23:14:36

1.多态

　　1.概念:多个不同类对象可以响应同一个方法,产生不同的结果,多态不是一种特殊的语法,而是一种特性

　　2 优点:对于使用者的角度,降低了使用难度

　　3.实现:接口类,抽象类,鸭子类型都可以实现

class Ji:
    def bark(self):
        print("咯咯咯")


    def dan(self):
        print('下鸡蛋')


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


    def dan(self):
        print('下鸭蛋')


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


    def dan(self):
        print('下鹅蛋')


def guanli(name):
    name.dan()



a = Ji()
b = Duck()
c = E()
guanli(a)
guanli(b)
guanli(c)

2.类相关的内置函数

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

# isinstance
flag = isinstance('5',str)
print(flag)  # True
def add_num(a,b):
    if isinstance(a,int) and isinstance(b,int):
        return a + b
    else:
        print("需传入整形")
        return None

add_num('u','s') # 需传入整形

　　2. issubclass 判断一个类是否时另一个类的子类   参数1 子类  参数2 父类

class A:
    pass

class B(A):
    pass

class C:
    pass

print(issubclass(B,A))  # True
print(issubclass(C,A))  # False
a = A()
b = B()
print(issubclass(type(b),type(a)))  # True

3.魔法方法:

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

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

    def __str__(self):
        return f"这是一个Person类对象,name:{self.name},age:{self.age}" 

jay = Person('jay',23)
print(jay)   # 这是一个Person类对象,name:jay,age:23

　　2.__del__: 手动删除对象时立马执行,程序运行结束对象释放时也会执行,如操作文件,网络端口

class FileTool:
    def __init__(self,path):
        self.f = open(path,'r',encoding='utf-8')
    
    def read(self):
        return self.f.read()
    
    # 当程序运行结束,对象释放,确定对象不再使用.自动关闭文件
    def __del__(self):
        self.f.close()

tool = FileTool('a.txt')
print(tool.read())   # 读完文件,对象释放,自动关闭文件

　　3.__call__: 再对象调用时自动执行,即对象加括号

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

b = B()   
b(11,name='hahaha')
# call run
# (11,)
# {'name': 'hahaha'}

　　4.__slots__: 优化对象内存占用,优化的原理是限定了属性的个数,解释器不再会为这个对象创建名称空间,所以__dict__也没了

class A:
    __slots__ = ['name']  # 限制此类只能有一个属性
    def __init__(self,name):
        self.name = name



b = A('小明')
print(b.name)   # 小明
print(b.age)  # 报错

5.运算符重载: 重新定义运算符的含义,通常用于自定义对象的比较规则时,就可以重载运算符

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)

6.迭代器协议: 迭代器时指具有__iter__和__next__的对象,我们可以利用这点创造迭代器对象

class MyRange:

    def __init__(self,start,end,step):
        self.start = start - step
        self.end = end
        self.step = step

    def __iter__(self):
        return self

    def __next__(self):
        self.start += self.step
        if self.start < self.end:
            return self.start
        else:
            raise StopIteration

for i in MyRange(0,20,2):
    print(i,end=' ')

7.上下文管理:上下问可以理解为时一个代码取键.一个范围

　　enter : 表示进入上下文

　　exit : 表示退出上下文

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

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

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

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

相关推荐