20.7.17 笔记算数运算符 复合运算符重载 比较运算重载 多态 设计原则 类的单一职责 依赖倒置 组合复用原则 里氏替换 迪米特法则 矩阵转置原理

算数运算符
复合运算符重载
比较运算重载

class Vector2:
    """
        二维向量
    """

    def __init__(self, x, y):
        self.x = x
        self.y = 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


v01 = Vector2(1, 2)
v02 = Vector2(3, 4)
print(id(v01))
v01 += v02  # v01.__iadd__(v02)
print(id(v01))
print(v01.__dict__)

# +=：可变对象不创建新
list01 = [1]
print(id(list01))
list01+=[2]
print(id(list01))

# +=：不可变对象创建新
tuple01 = (1,)
print(id(tuple01))
tuple01+=(2,)
print(id(tuple01))

"""

"""


class Skill:
    def __init__(self, name="", atk_rate=0, cost_sp=0, duration=0):
        self.name = name
        self.atk_rate = atk_rate
        self.cost_sp = cost_sp
        self.duration = duration

    # 相同的比较规则：技能名称
    def __eq__(self, other):
        return self.name == other.name

    # 大小的比较规则：持续时间
    def __lt__(self, other):
        return self.duration < other.duration


s01 = Skill("乾坤大挪移", 2, 50, 55)
s02 = Skill("乾坤大挪移", 2, 50, 55)
# s01.__eq__(s02)
print(s01 == s02)  # False  比较的是内存地址
list_skills = [
    Skill("乾坤大挪移", 2, 50, 55),
    Skill("九阳神功", 3, 40, 50),
    Skill("九阳神功", 3, 40, 50),
    Skill("玉女心经", 1, 60, 35),
]
print(list_skills.count(Skill("九阳神功", 3, 40, 50)))
print(Skill("玉女心经", 1, 60, 35) in list_skills)
list_skills.remove(Skill("玉女心经", 1, 60, 35))

list_skills.sort()
for item in list_skills:
    print(item.__dict__)

多态
设计角度讲
定义
父类的同一种动作或者行为，在不同的子类上有不同的实现。
作用
1.在继承的基础上，体现类型的个性化（一个行为有不同的实现）。
2.增强程序扩展性，体现开闭原则。
语法角度讲
重写
子类实现了父类中相同的方法（方法名、参数）。
在调用该方法时，实际执行的是子类的方法。
快捷键
Ctrl + O
设计原则
开-闭原则（目标、总的指导思想）
Open Closed Principle
对扩展开放，对修改关闭。
增加新功能，不改变原有代码。
类的单一职责（一个类的定义）
Single Responsibility Principle
一个类有且只有一个改变它的原因。
依赖倒置（依赖抽象）
Dependency Inversion Principle
客户端代码(调用的类)尽量依赖(使用)抽象。
抽象不应该依赖细节，细节应该依赖抽象。
组合复用原则（复用的最佳实践）
Composite Reuse Principle
如果仅仅为了代码复用优先选择组合复用，而非继承复用。
组合的耦合性相对继承低。
里氏替换（继承后的重写，指导继承的设计）
Liskov Substitution Principle
父类出现的地方可以被子类替换，在替换后依然保持原功能。
子类要拥有父类的所有功能。
子类在重写父类方法时，尽量选择扩展重写，防止改变了功能。
迪米特法则（类与类交互的原则）
Law of Demeter
不要和陌生人说话。
类与类交互时，在满足功能要求的基础上，传递的数据量越少越好。因为这样可能降低耦合度。

"""
    变化点：增加飞机、火车、自行车....
    缺点：违反了面向对象设计原则 -- 开闭原则
          -- 允许增加新功能,但是不能修改客户端代码.
"""
class Person:
    def __init__(self,name):
        self.name = name

    def go_to(self,position,a):
        print(self.name + "去"+position)
        if type(a) == Car:
            a.run()
        elif type(a) == Airplane:
            a.fly()

class Car:
    def run(self):
        print("汽车在行驶")

class Airplane:
    def fly(self):
        print("飞机在飞行")

lz = Person("老张")
car = Car()
air = Airplane()
lz.go_to("东北",car)
lz.go_to("东北",air)

"""
    变化点：增加飞机、火车、自行车....

    三大特征：
        封装：创建人类,汽车类,飞机类         [分]
        继承：创建交通工具隔离火车、飞机等变化 [隔]
        多态：人调用交通工具,　　　　　　　　　[做]　　　
        　　　火车、飞机重写运输方法,
        　　　创建火车飞机对象
    练习：
        情景：手雷爆炸，可能伤害敌人或者玩家的生命。
        变化：还可能伤害房子、树、鸭子....
        要求：增加新事物，不影响手雷.
        体会：开闭原则
        写出：封装继承多态具体体现
            画出架构设计图


"""
class Person:
    def __init__(self,name):
        self.name = name

    def go_to(self,position,vehicle):
        print(self.name + "去"+position)
        # 1. 编码时　调用父 transport 方法
        #　　　运行时 执行子
        vehicle.transport()

class Vehicle:
    def transport(self):
        pass

# -----------以上代码是框架--以下代码是实现-----------------
class Car(Vehicle):
    # 2. 子重写
    def transport(self):
        print("汽车在行驶")

class Airplane(Vehicle):
    def transport(self):
        print("飞机在飞行")


# -----------测试-------------
lz = Person("老张")
car = Car()
air = Airplane()
# 3. 创建子
lz.go_to("东北",car)
lz.go_to("东北",air)

"""
    创建图形管理器
        1. 记录多种图形（圆形、矩形....）
        2. 提供计算总面积的方法.
    满足：
        开闭原则、依赖倒置
    测试：
        创建图形管理器，存储多个图形对象。
        通过图形管理器，调用计算总面积方法.
    写出具体体现：
        封装：GraphicManager、Circle、Rectanle
        继承：创建Graphic、隔离GraphicManager与Circle、Rectanle
        多态：GraphicManager调用Graphic,
             Circle、Rectanle重写get_area方法、
             创建Circle、Rectanle对象
        开闭原则：
            增加具体类型(三角形),图形GraphicManager不变
        依赖倒置
            GraphicManager使用Graphic,不使用Circle、Rectanle
        组合复用
            GraphicManager通过变量调用图形,而不是继承。
"""


class GraphicManager:
    def __init__(self):
        self.list_graphics = []

    def add_graphic(self, graphic):
        self.list_graphics.append(graphic)

    def calculate_total_area(self):
        total_area = 0
        for item in self.list_graphics:
            # 1. 编写代码时调用父
            total_area += item.get_area()
        return total_area


class Graphic:
    def get_area(self):
        pass


# -------------------

class Circle(Graphic):
    def __init__(self, r):
        self.r = r

    # 2. 编写代码时子重写
    def get_area(self):
        return 3.14 * self.r


class Rectanle(Graphic):
    def __init__(self, l, w):
        self.l = l
        self.w = w

    def get_area(self):
        return self.l * self.w

# 测试
manager = GraphicManager()
# 3. 运行时创建子
manager.add_graphic(Circle(5))
manager.add_graphic(Rectanle(5, 6))
print(manager.calculate_total_area())

矩阵转置原理

本文地址：https://blog.csdn.net/zero950207/article/details/107419776