python学习基础第一阶段day13

多继承

一个子类继承两个或两个以上的基类，父类中的属性和方法同时被子类继承下来。
同名方法的解析顺序（MRO， Method Resolution Order）:
类自身 --> 父类继承列表（由左至右）--> 再上层父类
   A
  / \
 /   \
B     C
 \   /
  \ /
   D 

class A:
def func01(self):
print(“A – func01”)

class B(A):
def func01(self):
print(“B – func01”)

class C(A):
def func01(self):
print(“C – func01”)

class D(C, B):
def func01(self):
print(“D – func01”)

B.func01(self)

d = D()
d.func01()

内置可重写函数

Python中，以双下划线开头、双下划线结尾的是系统定义的成员。我们可以在自定义类中进行重写，从而改变其行为。

转换字符串

__str__函数：将对象转换为字符串(对人友好的)
__repr__函数：将对象转换为字符串(解释器可识别的)

class Wife:
def init(self, name, face_score, money):
self.name = name
self.face_score = face_score
self.money = money

# 重写__str__作用是：定义当前对象转换的字符串格式
#                  显示对象时使用（没有格式限制）
def __str__(self):
    return "臣妾%s,颜值%d,存款%f." % (self.name, self.face_score, self.money)

# 重写__repr__作用是：定义当前对象转换的字符串格式
#                   克隆当前对象（python语法格式）
def __repr__(self):
    return 'Wife("%s", %d, %f)' % (self.name, self.face_score, self.money)

w01 = Wife(“双儿”, 100, 50000)
message = w01.str()
print(message) # <main.Wife object at 0x7ff8a3224cf8>
w02 = Wife(“阿珂”, 150, 20000)
print(w02)

str_code = w01.repr()
# eval:将字符串作为python代码执行
w03 = eval(str_code) # 克隆老婆对象
w01.name = “双双”
print(w03.name)

运算符重载

	定义：让自定义的类生成的对象(实例)能够使用运算符进行操作。

class Vector2:
def init(self, x=0, y=0):
self.x = x
self.y = y

def str(self):
return “向量的x分量为%d,y分量为%d” % (self.x, self.y)

def add(self, other):
return Vector2(self.x + other.x, self.y + other.y)

def iadd(self, other):
self.x += other.x
self.y += other.y
return self
# 比较相同
def eq(self, other):
return self.x == other.x and self.y == other.y

# 比较大小
def lt(self, other):
return self.x < other.x

pos = Vector2(10, 25)
dir = Vector2(1, 0)
print(pos + dir) # pos.add(dir)
pos += dir
print(pos)

# list01 = [10]
# list01 += [20]# 在原有对象中添加新元素（在原有可变对象上修改）
# print(list01) # [10, 20]

# list02 = [10]
# list02 = list02 + [20] # 创建了新对象
# print(list02) # [10, 20]

v01 = Vector2(100, 200)
v02 = Vector2(100, 200)
print(v01 == v02) #
list_vectors = [
Vector2(200, 200),
Vector2(400, 400),
Vector2(100, 100),
Vector2(300, 300),
Vector2(500, 500),
]
print(list_vectors.count(Vector2(100, 100)))
for item in sorted(list_vectors):
print(item)

技能系统：

"""
    技能系统
    叙述
        三大特征
            封装：根据技能策划案划【分】为技能释放器、伤害生命类、消耗法力类、降低防御力类..
            继承：使用影响效果类【隔】离技能释放器与具体影响效果的变化
            多态：技能释放器调用影响效果,具体影响效果重写影响方法,根据配置文件创建具体影响效果
                        调父　　　　　　　　　重写　　　　　　　　　　　创建子
                　高扩展(增加新影响效果,技能释放器不改变)
                　　　　　　　　【做】
        六大原则
            开闭：增加新影响效果,技能释放器不改变
            单一：
                具体影响效果：实现某一种效果算法
                技能释放器：根据配置文件，执行释放技能.
            依赖倒置：技能释放器调用影响效果，不调用伤害生命类...
            组合复用：技能释放器通过变量调用各种影响效果
            里氏替换：看见爹传子
            　　　　　扩展重写
            迪米特：各个类之间都是低耦合
"""


class ImpactEffect:
    """
        影响效果,隔离技能释放器与具体效果（眩晕，降低速度...）
    """

    def impact(self):
        pass


class CostSPEffect(ImpactEffect):
    def __init__(self, value=0):
        self.value = value

    def impact(self):
        super().impact()
        print("消耗%d法力" % self.value)


class DamageEffect(ImpactEffect):
    def __init__(self, value=0):
        self.value = value

    def impact(self):
        super().impact()
        print("伤害%d生命" % self.value)


class LowerDeffenseEffect(ImpactEffect):
    def __init__(self, value=0, duration=0):
        self.value = value
        self.duration = duration

    def impact(self):
        super().impact()
        print("降低%f防御力,持续%d秒" % (self.value, self.duration))


class SkillDeployer:
    """
        技能释放器
    """

    def __init__(self, name=""):
        self.name = name
        self.__config_file = self.__load_config_file()
        self.__list_effects = self.__create_impact_effects()

    def __load_config_file(self):
        # 模拟配置文件读取后的数据结构
        return {
            "毁天灭地": ["CostSPEffect(200)", "DamageEffect(800)"],
            "降龙十八掌": ["CostSPEffect(150)", "DamageEffect(600)", "LowerDeffenseEffect(0.5,10)"],
        }

    def __create_impact_effects(self):
        # 技能名称ｋ ---> 效果名称列表v
        list_effect_names = self.__config_file[self.name]
        # 创建子类对象()
        # list_effect_objects = []
        # for itme in list_effect_names:
        #     effect_obj = eval(itme)
        #     list_effect_objects.append(effect_obj)
        # return list_effect_objects
        return [eval(itme) for itme in list_effect_names]

    def deploy_skill(self):
        print(self.name, "释放啦")
        for item in self.__list_effects:
            # 调用父类(影响效果)
            item.impact()


xlsbz = SkillDeployer("降龙十八掌")
xlsbz.deploy_skill()
xlsbz.deploy_skill()

设计原则

开-闭原则（目标、总的指导思想）

Open Closed Principle
对扩展开放，对修改关闭。
增加新功能，不改变原有代码。

类的单一职责（一个类的定义）

Single Responsibility Principle   
一个类有且只有一个改变它的原因。

依赖倒置（依赖抽象）

Dependency Inversion Principle
客户端代码(调用的类)尽量依赖(使用)抽象。
抽象不应该依赖细节，细节应该依赖抽象。

组合复用原则（复用的最佳实践）

Composite Reuse Principle
如果仅仅为了代码复用优先选择组合复用，而非继承复用。
组合的耦合性相对继承低。

里氏替换（继承后的重写，指导继承的设计）

Liskov Substitution Principle
父类出现的地方可以被子类替换，在替换后依然保持原功能。
子类要拥有父类的所有功能。
子类在重写父类方法时，尽量选择扩展重写，防止改变了功能。

迪米特法则（类与类交互的原则）

Law of Demeter
不要和陌生人说话。
类与类交互时，在满足功能要求的基础上，传递的数据量越少越好。因为这样可能降低耦合度。