类

关于类学习到了以下知识：

• 1.@property装饰器

方法伪装属性，方法返回值及属性值，被装饰方法不能有参数，必须实例化后调用，类不能调用

• 2.类的继承

继承父类的基本属性值，父类的参数调用

• 3.__slots__

限制类的属性

• 4.__str__()方法

返回对象的描述信息，需要返回一个字符串，当做这个对象的描写

• 5.随机数

从列表取随机元素，从给定范围取随机元素

• 6.条件语句的基本用法

条件、循环、Ture/False判断等

• 7.@abstractmethod

抽象方法，含abstractmethod方法的类不能实例化，继承了含abstractmethod方法的子类必须复写所有abstractmethod装饰的方法，未被装饰的可以不重写

实例小游戏

from abc import ABCMeta, abstractmethod
from random import randint, randrange


# 抽象类，只能被继承，不能被实例化abc模块
class Fighter(object, metaclass=ABCMeta):
    """战斗者"""
    # 限制该类能添加的属性，只能是name和hp
    __slots__ = ('_name', '_hp')

    def __init__(self, name, hp):
        # 初始化名名字和生命值
        self._name = name
        self._hp = hp

    # 修饰name方法，使该方法了name属性的getter方法
    @property
    def name(self):
        return self._name

    # 同上
    @property
    def hp(self):
        return self._hp

    # 修该hp属性
    @hp.setter
    def hp(self, hp):
        if hp >= 0:
            self._hp = hp
        else:
            self._hp = 0

    # 活着的
    @property
    def alive(self):
        return self._hp > 0

    # 用于程序接口的控制，正如上面的特性，含有@abstractmethod修饰的父类不能实例化，但是继承的子类必须实现@abstractmethod装饰的方法
    @abstractmethod
    def attack(self, other):
        # other 被攻击的对象
        pass

class Ultraman(Fighter):
    # 奥特曼的属性
    __slots__ = ('_name', '_hp', '_mp')

    def __init__(self, name, hp, mp):
        # super()函数是用于调用父类(超类)的一个方法
        super().__init__(name, hp)
        self._mp = mp

    # 此处继承了Fighter抽像类，必须实现attack的方法，即被攻击的对象掉血多少
    def attack(self, other):
        # 既然继承了父类，那么other参数就可以调用父类的参数，即此处hp为Fighter类定义的hp
        other.hp -= randint(15, 25)

    def huge_attack(self, other):
    # 必杀技，other是被攻击对象，成功返回True
        if self._mp >= 50:
            self._mp -= 50
            injury = other.hp * 3 // 4
            # 至少需要掉血50
            if injury >= 50:
                injury_current = injury
            else:
                injury_current = 50
            other.hp -= injury_current
            return True
        else:
            self.attack(other)
            return False

    def magic_attack(self, others):
        #群体魔法攻击，成功返回True
        if self._mp >= 20:
            self._mp -= 20
            for temp in others:
                if temp.alive:
                    temp.hp -= randint(10, 15)
            return True
        else:
            return False

    def resume(self):
        # 恢复魔法
        incr_point = randint(1, 10)
        self._mp += incr_point
        return  incr_point

    def __str__(self):
        # 返回对象的描述信息
        return '---%s奥特曼---\n生命值：%d\n魔法值：%d\n' % (self._name, self._hp, self._mp)


class Monster(Fighter):
    # 小怪兽
    __slots__ = ('_name', '_hp')

    # 同上，继承了Fighter父类，需要再此类中实现该方法
    def attack(self, other):
        other.hp -= randint(10, 20)

    def __str__(self):
        return '---%s小怪兽---\n生命值：%d\n' % (self._name, self._hp)


# 判断是否还有小怪兽存活,monsters是怪兽组，即所有怪兽的列表
def is_any_alive(monsters):
    for monster in monsters:
        if monster.alive > 0:
            return True
    return False

# 选中一只活着的怪兽
def select_alive_one(monsters):

    monsters_len = len(monsters)
    while True:
        # 从给定的范围返回随机项
        index = randrange(monsters_len)
        # 取出返回的怪兽序列
        monster = monsters[index]
        # 判断其是否活着
        if monster.alive > 0:
            return monster

# 输出奥特曼和怪兽的信息
def display_info(ultraman, monsters):
    print(ultraman)
    for monster in monsters:
        print(monster, end='')

def main():
    my = Ultraman('秦剑', 100, 50)
    g1 = Monster('怪兽1', 100)
    g2 = Monster('怪兽2', 100)
    g3 = Monster('怪兽3', 100)
    g4 = Monster('怪兽4', 100)
    # 实例化的4个怪兽的列表
    mosters = [g1, g2, g3, g4]
    # 初始化回合数为1
    fight_round = 1
    while my.alive and is_any_alive(mosters):
        print('========第%02d回合========' % fight_round)
        tmp_g = select_alive_one(mosters)
        # 取1-10之间的随机数
        skill = randint(1, 10)
        if skill <= 3:
            print('%s对%s使用了普通攻击' % (my.name, tmp_g.name))
            # 奥特曼攻击怪兽，怪兽随机掉血
            my.attack(tmp_g)
            # 奥特曼恢复魔法值
            print('%s的魔法值恢复了%d点' % (my.name, my.resume()))
        elif skill >= 8:
            # 使用全体魔法攻击，对所有小怪兽进行扣血
            if my.magic_attack(mosters):
                print('%s对全体小怪兽使用了魔法攻击' % my.name)
            else:
                print('%s的魔法值不足，释放技能失败' % my.name)
        else:
            # 对单个怪兽使用大招
            if my.huge_attack(tmp_g):
                print('%s对%s使用了大招技能' % (my.name, tmp_g.name))
            else:
                print('%s对%s使用了普通攻击' % (my.name, tmp_g.name))
                my.attack(tmp_g)
                print('%s的魔法值恢复了%d点' % (my.name, my.resume()))
        if tmp_g.alive > 0:
            print('%s回击了%s' % (tmp_g.name, my.name))
            tmp_g.attack(my)
        display_info(my, mosters)
        fight_round += 1
    print('\n========战斗结束!========\n')
    if my.alive > 0:
        print('%s奥特曼胜利！'% my.name)
    else:
        print('%s怪兽胜利！' % tmp_g.name)



if __name__ == '__main__':
    main()