面向对象三大特性之多态以及面向对象进阶

1.多态

概念:一种事物具备多种不同的形态

例如:水有三种形态

面向对象中的多态:多个不同类对象可以响应同一个方法,产生不同的结果

多态不是一种特殊的语法,而是一种状态,特性(多个对象有相同的使用方法)

优点:对于使用者,可以降低使用难度

 

实现多态

接口,抽象类,鸭子类型都可以实现多态,最简单的就是鸭子类型

鸭子类型实现多态例子

# 鸭子类型产生几个类
class Ji:
    def bark(self):
        print('咕咕咕')

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

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

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


class E:
    def bark(self):
        print('鹅鹅鹅')

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

# 定义一个调用他们的方法
def manage(obj):
    obj.bark()
    obj.spawn()

j = Ji()
y = Duck()
e = E()

manage(j)  # 多个不同的对象都可以使用manage的方法,产生不同的结果
manage(y)
manage(e)

在python中许多内置方法也是多态的表现形式

# python中很多内置方法也是多态的表现形式
a = 1
b = 'sxc'
c = [1,5,'xxx']
# type,不同的对象拥有相同的方法,print其实也是多态的表现
print(type(a))
print(type(b))
print(type(c))

 

2.OOP相关的内置函数

(1)isinstance(obj,cls)

检查是否obj是类cls的对象,判断一个对象是否是某个类的实例

# isinstance(obj,cls)
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

p1 = Person('sxc',18)

p2 = ('sxc',18)

print(isinstance(p1,Person))  # 判断是否是该类的对象
print(isinstance(p2,Person))

print(isinstance(p2[0],str))  # 还可以判断是否为基本类型,p2的第一个参数是'sxc'
print(isinstance(p2[1],int))  # p2的第二个参数是18,是int类型

(2)issubclass(sub,super)

 检查sub类是否是super的子类(派生类),判断一个类是否是另一个类的子类

# issubclass(sub,super)
class Animal:
    def __init__(self,name,age):
        self.name = name
        self.age = age

class Person(Animal):
    def speak(self):
        print('人说话')

class Student(Person):
    def study(self):
        print('学生学习')

class Dog(Animal):
    def bark(self):
        print('狗叫')

print(issubclass(Student,Animal))  # 判断是否为某一个类的子类
print(issubclass(Dog,Animal))  # 是
print(issubclass(Student,Person))  # 是
print(issubclass(Dog,Person))  # 否

3.类中的魔法函数

(1)__str__

执行时机:会在对象被转换成字符串时执行,转换的结果就是这个函数的返回值

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

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

    def __str__(self):  # 自定义对象的打印格式
        return '姓名:%s,年龄:%s'%(self.name,self.age)

p1 = Person('sxc',18)
print(p1)  # 如果没有__str__函数返回值是该对象的内存地址.<__main__.Person object at 0x000001C339547278>
print(p1)  # 利用该函数获取自己想要的返回值.姓名:sxc,年龄:18

作业:1.编写class类,拥有name,teacher,cursor三个属性,自定义打印格式输出,对象的全部属性

class School:
    def __init__(self,name,teacher,course):
        self.name = name
        self.teacher = teacher
        self.course = course

    def __str__(self):
        return '学校名:%s,老师名:%s,课程名:%s'%(self.name,self.teacher,self.course)

s1 = School('oldboy','tank','python10期')
print(s1)

(2)__del__析构函数

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

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

# __del__
class FileTool:
    def __init__(self,path):
        self.file = open(path,'r',encoding='utf-8')

    def read(self):  # 打开文件之后py解释器不会主动的关闭文件
        return self.file.read()

    def __del__(self):  # 该方法在程序运行完毕之后自动执行
        self.file.close()  # 通过上述条件,确定我们不再复用该文件,可以在这关闭文件
        print('关闭文件')  # 证明程序最后会执行该方法

tool = FileTool('a.txt')
print(tool.read())

(3)__call__

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

# __call__
class A:
    def __call__(self, *args, **kwargs):  # 在调用对象时执行
        print('运行call')
        print(args)  # 调用对象时传入的参数,单个参数
        print(kwargs)  # 传入的字典类型

a = A()
# a()
# a(18)
a(18, name = 'sxc')  # 对象名+()自动触发

(4)__slots__优化内存

该属性是一个类属性,用于优化内存占用

优化的原理:将原本不固定的属性数量变的固定,从而达到减少内存开销的效果

需要注意的是这个方法会把__dict__都取消,并且当使用这个方法时,将导致这个类的对象无法添加新的属性

# __slots__
import sys

class A:
    __slots__ = ['name']  # 在声明属性时使用,中括号内的就是生成的属性,
    # 并且只会产生括号中属性的名称空间

    def __init__(self,name):
        self.name = name
        print(name)
        # print(self.__dict__)  # 内部也不能查看

a = A('sxc')

# print(a.__dict__)  # 使用该方法时__dict__也被取消,会报错
# a.age = 18  # 并且不能添加新的属性

print(sys.getsizeof(a))  # 查看对象的内存占用,当没有__slots__方法时为56
print(sys.getsizeof(a))  # 查看对象的内存占用,有该方法时为48,内存确实被优化了

4.点. 括号[]语法的实现原理

(1)点.语法的实现原理(getattr,setattr,delattr)

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

setattr:用点设置属性时执行

delattr:用del 对象.属性, 删除属性时执行

getattribute:该函数也是用来获取属性

在获取属性时,如果存在getattribute则先执行该函数,如果没有返回值,则再执行getattr,如果有返回值,则直接返回

# 点属性的实现原理getattr,setattr,delattr,getattribute
class A:
    def __getattr__(self, item):  # 该函数有返回值
        print('执行了__getattr__')
        return '__getattr__的返回值'  # 该返回值只有属性没有返回值才会执行

    def __setattr__(self, key, value):
        print('执行了__setattr__')
        self.__dict__[key] = value  # 这就是点设置值语法的实现原理

    def __delattr__(self, item):
        print('执行了__delattr__')
        self.__dict__.pop(item)  # 这就是点删除值语法的实现原理

    def __getattribute__(self, item):
        # print('__getattribute__')
        return super().__getattribute__(item)  # 这就是点获取值语法的实现原理

a = A()

# 点语法内部是调用__dict__进行增删查改的操作
a.name = 'sxc'  # 执行了setattr
# print(a.name)  # 执行了getattr,并且有返回值
print(a.name)  # 当有两个get方法时会先执行getattribute,没有返回值的情况下再执行getattr
del a.name  # 执行了delattr

print(a.xxx)  # 属性不存在的情况下执行getattr

点语法的实现原理是在上述方法里__dict__里加入新的值

(2)括号[]语法的实现原理(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):
        print('__delitem__')
        self.__dict__.pop(key)  # 这就是括号删除值语法的实现原理


a = A()
a['name'] = 'sxc'  # 可以括号赋值
print(a['name'])  # 可以括号取值
del a['name']  # 可以括号删值

可以使用点语法又可以使用括号语法

classes = {}
class Student(dict):
    def __getattr__(self, item):
        return self.get(item)

    def __setattr__(self, key, value):
        self[key] = value

    def __delattr__(self, key):
        del self[key]

s1 = Student()
s1['name'] = 'zzp'
print(s1.name)

s1.age = 28
print(s1['age'])

s1['classes'] = 'py10期'
print(s1.classes)

 

5.运算符重载

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

class Student:
    def __init__(self,name,age,height,weight):
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

    def __gt__(self, other):  # 大于
        return self.age > other.age

    def __lt__(self, other):  # 小于
        return self.height < other.height

    def __eq__(self, other):  # 等于
        return self.weight == other.weight

s1 = Student('sxc',18,175,60)
s2 = Student('zzj',20,174,60)


print(s1 > s2)  # 比较年龄
print(s1 < s2)  # 比较身高
print(s1 == s2)  # 比较体重

 作业2:创建一系列student对象存储到列表中, 然后编写排序算法,将对象按照年龄排序,排序算法不限

# 运算符重载
# 创建一系列student对象存储到列表中, 然后编写排序算法,将对象按照年龄排序,排序算法不限
class Student:
    def __init__(self,name,age,height,weight):
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

    def __gt__(self, other):  # 大于
        return self.age > other.age

    def __lt__(self, other):  # 小于
        return self.age < other.age

    def __eq__(self, other):  # 等于
        return self.weight == other.weight

s1 = Student('sxc',18,175,60)
s2 = Student('zzj',20,174,60)
s3 = Student('zzp',21,156,50)
s4 = Student('lzx',17,156,50)
s5 = Student('zkj',25,156,50)

# print(s1 > s2)  # 比较年龄
# print(s1 < s2)  # 比较身高
# print(s1 == s2)  # 比较体重


all_student = []
all_student.append(s1)
all_student.append(s2)
all_student.append(s3)
all_student.append(s4)
all_student.append(s5)

for i in range(len(all_student)):
    for j in range(i+1,len(all_student)):
        if all_student[i] > all_student[j]:
            all_student[i],all_student[j] = all_student[j],all_student[i]

for i in all_student:
    print(i.name)

6.迭代器协议

迭代器指的是具有__iter__和__next__的对象

我们可以为对象增加这两个方法来让对象变成一个迭代器

# 迭代器
class MyIter:
    def __init__(self,num):  # num用来限制迭代次数
        self.num = num
        self.c = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.c < self.num:  # 加上逻辑判断来限制迭代次数
            self.c += 1
            return '123'
        else:
            raise StopIteration

for i in MyIter(10):
    print(i)

自定义编写一个range方法

# 实现一个自定义的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.start += self.step
        if a < self.end:
            return a
        else:
            raise StopIteration

for i in Myrange(1,10,2):
    print(i)

7.上下文管理

指的是一段话的意义,要参考当前的场景,即上下文

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

两个方法

enter:表示进入上下文

exit:表示退出上下文

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

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

class Myopen:
    def __init__(self,path):
        self.path = path

    def __enter__(self):
        print('__enter__')
        self.file = open(self.path)
        return self  # 需要返回自己

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('__exit__')
        self.file.close()
        return True  # 返回错误有没有处理

with Myopen('a.txt') as m:
    print(m.file.read())

注意:

enter函数应该返回对象自己

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

与del的区别:

　　上下文关联,管理的是一个代码范围,出了范围自动清理

　　del管理的是对象的生命周期,会在对象销毁时执行清理

 23