组合
自定义类的对象作为另外一个类的属性
class Teacher:
def __init__(self, name, age):
self.name = name
self.age = age
t1 = Teacher("Ben", 17)
class Student:
# 学生可以有 老师 属性
def __init__(self, name, age, teacher):
self.name = name
self.age = age
# 组合
self.teacher = teacher
stu = Student('Bob', 18, t1)
# 访问老师具体的信息
print(stu.teacher.name)
print(stu.teacher.age)
接口
接口：建立关联的桥梁，方便管理代码
接口类：用来定义功能的类，为继承它的子类提供功能的，该类的功能方法一般不需要有实现体，实现体有继承它的子类自己去实现
# 提供所有宠物应该有的功能
class PetInterface:
def close_master(self):pass
# 提供所有看门应该有的功能
class WatchInterface:
def watch_door(self):pass
# 没有去继承PetInterface，WatchInterface的Dog就是普通的Dog类
# 但继承了PetInterface，该Dog就可以作为宠物狗，同理继承WatchInterface就可以作为看门狗
class Dog(PetInterface, WatchInterface):
def speak(self):
print('汪汪汪')
def eat(self):
print('吃狗粮')
def run(self):
print('狗在跑')
# 一定要重写接口的方法
def close_master(self):
print('这是一只宠物狗!')
# 可以作为宠物及看门猫
class Cat(PetInterface, WatchInterface): pass
dog = Dog()
dog.speak()
dog.run()
dog.eat()
dog.close_master()
dog.watch_door()
'''
输出：
汪汪汪
狗在跑
吃狗粮
这是一只宠物狗!
'''
抽象父类
抽象父类：拥有抽象方法(子类共有的方法，但是父类不能有具体的实现体)的父类
抽象方法：方法名是具体的，但是实现体是抽象的(在子类中重写来具象化)
注意点：有抽象方法的父类不能被实例化（假设能被实例化，就可以调用自己的抽象方法，没有任何意义）
# 实现抽象父类的语法
import abs# abstract base class
class Sup(metaclass=abc.ABCMeta):
抽象父类中的抽象方法，在继承它的子类中必须有自己的实现体
-- 抽象父类中的抽象方法实现体就没有意义，实现与不实现都是pass填充
@abc.abstractmethod
def func(self): pass
class Sub(Sup):
def func(self):
# 必须重写父类的抽象方法
# 案例
import abc
class Quan(metaclass=abc.ABCMeta):
def __init__(self, name):
self.name = name
# 共有方法，子类继承就可以了
def run(self):
print(self.name + 'running')
# 抽象方法：子类必须重写
@abc.abstractmethod
def chi(self): pass
@abc.abstractmethod
def jiao(self): pass
class Dog(Quan):
def kanmen(self):
print(self.name + '看门')
def chi(self):
super().chi()
print(self.name + '狗粮')
def jiao(self):
print('汪汪汪')
class Wolf(Quan):
def bulie(self):
print(self.name + '捕猎')
def chi(self):
print(self.name + '肉')
def jiao(self):
print('嗷嗷嗷')
dog = Dog('来福')
wolf = Wolf('呵呵')
dog.jiao()
wolf.jiao()
dog.run()
wolf.run()
'''
输出：
汪汪汪
嗷嗷嗷
来福running
呵呵running
'''
了了解
# 抽象的类方法
import abs
class Sup(metaclass=abc.ABCMeta):
@classmethod
@abc.abstractmethod
def func(cls): pass
class Sub(Sup):
@classmethod
def func(self):
# 必须重写父类的抽象方法
格式化方法与析构方法
格式化方法：在外界打印该类对象是被调用
析构方法：在对象被消耗的那一刹那被调用，在被消耗前可以做一些事情
class A:
def __init__(self, name, age):
self.name = name
self.age = age
# 格式化方法：在外界打印该类对象是被调用
# 格式化外界直接打印该类对象的字符串表示结果
def __str__(self):
# return 'abc' # 外界打印A类的对象，都打印 字符串 abc
# return super().__str__() # 系统默认的在父类中返回的是对象存放的地址信息
return '<name:%s | age:%s>' % (self.name, self.age) # 根据对象实际的属性格式化具体的输出内容
# 析构方法：在对象被消耗的那一刹那被调用，在被消耗前可以做一些事情
def __del__(self):
# del会在self代表的对象被消耗的时候被调用
# 我们可以在析构函数中释放该对象持有的其他资源，
# 或者将一些持有资源持久化(保存到文件或数据库中)
del self.name # 也可以将name存起来
a = A('老王', 88)
print(a, type(a))
import time
time.sleep(5)
print('文件马上执行完毕，a就会被销毁')
了解
class B:
# 了解：对象.语法的内部实现
def __setattr__(self, key, value):
self.__dict__[key] = value # 系统默认实现，在名称空间添加名字
# self.__dict__[key] = value.lower() # 可以自定义处理一些内容
# 了了解：将对象添加属性的方式可以同字典形式
def __setitem__(self, key, value):
self.__dict__[key] = value
b = B()
# 设置
b.name = 'BBB' # 内部走的是 __setattr__
b['age'] = 18 # 内部走的是 __setitem__
# 访问
print(b.name)
print(b.age)
反射
反射：通过字符串与类及类的对象的属性(方法)建立关联
class A:
num = 10
print(hasattr(A, 'num'))
res = getattr(A, 'num', '默认值')
print(res)
delattr(A, 'num')
print(setattr(A, 'tag', 10))
# 类的属性类来操作
class B:
def __init__(self, name):
self.name = name
print(hasattr(b, 'name'))
print(getattr(b, 'name', '对象的属性类不能获取'))
delattr(b, 'name')
print(setattr(b, 'age', 18))
# 对象的属性对象来操作
class C:
def fn(self):
print('fn')
@classmethod
def func(cls):
print('func')
fn = getattr(C, 'fn')
c = C()
fn(c) # 类获取对象方法调用时传入具体的对象
obj_fn = getattr(c, 'fn')
obj_fn() # 对象获取对象方法调用时不用传参
func = getattr(C, 'func')
func() # 类获取类方法调用时不需要传入参数