python面向对象基础-01

面向对象（OOP）基本概念

前言

话说三国时期曹军于官渡大败袁绍,酒席之间,曹操诗兴大发,吟道:喝酒唱歌,人生真爽! 众将直呼:"丞相好诗",于是命印刷工匠刻板印刷以流传天下;

待工匠刻板完成,交与曹操一看,曹操感觉不妥,说道:"喝酒唱歌,此话太俗,应改为'对酒当歌'较好",于是名工匠重新刻板,当时还没有出现活字印刷术,如果样板要改,只能重新刻板,工匠眼看连夜刻版之工，彻底白费，心中叫苦不迭。可也只得照办。

版样再次出来请曹操过目，曹操细细一品，觉得还是不好，说”人生真爽太过直接，应该改问语才够意境，因此应改为‘对酒当歌，人生几何？’“，于是....

在活字印刷术还没出现之前，如果版样有改动，只能重新雕刻。而且在印刷完成后，这个样板就失去了它的价值，如果需要其他样板只能重新雕刻。而活字印刷术的出现就大大改善了印刷技术。如上例”喝酒唱歌，人生真爽“，如果用活字印刷，只需要改四个字就可，其余工作都未白做。岂不快哉!!

活字印刷也反应了OOP。当要改动时，只需要修改部分，此为 可维护；当这些字用完后，并非就完全没有价值了，它完全可以在后来的印刷中重复使用，此乃 可复用；此诗若要加字，只需另刻字加入即可，这就是 可扩展；字的排列可以横排，也可以竖排，此是 灵活性好。

曹操吟诗工匠刻录的故事（转载）

# 上述案列反应了面向对象的优点,即可维护性高,扩展性强,复用性高!
#   这些特点非常适用于用户需求变化频繁的互联网应用程序,这是学习面向对象的重要原因
#   但是面向对象设计的程序需涉及类与对象,相应的复杂度会提高!
#
# 并非所有程序都需要较高的扩展性,例如系统内核,一旦编写完成,基本不会再修改,使用面向过程来设计则更适用

小结

面向对象

面向对象： # 是一种编程思想，是前辈们总结的编程经验，指导程序员如何编写出更好的程序

核心： # 对象

程序就是一系列对象的集合，程序员负责调度控制这些对象来交互着完成任务 在面向对象中程序员的角度发生了改变，从具体的操作者变成了指挥者。

强调：对象不是凭空产生的，需要我们自己设计

面向对象的优缺点

'''
    优点：
        1.可扩展性高
        2.灵活性高
        3.重用性高

    缺点：
        1.程序的复杂度提高了
        2.无法准确预知结果
'''

使用场景： # 对扩展性要求较高的程序，通常是直接面向用户的，例如qq 微信

注意点： # 不是所有的程序都要采用面向对象，要根据实际需求来选择

面向对象的两大核心： # 类与对象

类

'''
  类即类型、类别，是一种 抽象概念
      是一系列具备相同特征和相同行为的对象的集合
''' 

对象

'''
    对象就是具体存在的某个事物，具备自己的特征和行为
        对象就是特征和技能的结合体
'''

类和对象的关系

'''
    类包含一系列对象
    对象属于某个类

    在现实中先有对象再有类，程序中先有类再有对象
        我们必须先告诉计算机这类的对象有什么特征有什么行为
'''

结论： # 在面向对象编程时，第一步需要考虑需要什么样的对象，对象具备什么样的特征和行为，从而根据这些信息总结出需要的类

用面向对象思想编程

类的定义语法及类名书写规范

class 类的名称:
    # 类中的内容，描述属性和技能
    # 描述属性用变量
    # 描述行为用函数

'''
    类名书写规范：
        1.见名知意
        2.名称是大驼峰式（驼峰就是单词首字母大写，大驼峰就是第一个字母大写，小驼峰是第一个字母小写）
        3.其他规范与变量大致相同
'''

属性

'''
属性可以写在类中
类中的属性，是对象公共的

也可以写在对象中
对象中的属性，每个对象独特的（不一样的）

如果类和对象中存在同样的属性，先访问对象，如果没有再访问类
'''

属性的增删改查

'''
增加属性
    对象变量名称.属性名称 = 属性值
    egon.male = 'male'
删除属性
    del 对象的变量名称.属性名称
    del egon.male
修改属性
    对象.属性 = 新的值
查看所有属性，访问的是对象的所有属性
    对象.__dict__  --> dict 可以访问调用者自身的名称空间

访问他的类
    对象.__class__ 返回类
'''

class Student:
    '''
    这是Student类的注释
    '''
    def __init__(self, name):
        self.name = name

class TeachOfOldBoy:
    company = 'oldboy'

    def __init__(self, name):
        self.name = name

# ---------- 对象新增、修改、查看、删除属性 -------------
xuzhaolong = Student('xzl')
print(xuzhaolong.name)  # 对象.属性 --> 访问对象的属性
# xzl
# print(xuzhaolong.age)  # 访问不存在的属性会报错'Student' object has no attribute 'age'
xuzhaolong.age = 18  # 对象.属性 = 值 --> 为对象添加新属性
print(xuzhaolong.age)
#
xuzhaolong.age = 28  # 对象.属性 = 新值 --> 修改属性的值（如果该对象已有此属性）
print(xuzhaolong.age)
#
del xuzhaolong.age   # 删除对象的属性
# print(xuzhaolong.age)  # 会报错，属性已被删除，类中（属性的查找顺序：对象-->父类-->...如果还有父类，其他父类...-->Object）没有这个属性，AttributeError: 'Student' object has no attribute 'age'

print(TeachOfOldBoy.__dict__)  # __dict__查看调用者的名称空间里的名字
# {'__module__': '__main__', 'company': 'oldboy', '__init__': <function TeachOfOldBoy.__init__ at 0x0000026D1AC8A9D8>, '__dict__': <attribute '__dict__' of 'TeachOfOldBoy' objects>, '__weakref__': <attribute '__weakref__' of 'TeachOfOldBoy' objects>, '__doc__': None}
print(xuzhaolong.__dict__)
# {'name': 'xzl', 'age': 28}

# ---------- __class__ 查看调用者所属类型（python里类也是一种数据类型） -------------
print(TeachOfOldBoy.__class__)  # __class__ 查看调用者所属类
# <class 'type'>
print(xuzhaolong.__class__)
# <class '__main__.Student'>

# ---------- __doc__ 查看调用者的注释  -------------
print(TeachOfOldBoy.__doc__)  # __doc__ 查看调用者的注释
# None
print(Student.__doc__)  # __doc__ 查看调用者所属类的注释
#
#     这是Student类的注释
#
print(xuzhaolong.__doc__)  # __doc__ 查看调用者所属类的注释
#
#     这是Student类的注释
#

# ------------ 类中的属性与对象 -----------------
egon = TeachOfOldBoy('egon')
print(egon.company)
# oldboy
egon.company = 'OldBoy'
print(egon.company)  # 修改对象的继承的属性不影响类中的属性
# OldBoy
print(TeachOfOldBoy.company)
# oldboy

代码体现

属性的查找顺序： # 属性的查找顺序：先找自己的，再找类的，再父类。。。。一直往上找到object，再没有就报错

对象初始化__inint__

'''
__init__方法
    特点
        1.当实例化对象时，会自动执行__init__方法
        2.会自动将对象作为第一个参数传入，对象参数名称为self，self这个名字可以改，但不建议（一眼就知道是对象本身了）

    功能
        用户给对象赋初始值
'''
# 初始化，不仅仅只是赋初值，还可以做一些其他操作，来保证对象的正常生成

'''
    之前十个老师，每个老师都要输姓名年龄等，而属性的值又不一样，就不能直接定义成类的属性
    每定义一个对象都要写一次，很麻烦

    那么我们可以使用函数来简化这个赋值操作
    class Cls:  # 定义一个类
        pass

    def init(obj, kind, color, age):  # 定义一个方法来简化给对象添加（定制）属性
        obj.kind = kind  # 即 对象.属性 = 值（变量的） --> 像什么？ 给对象添加属性嘛
        obj.color = color
        obj.age = age

    obj1 = Cls()  # 实例化出一个对象
    init(obj1, "泰日天", '棕色', 2)  # 通过调用 init 函数来给该对象添加属性
    obj2 = Cls()
    init(obj2, "拆家犬", '黑白', 1)
    # 这样子就有了两个对象，且都已经有了各自的属性了

'''

class Dog:
    def __init__(self, kind, color, age):
        # print(locals())  # {'age': 2, 'color': '棕色', 'kind': '泰日天', 'self': <__main__.Dog object at 0x000002985BE586D8>}
        self.kind = kind
        self.color = color
        self.age = age
        # __init__ 函数不允许写返回值（不能写，只能返回None，写return None 没有意思） 规定如此

    '''
        不过在类里面直接写这个 init 函数会更方便（python内部做了一些处理）
        如上，当实例化对象时，会自动执行这个 __init__ 方法
            会自动将调用这个类实例化的对象作为第一个参数传入，对象参数名称为self
    '''

# 那么在实例化的时候就可以简写成这样了，四行变两行
teidi = Dog("泰日天", '棕色', 2)
# print(teidi.__dict__)  # {'kind': '泰日天', 'color': '棕色', 'age': 2}
erha = Dog("拆家犬", '黑白', 1)

'''
其实上面的写法还可以有优化，那个__init__ 函数还可以写得更简洁一点（参数越多越明显）
    def __init__(self, kind, color, age):
        lcs = locals()
        lcs.pop('self')
        self.__dict__.update(lcs)

    上面写法中的locals()内置函数在 __init__ 函数中，可以获取 __init__ 函数名称空间里的那些名字，它是一个字典
        # print(locals())  # {'age': 2, 'color': '棕色', 'kind': '泰日天', 'self': <__main__.Dog object at 0x000002985BE586D8>}
        我们将其赋给一个中间字典接收，将多余的 self 键值对去掉，就是我们对象想要的属性
        而对象.__dict__正好也是一个字典
        # print(teidi.__dict__)  # {'kind': '泰日天', 'color': '棕色', 'age': 2}
        都是字典？字典的update()方法还记得吗？
        将这个中间字典update()到对象的.__dict__ 中，即完成了对象的属性添加
        self.__dict__.update(lcs)
'''

__init__

备注：关于python内一些 __名字__ 这种属性是什么情况，可以参考这篇博客哦（都说不重要，但总有我这样的好奇宝宝嘛）~  Python常用内建方法：__init__,__new__,__class__的使用详解

绑定方法与非绑定方法

对象的精髓所在就是将数据和处理数据的函数整合到一起了,这样一来，拿到一个对象就同时拿到了需要处理的数据以及处理数据的函数

'''
******* 这一块基础概念是重点 *******
对象绑定方法：self --> 默认传入对象
    默认情况下，类中的方法都是对象绑定方法

    当使用对象调用时
        其特殊之处在于调用该函数时会自动传入对象本身作为第一个参数
    当使用类名来调用时就是一个普通函数，有几个参数就传几个参数

类绑定方法：@classmethod
            cls(加上@classmethod装饰后自己将self改为cls(class是关键字)) --> 默认传入类
    给类的抽象方法，默认传入类作为参数
    特殊之处：不管用类还是对象调用，都会自动传入类本身，作为第一个参数

    何时绑定给对象：当函数逻辑需要访问对象中的数据时
    何时绑定给类：当函数逻辑需要访问类中的数据时   

非绑定方法：@staticmethod
    装饰成普通函数，不管谁调都一样
        既不需要访问类的数据也不需要访问对象的数据
    定义时有几个参数调用时就需要传入几个参数

'''
class Dog:
    species = 'dog'
    # 初始化方法 __init__ 也属于对象绑定方法
    def __init__(self, kind, nickname, skill):
        self.kind = kind
        self.nickname = nickname
        self.skill = skill

    # 这就属于一个对象绑定方法，默认将对象作为第一个参数传入（调用的时候不需要手动传入）
    def introduce(self):
        print(f"我是{self.kind}，我能{self.skill}，人送外号{self.nickname}")

    # 类绑定方法
    @classmethod
    def tell_species(cls):  # 先写装饰器再写函数，默认参数就是cls了，写完函数再装饰的话，记得把self换成cls，表示参数是一个类
        print(f"我的物种是{cls.species}")

    # 非绑定方法（既不需要传入类，也不需要传入对象）
    @staticmethod
    def normal_func(arg1, arg2):
        print(f"参数一：{arg1} 参数二：{arg2}，这只是一个普通方法啦~")

taidi = Dog('泰迪', '泰日天', '日天')
erha = Dog('二哈', '拆家犬', '拆家')

# --------绑定对象方法的调用
taidi.introduce()
erha.introduce()
# 我是泰迪，我能日天，人送外号泰日天
# 我是二哈，我能拆家，人送外号拆家犬
Dog.introduce(erha)  # 类调用对象的方法要手动把对象传入进去
# 我是二哈，我能拆家，人送外号拆家犬

# --------类绑定方法调用
Dog.tell_species()
taidi.tell_species()  # 可以直接调用，无需手动传入 class
# 我的物种是dog
# 我的物种是dog

# --------非绑定方法调用
Dog.normal_func(1, 2)  # 非绑定方法，定义时有几个参数，调用时就要传几个参数
taidi.normal_func(1, 2)  # 非绑定方法，定义时有几个参数，调用时就要传几个参数
# 参数一：1 参数二：2，这只是一个普通方法啦~
# 参数一：1 参数二：2，这只是一个普通方法啦~

对象绑定方法、类绑定方法、非绑定方法

利用pickle模块将对象序列化到本地

如单机游戏的存档（把对象的数据等信息存储到文件中，下次启动再读取回来） --> 游戏扩展

import pickle

class Student:
    def __init__(self, name):
        self.name = name

    def say_hi(self):
        print("name:", self.name)

    def save(self):
        with open(self.name, "wb") as f:  # pickle 模块操作文件必须是b 模式
            pickle.dump(self, f)  # 利用pickle 模块，将传入的对象序列化到了文件中（json模块不支持对象这种类型）

    @staticmethod
    def get(name):
        with open(name, "rb") as f:
            obj = pickle.load(f)  # 利用pickle 模块，将文件中的对象反序列化成python中的对象
            return obj

# 将rose 和 jack两个从内存中对象序列化到文件中
stu = Student("rose")
stu.save()
stu2 = Student("jack")
stu2.save()

# 将他两反序列化出来到内存中
obj = Student.get("rose")  # 调用类中的方法（类绑定方法）从文件中将对象加载到内存中
print(obj.name)  # 使用该对象获取属性值
# rose
obj2 = Student.get("jack")
print(obj2.name)
# jack

print(Student.__name__)  # 获取类名
# Student

# 反序列化出来的对象和序列化的那个对象已经不是同一个对象了
print(id(stu), id(obj))
# 2161209937816 2161209971880
print(stu.name, obj.name)
# rose rose
print(id(stu2), id(obj2))
# 2161209937872 2161209971824
print(stu2.name, obj2.name)
# jack jack
obj2.name = 'jack2'
print(stu2.name, obj2.name)
# jack jack2

将对象从内存中序列化反序列化到文件中

英雄大乱斗（随机）案例

import random
import time

class Hero:
    def __init__(self, name, health, attack, q_hurt, w_hurt, e_hurt):
        lcs = locals()
        lcs.pop('self')
        self.__dict__.update(lcs)

    def attack(self, enemy):
        print(f"-- {self.name} --使用普通攻击攻击了-- {enemy.name} --,造成了 {self.attack} 点伤害，{enemy.name} 剩余 {enemy.health} 点生命值。\033[0m")
        enemy.health -= self.attack

    def Q(self, enemy):
        print(f"\033[0m-- {self.name} --使用Q技能攻击了-- {enemy.name} --,造成了 {self.q_hurt} 点伤害，{enemy.name} 剩余 {enemy.health} 点生命值。\033[0m")
        enemy.health -= self.q_hurt

    def W(self, enemy):
        print(f"\033[32m-- {self.name} --使用W技能攻击了-- {enemy.name} --,造成了 {self.w_hurt} 点伤害，{enemy.name} 剩余 {enemy.health} 点生命值。\033[0m")
        enemy.health -= self.w_hurt

    def E(self, enemy):
        print(f"\033[35m-- {self.name} --使用E技能攻击了-- {enemy.name} --,造成了 {self.e_hurt} 点伤害，{enemy.name} 剩余 {enemy.health} 点生命值。\033[0m")
        enemy.health -= self.e_hurt

def check_hero(enemy, team):
    if enemy.health <= 0:
        print(f"\033[31m** {enemy.name} ** 阵亡。\033[0m")
        if team == 'blue':
            blue_team.remove(enemy)
        elif team == 'red':
            red_team.remove(enemy)

def get_random_skill():
    return skill_list.get(random.randint(1, 4))

def get_random_blue_hero():
    return blue_team[random.randint(0, len(blue_team) - 1)]

def get_random_red_hero():
    return red_team[random.randint(0, len(red_team) - 1)]

blue_team = [
    Hero('瑞文', 465, 65, 30, 25, 70),
    Hero('提莫', 300, 35, 50, 40, 60),
]

red_team = [
    Hero('李白', 320, 60, 35, 29, 77),
    Hero('鲁班', 280, 79, 35, 40, 80),
]

skill_list = {
    1: Hero.attack,
    2: Hero.Q,
    3: Hero.W,
    4: Hero.E,
}

while len(red_team) > 0 and len(blue_team) > 0:
    skill = get_random_skill()
    blue = get_random_blue_hero()
    red = get_random_red_hero()
    flag = random.randint(0, 1)
    if flag:
        skill(blue, red)
        check_hero(red, 'red')
    else:
        skill(red, blue)
        check_hero(blue, 'blue')
    time.sleep(0.3)

    if len(red_team) == 0:
        print(f"蓝色方获胜！")
        print(f"蓝色方所剩英雄状态为：")
        for hero in blue_team:
            print(f"{hero.name} 剩余生命值 {hero.health}")
    elif len(blue_team) == 0:
        print(f"红色方获胜！")
        print(f"红色方所剩英雄状态为：")
        for hero in red_team:
            print(f"{hero.name} 剩余生命值 {hero.health}")

无注释版

注释版

import random
import time

# 定义一个英雄类，表示英雄这一类的共同特征
class Hero:
    def __init__(self, name, health, attack, q_hurt, w_hurt, e_hurt):
        lcs = locals()
        lcs.pop('self')
        self.__dict__.update(lcs)
        '''
            ********************************** 上述代码讲解 *************************************
            # 每次调用类生成对象的时候都会执行这里面的代码，并将对象作为第一个参数self 传进来
            print(locals())
            # {'e_hurt': 70, 'w_hurt': 25, 'q_hurt': 30, 'attack': 65, 'health': 465, 'name': '瑞文', 'self': <__main__.Hero object at 0x000002371823B278>}
            lcs = locals()  # 这个locals()在 __init__ 函数里 可以获取 __init__ 函数名称空间里的那些名字，他是一个字典
            lcs.pop('self')  # 发现上面的 locals() 多了一个 self 是不需要的，那就把它删掉
            print(lcs)
            # {'e_hurt': 70, 'w_hurt': 25, 'q_hurt': 30, 'attack': 65, 'health': 465, 'name': '瑞文'}
            # 这些内容正是初始化对象时想做的事（只不过是 对象.e_hurt = 70 这样的形式而已）
            self.__dict__.update(lcs)  # 将这些东西放到对象里，就重复了n变 self.参数 = 参数 （self.name = name）这样的动作
            print(self.__dict__)
            # {'e_hurt': 70, 'w_hurt': 25, 'q_hurt': 30, 'attack': 65, 'health': 465, 'name': '瑞文'}

            最初始的写法：
                self.name = name
                self.health = health
                self.attack = attack
                self.q_hurt = q_hurt
                self.w_hurt = w_hurt
                self.e_hurt = e_hurt
        '''

    def attack(self, enemy):
        enemy.health -= self.attack
        print(f"-- {self.name} --使用普通攻击攻击了-- {enemy.name} --,造成了 {self.attack} 点伤害，{enemy.name} 剩余 {enemy.health} 点生命值。\033[0m")

    def Q(self, enemy):
        enemy.health -= self.q_hurt
        print(f"\033[0m-- {self.name} --使用Q技能攻击了-- {enemy.name} --,造成了 {self.q_hurt} 点伤害，{enemy.name} 剩余 {enemy.health} 点生命值。\033[0m")

    def W(self, enemy):
        enemy.health -= self.w_hurt
        print(f"\033[32m-- {self.name} --使用W技能攻击了-- {enemy.name} --,造成了 {self.w_hurt} 点伤害，{enemy.name} 剩余 {enemy.health} 点生命值。\033[0m")

    def E(self, enemy):
        enemy.health -= self.e_hurt
        print(f"\033[35m-- {self.name} --使用E技能攻击了-- {enemy.name} --,造成了 {self.e_hurt} 点伤害，{enemy.name} 剩余 {enemy.health} 点生命值。\033[0m")

def check_hero(enemy, team):
    if enemy.health <= 0:
        # \033[31m 这种格式的是打印时的颜色控制（颜色可参考 https://www.cnblogs.com/easypython/p/9084426.html）
        print(f"\033[31m** {enemy.name} ** 阵亡。\033[0m")
        if team == 'blue':
            blue_team.remove(enemy)
        elif team == 'red':
            red_team.remove(enemy)

# 随机选择一种攻击方式
def get_random_skill():
    # random_index = random.randint(1, 4)
    # random_skill = skill_list.get(random_index)
    # return random_skill  # 函数名当做返回值返回，拿到可以直接加括号调用执行函数
    return skill_list.get(random.randint(1, 4))  # 上面代码的简便写法

# 随机选择一个蓝色方英雄
def get_random_blue_hero():
    # 返回 blue_team 这个列表的索引为 random.randint(0, len(blue_team) - 1) 返回值的元素（英雄对象）
    # return blue_team[random.randint(0, len(blue_team) - 1)]  # 下面几行的简便写法
    random_idndex = random.randint(0, len(blue_team) - 1)
    hero = blue_team[random_idndex]
    return hero

# 随机选择一个红色方英雄
def get_random_red_hero():
    return red_team[random.randint(0, len(red_team) - 1)]

# 蓝色方英雄阵容 --- 可自定义 ---
# 方便随机数取英雄对象
blue_team = [
    # 英雄名 生命值 普通攻击力 Q技能伤害 W技能伤害 E技能伤害
    #  瑞文   465      65       30        25        70
    Hero('瑞文', 465, 65, 30, 25, 70),
    Hero('提莫', 300, 35, 50, 40, 60),
    Hero('锤石', 600, 15, 20, 0, 32),
]

# 红色方英雄阵容 --- 可自定义 ---
# 方便随机数取英雄对象
red_team = [
    Hero('李白', 320, 60, 35, 29, 77),
    Hero('鲁班', 280, 79, 35, 40, 80),
    Hero('盾山', 800, 3, 3, 3, 3),
]

# 技能数字对应表（方便根据随机数取技能）
skill_list = {
    1: Hero.attack,
    2: Hero.Q,
    3: Hero.W,
    4: Hero.E,
}

def run():
    while len(red_team) > 0 and len(blue_team) > 0:
        # 调用方法随机获得一个技能
        skill = get_random_skill()
        # 调用方法随机获得一个蓝色方英雄
        blue = get_random_blue_hero()
        # 调用方法随机获得一个红色方英雄
        red = get_random_red_hero()
        # 随机选择一方为攻击方（那么另一方就是被攻击方）
        flag = random.randint(0, 1)
        if flag:
            skill(blue, red)
            check_hero(red, 'red')
        else:
            skill(red, blue)
            check_hero(blue, 'blue')
        # 暂停0.3秒，可以慢慢看战斗过程
        time.sleep(0.3)

        # 如果有任意一方没有英雄了，即游戏结束
        if len(red_team) == 0:
            print(f"蓝色方获胜！")
            print(f"蓝色方所剩英雄状态为：")
            for hero in blue_team:
                print(f"{hero.name} 剩余生命值 {hero.health}")
        elif len(blue_team) == 0:
            print(f"红色方获胜！")
            print(f"红色方所剩英雄状态为：")
            for hero in red_team:
                print(f"{hero.name} 剩余生命值 {hero.health}")

if __name__ == '__main__':
    run()
    '''
        战斗记录
        ************************** 省略n多中间战斗步骤  *********************************
        -- 锤石 --使用W技能攻击了-- 盾山 --,造成了 0 点伤害，盾山 剩余 42 点生命值。
        -- 盾山 --使用E技能攻击了-- 瑞文 --,造成了 3 点伤害，瑞文 剩余 289 点生命值。
        -- 瑞文 --使用E技能攻击了-- 盾山 --,造成了 70 点伤害，盾山 剩余 -28 点生命值。
        ** 盾山 ** 阵亡。
        蓝色方获胜！
        蓝色方所剩英雄状态为：
        瑞文 剩余生命值 289
        锤石 剩余生命值 235

        战斗记录2
        ************************** 省略n多中间战斗步骤  *********************************
        -- 盾山 --使用普通攻击攻击了-- 锤石 --,造成了 3 点伤害，锤石 剩余 11 点生命值。
        -- 锤石 --使用普通攻击攻击了-- 盾山 --,造成了 15 点伤害，盾山 剩余 288 点生命值。
        -- 盾山 --使用E技能攻击了-- 瑞文 --,造成了 3 点伤害，瑞文 剩余 -1 点生命值。
        ** 瑞文 ** 阵亡。
        -- 盾山 --使用普通攻击攻击了-- 锤石 --,造成了 3 点伤害，锤石 剩余 8 点生命值。
        -- 盾山 --使用普通攻击攻击了-- 锤石 --,造成了 3 点伤害，锤石 剩余 5 点生命值。
        -- 盾山 --使用W技能攻击了-- 锤石 --,造成了 3 点伤害，锤石 剩余 2 点生命值。
        -- 盾山 --使用Q技能攻击了-- 锤石 --,造成了 3 点伤害，锤石 剩余 -1 点生命值。
        ** 锤石 ** 阵亡。
        红色方获胜！
        红色方所剩英雄状态为：
        盾山 剩余生命值 288
    '''

'''
有红蓝两方英雄（可自定义个数）
    随机一方英雄使用随机攻击方式攻击另一方英雄，任意一方英雄全部阵亡则游戏结束
        每个英雄有 名字、生命值、普通攻击、Q技能攻击、W技能攻击、E技能攻击以及对应的伤害值
            当生命值为 0 时阵亡，不再参与战斗
'''

注释版案例

后续完善博客思路

调用类生成对象发生的一些事情（对比变量、模块名称空间生成等）

属性的查找顺序（画图表示吧）
　　先找自己的，再找父类的，一级一级往上找，直到基类object，再没有报错

英雄大乱斗案例
序列化、反序列化对象（保存、读取对象）(游戏退出，读档)

待完善内容(不算是面向对象的重点啦)