类
关于类学习到了以下知识：
- 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()
