21，钻石继承，多态，封装，几个装饰器函数
组合 什么有什么的关系
# 一个类的对象作为另一个类对象的
# 继承
# 子类可以使用父类中的名字（静态属性 方法）
# 抽象类和接口类 ：
# 只能被继承不能被实例化
# 子类必须实现父类中的同名方法——规范代码
# metaclass = ABCMeta 、@abstractmethod
# python支持多继承，对于python来说抽象类和接口类没有区别
# 接口类是python特有的，因为python直接用类就可以实现接口的效果
# python没有“接口”这种数据类型，java中有
钻石继承
class A(object): def func(self): print('in A') class B(A): def func(self): print('in B') class C(A): def func(self): print('in C') class D(B,C): def func(self): print('in D') D.func(1) B.func(1) print(B.mro()) print(D.mro()) in D in B [<class '__main__.B'>, <class '__main__.A'>, <class 'object'>] [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
找一个名字，如果这个名字在子类不存在，就会遵循一个顺序往上找。继承关系会形成一张图，每个类都是这个途中的节点寻找顺序会把途中的每一个节点都找，且只找一次——遍历算法
Python3中里面的所有类都是新式类，新式类的遍历算法——遵循广度优先规律
找下一个点的时候，首先往深度走，但是如果这个深度的类，以后还会有机会找到，那么，就从广度找。
print（类.mro）能够查找子类之间的寻找顺序。
super并不是单纯的找父类，和mro顺序是完全对应的。
class A(): def func(self):print('in,A') class B(A): def func(self):print('in,B') class C(A): def func(self):print('in,C') class D(B): def func(self):print('in,D') class E(C): def func(self):print('in,E') class F(D,E): def func(self):print('in,F') print(F.mro()) [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
python3： 新式类：python3里全部都是新式类，新式类默认继承object。
python2：经典类：不主动继承object——遵循深度优先遍历算法，没有mro方法，也没有super方法。
新式类：主动继承object
多态
python天生自带多态
java多态 class Foo:pass class list(Foo):pass class dict(Foo):pass class str(Foo):pass def len(a): print(a) len(1)
封装
封装：面向对象的的特性
私有静态属性
# __静态属性 = 'aaa' # 私有的静态属性 # print(__静态属性) # __静态属性，_类名__名字 # 在一个变量之前 加上两个双下划线是有特殊意义的 # 加上了这个双下划线，这个变量就变成了私有的 # print(A.__静态属性) # 报错 私有的名字不能在类的外部使用 # print(A.__dict__) # # print(A._A__静态属性) # 从语法的角度上不允许你直接调用的 A.__wahaha = 'hahaha' # 在一个类的外部是不可能定义一个私有的名字的 print(A.__dict__)
私有对象属性
class Room: def __init__(self,owner,id,length,width,height): self.owner = owner self.id = id self.__length = length self.__width = width self.__height = height def area(self): return self.__length * self.__width r = Room('杰哥哥',302,2,1.5,0.5) print(r.area())
@property（将一个方法，伪装成一个属性）
from math import pi class Circle: def __init__(self,r): self.r = r @property def area(self): return self.r**2*pi @property def perimeter(self): return 2*pi*self.r c = Circle(5) # c.r print(c.area) # ==> c.area() print(c.perimeter) # 将一个方法伪装成一个属性
class Person: def __init__(self,name): self.__name = name # self.name = name @property def name(self): return self.__name @name.setter def name(self,new): if type(new) is str: self.__name = new alex = Person(444) print(alex.name) alex.name = 'sb' # 能不能改？ —— 不能直接改 print(alex.name)
class Demo: def __init__(self,wahaha): self.__wahaha = wahaha @property # wahaha = property(wahaha) def wahaha(self): print('in wahaha') return self.__wahaha @wahaha.setter # wahaha = wahaha.setter(wahaha) # 也是一个装饰器方法 def wahaha(self,new): self.__wahaha = new d = Demo('wahaa') print(d.wahaha) # 可以被查看 d.wahaha = 123 # 可以被修改 print(d.wahaha)
class A: def __init__(self,path): self.__f = open(path,'w') @property def f(self):return self.__f @f.deleter def f(self): # 所有的借用操作系统的资源，在删除一个变量之前都必须先归还资源 self.close() del self.__f def write(self,content): self.__f.write(content) def close(self): self.__f.close() obj = A('wahaha') obj.write('wahahayawahaha') obj.close() del obj.f # f变量删除，文件没有关 print(obj.f)
@staticmethod
class Student: def __init__(self,name,sex): self.name = name self.sex = sex @staticmethod # 相当于函数 def login(): name = input('>>') if name == 'alex':print('登录成功') # 学生的登陆行为 Student.login()
# method 方法 —— 函数 由实例化对象去调用
# property 伪装成属性的方法 —— 特性 由实例化对象去调用
# classmethod 类方法 由类调用,只使用类中的静态变量
# staticmethod 静态方法 由类调用,一个方法既不会用到对象的属性，也不会用到类的属性
