python_day13(笔记及练习)

面向对象的延续
复习
封装：
封装数据：多 --> 一
封装行为:隐藏 --> 提供必要功能
设计角度：分而治之,变则疏之
继承：
继承行为：子类可以直接使用父类的方法
继承数据：子类在构造函数中通过super()调用父类构造函数
设计角度：抽象 --> 统一 --> 隔离
多态：
语法角度：调用父方法,重写,创建子类对象
设计角度：调用父类一个方法，在不同的子类上有不同的实现.
开闭原则：
可以增加新功能,不修改客户端的代码.
单一职责：
类有且只有一个改变的原因
依赖倒置
调用父类，不调用子类.
组合复用
如果仅仅是代码的复用,优先使用组合关系,而不是继承关系

class A:
    def func01(self):
        pass

class A1(A):

    def func01(self):
        print("func02")


class A2(A):
    # 重写
    def func01(self):
        print("func02")

# 动态：运行时可以改变
def func02(a):
    # 1. 调用的是父类类(A)
    a.func01()


# 3. 创建子类对象
func02(A1())
func02(A2())

"""
    多继承
        有多种变化需要隔离（不是代码复用）
    １６：５０
"""

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")
        # 1. 如何调用某一个同名方法
        B.func01(self)

d = D()
d.func01()
# 2. 同名方法解析顺序
print(D.mro())

"""
   里氏替换
"""

class Granade:
    def __init__(self, atk=0):
        self.atk = atk

    def explode(self, target):
        print("手雷爆炸啦")
        target.damage(self.atk)

class Target:
    def __init__(self, hp=0):
        self.hp = hp

    def damage(self, value):
        self.hp -= value

# ------------------------------------------
class Player(Target):
    def damage(self, value):
        super().damage(value)
        print("玩家受伤,屏幕碎屏")

class Enemy(Target):
    def damage(self, value):
        super().damage(value)
        print("敌人受伤,掉下装备")
      
g01 = Granade()
g01.explode(Player())
g01.explode(Enemy())

"""
    运算符重载
"""


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 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)  #

面向对象逻辑:

"""
    一家公司有如下几种岗位:
        程序员：底薪 + 项目分红
        测试员：底薪 + Bug * 5
        ....
    创建员工管理器
        记录所有员工
        提供计算总工资的功能
    叙述：
        三大特征：
            封装：根据需求划分为员工管理器、程序员、测试员
            继承：创建员工类,隔离员工管理器与具体员工的变化
            多态：员工管理器调用员工,具体员工重写员工的计算薪资方法,添加具体员工对象
                    (调父)             (重写)                 (创建子类对象)
                 总结多态步骤：面对变化点，需要使用3步进行处理。
                 价值(作用)：程序灵活(扩展性强 = 开闭原则)
        六大原则：
            开闭原则：增加员工种类,员工管理器不变.
            单一职责：员工管理器：统一管理所有员工(薪资...)
                    程序员：定义该员工的薪资算法(底薪 + 项目分红)
                    测试员：定义该员工的薪资算法(底薪 + Bug * 5)
            依赖倒置：员工管理器调用员工,不调用程序员/测试员
            组合复用：员工管理器通过组合关系,使用各种员工的薪资算法.
            里氏替换：向员工管理器添加的是员工子类对象
                    员工子类先调用员工类计算薪资方法返回底薪,再添加自己的薪资逻辑.
            迪米特：每个具体员工类之间低耦合
                   员工管理器与具体员工之间低耦合


"""

class EmployeeManager:
    def __init__(self):
        self.__list_employees = []

    def add_employee(self, emp):
        self.__list_employees.append(emp)

    def get_total_salary(self):
        total_salary = 0
        for item in self.__list_employees:
            # 调用父类
            total_salary += item.calculate_salary()
        return total_salary

class Employee:
    def __init__(self, base_salary=0):
        self.base_salary = base_salary

    def calculate_salary(self):
        return self.base_salary

# --------------------------
class Programmer(Employee):
    def __init__(self, base_salary=0, bonus=0):
        super().__init__(base_salary)
        self.bonus = bonus

    # 重写
    def calculate_salary(self):
        return super().calculate_salary() + self.bonus

class Tester(Employee):
    def __init__(self, base_salary=0, bug_count=0):
        super().__init__(base_salary)
        self.bug_count = bug_count

    def calculate_salary(self):
        return super().calculate_salary() + self.bug_count * 5


manager = EmployeeManager()
# 创建子类对象
manager.add_employee(Programmer(8000, 20000))
manager.add_employee(Tester(5000, 100))
print(manager.get_total_salary())

"""
    技能系统
    叙述
        三大特征：
        六大原则：
"""


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()