面向对象复习

# type(obj) 结果:这个对象所属的类
# type(类)  结果:创建这给类的元类,默认就是type.指定metaclass
# type是所有类的元类,object是所有类的父类
# 类也是被创建出来的,type创建类,type(cls)=type
# class A(metaclass=ABCMeta) ABCMeta创建了A类,ABCMeta是A的元类

1 from abc import ABCMeta, abstractmethod
2 class A(metaclass=ABCMeta):pass
3 class B():pass
4 print(type(A))  # <class 'abc.ABCMeta'>
5 print(type(B))  # <class 'type'>

# 类是执行的时候被加载的, 类名是在加载后生效的

1 class Human:
2     ROLE = "CHINA"
3     # print(Human.ROLE)  # 报错
4     print(ROLE)
5     def fun(self):
6         print("abc")

# 组合:一个类对象是另一个类对象的属性

　　什么(人类)有什么(武器类)的关系

# 继承

　　# 单继承 和 多继承

　　super : 不用自己传self参数  super(子类, self).方法名(除了self之外的参数)

　　父类名 : 父类名.方法名(self, ...)

 1 class Foo:
 2     def __init__(self):
 3         self.func()
 4 
 5     def func(self):
 6         print("Foo.func")
 7 
 8 class Son(Foo):
 9     def func(self):
10         print("Son.func")
11 
12 son = Son()

 　　# 多继承

　　　　#新式类: 广度优先 -C3算法

　　　　　　# py3 默认继承object,所以py3都是新式类

　　　　　　　　# super().func() 遵循mro算法,在类的内部不用传子类名和self

　　　　　　# py2x需要主动继承object

　　　　　　　　# super(子类名, self).func()b必须传子类名和self

　　　　　　# mro方法查看继承顺序

　　　　#经典类: 深度优先

　　　　　　# py2 不继承object,默认都是经典类

　　　　　　# 没有mro

 1 class A:
 2     def func(self):
 3         print("A")
 4 
 5 class B(A):
 6     def func(self):
 7         super().func()
 8         print("B")
 9 
10 class C(A):
11     def func(self):
12         super().func()
13         print("C")
14 
15 class D(B, C):
16     def func(self):
17         super().func()
18         print("D")
19 
20 d = D()
21 d.func()
22 
23 # MRO : DBCA
24 # 打印结果 : ACBD

 # 抽象类(接口类)

 

1 from abc import ABCMeta, abstractmethod
2 
3 class Payment(metaclass=ABCMeta):  # 抽象类(接口类)
4     '''强制制定一个规范，凡是继承我的类中必须要有pay方法，如果没有，实例化对象的时候就会报错'''
5     @abstractmethod
6     def pay(self): pass  # 制定了一个规范

 

# 多态
    # 一种类型的多种形态,多个子类去继承父类,那么每一个子类都是这个父类的一种形态

# property 装饰器函数,内置函数,赞助你将类中的方法伪装成属性
# @方法名.setter 装饰器,修改被property装饰的属性的时候会被调用被这个装饰器装饰的方法,除了self之外还有一个参数,被修改的值
# @方法名.deleter 装饰器,当要删除被property装饰的属性的时候会被调用被这个装饰器装饰的方法

# classmethod类方法

 1 # classmethod 类方法的装饰器 内置函数
 2 # 使用类名调用,默认传类名作为第一个参数
 3 # 不用对象命名空间的内容,而用到了类命名空间中的变量(静态属性),或者类方法或者静态属性
 4 class Goods:
 5     __discount = 0.8
 6     def __init__(self, price):
 7         self.__price = price
 8 
 9     @property
10     def price(self):
11         return self.__price * Goods.__discount
12 
13     @classmethod
14     def change_discount(cls, num):
15         cls.__discount = num
16 
17 apple = Goods(10)
18 banana = Goods(15)
19 print(apple.price, banana.price)
20 Goods.change_discount(1)
21 print(apple.price, banana.price)

# staticmethod

 1 # staticmethod 静态方法的装饰器 内置函数
 2 # 如果一个类里面的方法,既不需要用到self中的资源,页不用cls中的资源
 3 # 相当于一个普通的函数
 4 # 但是你由于某种原因,还要把这个方法放在类中,这个时候,就将这个方法变成一个静态方法
 5 # 某种原因
 6     # 1. 完全想用面向对象编程,所有的函数都必须写到类里
 7     # 2. 某个功能确确实实是这个类的方法,但是确确实实没有用到和这个类有关系的资源
 8 # 学生 管理员
 9 # 课程 班级
10 class Person:
11     @staticmethod
12     def login():  #  动词 动作 属于每一个对象
13         pass
14 class Student(Person):pass
15 class Manager(Person):pass
16 class Course:pass
17 class Classes:pass

 

 

转载于:https://www.cnblogs.com/arley520/p/11521384.html