一、多态

例如：水有固态、气态、液态三种形态

多态就是，多个不同类对象可以响应同一个方法，产生不同的结果。多态不是一种特殊的语法，而是一种状态，特性。即多个不同的对象可以响应同一个方法，产生不同的结果也就是多个对象有相同的方法

好处：对于使用使用者而言。大大的降低了使用难度

二、实现多态

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

案例：要管理 鸡 鸭 鹅如何能够最方便的管理,就是我说同一句话,他们都能理解既它们拥有相同的方法

1 class Chicken: 2     def bark(self): 3         print('咕咕咕') 4  5     def spawn(self): 6         print('下鸡蛋') 7  8 class Duck: 9     def bark(self):10         print('嘎嘎嘎')11 12     def spawn(self):13         print('下鸭蛋')14 15 class E:16     def bark(self):17         print('鹅鹅鹅')18 19     def spawn(self):20         print('下鹅蛋')21 22 23 def manage(obj):24     obj.spawn()25 26 a = Chicken()27 b = Duck()28 c = E()29 30 manage(a)31 manage(b)32 manage(c)

python中到处都有多态!

三、OOP相关的内置函数

1.isinstance

检查是否obj是否是类 cls 的对象

1 def add_num(a,b):2     if isinstance(a,int) and isinstance(b,int):3         return a + b4     return None5 print(add_num(10,5))

2.issubclass

判断一个类是否是另一个类的子类

参数一是子类，参数二是父类

class Animal:    def eat(self):        passclass Pig(Animal):    def eat(self):        print('猪吃猪饲料')class Tree():    def life(self):        print('树要进行光合作用')def manage(obj):    if issubclass(type(obj),Animal):        obj.eat()    else:        print('不是动物！')p = Pig()t = Tree()manage(p)manage(t)

3.str

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

1 class Person: 2     def __init__(self,name,age): 3         self.name = name 4         self.age = age 5  6     def __str__(self): 7         return '这是一个person对象,name:%s,age:%s'%(self.name,self.age) 8  9 p = Person('jack','20')10 print(p)

4.del

使用时机：手动删除对象时立马执行，或是程序运行结束时也会自动执行

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

1 class FileTool: 2     def __init__(self,path): 3         self.file = open(path,'rt',encoding='utf-8') 4  5     def read(self): 6         return self.file.read() 7  8     def __del__(self): 9         self.file.close()10 11 f = FileTool('test.txt')12 13 print(f.read())

5.call

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

1 class A:2     def __call__(self,*args,**kwargs):3         print('call run')4         print(args)5         print(kwargs)6 7 a = A()8 9 a(1,2,3,a=4)

6.slots

优化内存，限制属性

1 class Person:2     __slots__ = ['name']3     def __init__(self,name,age):4         self.name = name5       6 p = Person('zzj',18)

7.__setattr__、__delattr__、__getattr__、__getattribute__

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

setattr 用点设置属性

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

getattribute该函数也是用来获取属性的，在获取属性时如果存在getattribute则先执行该函数，如果没有拿到属性则继续调用getattr函数，如果拿到了则直接返回

1 class A: 2  3     def __setattr__(self, key, value): 4         print('__setattr__') 5         self.__dict__[key] = value 6  7     def __delattr__(self, item): 8         print('__delattr__') 9         self.__dict__.pop(item)10 11     def __getattr__(self, item):12         print('__getattr__')13         return self.__dict__[item]14 15     def __getattribute__(self, item):16         print('__getattribute__')17         return super().__getattribute__(item)18 19 20 a = A()21 a.name = 'jason'22 print(a.name)

8.[]的实现原理

getitem setitem delitem

任何的符号都会被解释器解释成特殊含义，例如：. [] ()

getitem 当你用中括号去获取属性时执行

setitem 当你用中括号去设置属性时执行

delitem 当你用中括号去删除属性时执行

1 class A: 2     def __getitem__(self, item): 3         print('__getitem__') 4         return self.__dict__[item] 5  6     def __setitem__(self, key, value): 7         print('__setitem__') 8         self.__dict__[key] = value 9 10     def __delitem__(self, key):11         print('__delitem__')12         del self.__dict__[key]13 14 a = A()15 a['name'] = 'jerry'16 print(a['name'])17 del a['name']

9.运算符重载

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

1 class Student: 2     def __init__(self,name,height,age): 3         self.name = name 4         self.height = height 5         self.age = age 6  7     def __gt__(self, other): 8         return self.height > other.height 9 10     def __lt__(self, other):11         return self.height < other.height12 13     def __eq__(self, other):14         return self.height == other.height15 stu1 = Student('zzj',180,18)16 stu2 = Student('lzx',150,30)17 18 print(stu1 > stu2)19 print(stu1 < stu2)20 print(stu1 == stu2)

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

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

10.迭代器协议

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

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

1 class MyRange: 2  3     def __init__(self,start,end,step): 4         self.start = start 5         self.end = end 6         self.step = step 7  8     def __iter__(self): 9         return self10 11     def __next__(self):12         a = self.start13         self.start += self.step14         if a < self.end:15             return a16         else:17             raise StopIteration18 for i in range(1,10,2):19     print(i)

11.上下文管理

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

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

涉及到的两个方法：

enter：表示进入上下文，（进入某个场景了）

exit：表示退出下文，（退出某个场景了）

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

1 class MyOpen: 2     def __init__(self,path): 3         self.path = path 4  5     def __enter__(self): 6         self.file = open(self.path) 7         return self 8  9     def __exit__(self, exc_type, exc_val, exc_tb):10         self.file.close()11 12 with MyOpen('test.txt') as f:13     print(f.file.read())

　　enter函数应该返回对象自己

　　exit函数 可以有返回值，是一个bool类型

　　如果为True，则意味着，异常已经被处理了

　　False，异常未被处理，程序将中断报错