python类相关术语与实战：打造高效、灵活的代码架构

一、相关术语

①面向对象

面向对象是将实例的属性及行为进行封装，对不同的实例可以使用同一类实现。即编码的实现更关心实例的数据和操作。

②类

将相类似实例的属性及行为进行封装。即是实例的模版，在模版中实例可以编写属性及进行操作。

③实例

每个具体的对象。

④初始化方法

__init__()方法，可以对类的实例进行初始化操作，创建对象后会自动执行，即自动设置对象的初始化状态。

class Person:
    def __init__(self, name, age):
        # 执行类 就是执行初始化函数
        # self 就是执行类以后返回的实例
        print(id(self))
        # 初始化实例就是初始化self
        self.name = name
        self.age = age
        print(hasattr(self, "name"))
        # 初始化函数默认范湖初始化好的self
        pass

    def display(self):
        return f"{self.name}--{self.age}"


print(callable(Person))

⑤魔法方法

不用调用该方法，该方法就自动执行。

⑥字符串方法

返回的必须是字符串，可以将类的属性或方法的地址转换为字符串输出。

⑦self

self是对类进行调用的对象，哪个实例使用该类，该类中的self就是哪个实例。

class Person:
    """
    人类
    """

    def __init__(self, name, age):
        # self 的id值== 实例的id值
        # 初始化人类的变量
        # self.变量名 调用的值为实例中的值
        # self.变量名 如果直接赋值，则相当于固定下来
        print(id(self))

        self.name = name
        self.age = age

        # 判断self中是否有“age”的属性
        print(hasattr(self, "age"))

    def display(self):
        print(f"self--{self}")
        # 调用实例中的变量
        print(self.name, self.age)
        return self


# 是将p1中的参数给self，不是给class
p1 = Person("张三", 20)
# self与对象的id值是一样的
print(id(p1))

# 使用实例名调用self的属性
print(p1.name)

# self 返回的就是实例本身
print(f"p1---{p1.display()}")

# 查看对象中，有误某变量
print(hasattr(p1, "name"))

⑧数据、属性、操作、行为

数据和属性是实例的数据性质，操作和行为是实例的行为属性或者是要去执行的代码。

⑨父类、基类、超类

被继承的类，拥有基本属性。

⑩子类、派生类

继承别的类的类，拥有比父类更多的属性或操作。

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

    def walk(self):
        return f"{self.name} 走"

    def __str__(self):
        return f"名字：{self.name}\t"


class Dog(Animal):
    def __init__(self, name, age):
        Animal.__init__(self, name)
        self.age = age

    def __str__(self):
        return f"{Animal.__str__(self)}年龄：{self.age}"


class WangDog(Dog):

    def __init__(self, name, age, sex):
        Dog.__init__(self, name, age)
        self.sex = sex

    def display(self):
        print(f"{self.age}---------")

    def __str__(self):
        # 打印输出的时候，以前有的不用再写了，直接调用以前的__str__就可以，即父类名
        return f"{Dog.__str__(self)},性别：{self.sex}\t{Animal.walk(self)}"
        # print(f"{self.age}---------")


wd = WangDog("阿奇", 5, "男")
print(wd)
# wd.walk()
# wd.display()

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

    def __str__(self):
        return f"人 名字是{self.name}"

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

    def __str__(self):
        return f"超{Person.__str__(self)}  技能{self.skill}"



sp1 = SuperMan("蜘蛛侠", "凌空飞波")
print(sp1)

⑪多态

同一个方法允许拥有不同个参数的实例进行访问。

class Person:
    def walk(self, *args):
        """
        通过args可变元组参数，实现重载
        即同一个类中，可以传入不同个数的参数.
        args是以元组的形式返回的
        """
        print("父类中的walk类", args)


p1 = Person()
p1.walk()
p1.walk([1, 2])
p1.walk(10, 20, 30, 50)


class SupperPerson(Person):
    def walk(self):
        print("子类中的walk类")


sp = SupperPerson()
sp.walk()

⑫python没有多态 python到处都是多态

不同的实例可以调用相同的方法，不用特意强调对象的参数个数。

# **kwargs 允许函数接受任意数量的关键字参数，并将这些参数存储在一个字典中。
def example_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} : {value}")

# 调用函数并传入关键字参数
example_function(name="Alice", age=30, city="New York")

⑬重载多态

同一方法的名称相同，调用此方法的实例的参数可以不一样。

⑭重写多态

父类中的方法，子类中重新定义。

class Person:
    def walk(self, *args):
        """
        通过args可变元组参数，实现重载
        即同一个类中，可以传入不同个数的参数.
        args是以元组的形式返回的
        """
        print("父类中的walk类", args)


p1 = Person()
p1.walk()
p1.walk([1, 2])
p1.walk(10, 20, 30, 50)


class SupperPerson(Person):
    def walk(self):
        print("子类中的walk类")


sp = SupperPerson()
sp.walk()

⑮实例属性

实例中拥有属性。

⑯实例方法

实例中拥有的方法。

⑰类属性

类名可以获取和修改类属性，实例可以获取类属性。

⑱类方法

第一个形参叫cls, 使用装饰器@classmethod。

⑲静态方法

定义在类中，并且使用 @staticmethod 修饰器修饰，没有 cls 和 self 参数限制的方法。

class Person:
    """
    这个Person演示的是实例与类的内容
    """
    """person类"""
    info = "person类的info"

    @classmethod
    def get_doc(cls):
        # 类的方法通常使用cls,与@classmethod
        print(cls == Person)
        # 使用类名获取类的文档注释与类名
        return Person.__doc__, Person.__name__

    @staticmethod
    def get_info():
        """
        类方法一般使用cls,实例方法一般使用self.
        两个都没有的使用@staticmethod
        """
        return f"这里是静态方法"

    def __init__(self, name):
        """初始化self和实例属性"""
        self.name = name

    def get_name(self):
        """实例方法"""
        return self.name

    def set_name(self, name):
        """实例方法"""
        self.name = name

p1 = Person("第一个实例")
p2 = Person("第二个实例")


# 实例p1与p2都有实例实例的属性
print("实例p1的实例的属性", p1.name)
print("实例p2的实例的属性", p2.name)
# 实例p1/p2都有实例方法
p1.set_name("p1的实例方法")
p2.set_name("p2的实例方法")
print(p1.get_name())
print(p2.get_name())

# 给实例p1初始化实例属性  不影响Person
# 类属性
# 类名和实例都可以获取类的属性
print("Person.info:", Person.info, id(Person.info))
print("p1.info:", p1.info, id(p1.info))
print("p2.info:", p1.info, id(p1.info))

# 类名可以改变类属性
# 改变后的id值会变，但是是修改的类中的属性
Person.info = "使用类名修改类属性后"
print("Person.info:", Person.info, id(Person.info))
print("p1.info:", p1.info, id(p1.info))
print("p2.info:", p1.info, id(p1.info))
Person.info = "使用类名修改类属性后~~~"
print("Person.info:", Person.info, id(Person.info))

# 实例不能修改类的属性，只是给实例又添加了一个同名属性
# p1与p2的同名属性也不相同
p1.info = "p1修改类属性"
print("p1.info:", p1.info, id(p1.info))
p2.info = "p2修改类属性"
print("p2.info:", p2.info, id(p2.info))

print("使用类名调用类方法：", Person.get_doc())
print("使用实例调用类方法：", p1.get_doc())

# 给实例创作一个方法
p1.get_doc = lambda: f"这是实例的同名方法"
print("使用实例调用类的同名方法：", p1.get_doc())

二、实战

①创建一个圆Circle类，为该类提供一个初始化方法，用于初始化半径
为该类提供两个方法，
方法一用 于求圆的面积，方法二用于求圆的周长

class Circle:
    """
    圆的类: 提供半径 求面积 周长
    """

    def __init__(self, radius):
        """
        初始化实例 self就是返回的实例
        :param radius: 半径
        :return: 初始化函数默认会把初始化好的self返回给实例
        """
        self.radius = radius

    def area(self):
        """
        圆的面积
        self就是调用area方法的实例
        """
        circle_area = self.radius * self.radius * math.pi
        return circle_area

    def perimeter(self):
        """
        圆的周长
        self就是调用perimeter方法的实例
        """
        circle_peri = self.radius * 2 * math.pi
        return circle_peri


c0 = Circle(1)
print(f"半径为{c0.radius}的圆，面积为：{c0.area()}，周长为{c0.perimeter()}")

②创建Rectangle类，初始化属性width、height；
在Rectangle类中添加两个方法计算矩形的周长和面积；
在Rectangle类中添加方法输出矩形的周长和面积
生成10个矩形 width,height都位于 5-10之间 求周长与面积之和最大的一个矩形

class Rectangle:
    """
    长方形的类
    """

    def __init__(self, width, height):
        """
        初始化宽和高
        """
        self.width = width
        self.height = height

    def rect_area(self):
        """
        矩形面积
        """
        area = self.height * self.width
        return area

    def rect_peri(self):
        """
        矩形周长
        """
        perimeter = (self.width + self.height) * 2
        return perimeter

    def sum_num(self):
        # 类的内部函数也可以用self调用内部函数
        total = self.rect_peri() + self.rect_area()
        return total

    def display(self):
        return f"{self.height},{self.width},{self.sum_num()}"

# 直接记录矩形，最后用最大值调用display即可
targe = None
for i in range(10):
    width = random.randint(5, 10)
    height = random.randint(5, 10)
    r = Rectangle(width, height)
    if targe:
        if r.sum_num() > targe.sum_num():
            targe = r
    else:
        targe = r

print(targe.display())

拓展：创circle类，初始化属性圆心(x,y)有半径r：
构造两个圆形的实力，判定两个圆形的位置关系（内部，相交，相切，相离）

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

    def display(self):
        return self.x, self.y

c1 = Circle(10, 25, 5)
c2 = Circle(10, 10, 10)

distance = math.dist((c1.display()[0], c1.display()[1]), (c2.display()[0], c2.display()[1]))
print(distance)
r_distance = c1.r + c2.r
if r_distance > distance > abs(c1.r - c2.r):
    print("相交")
elif r_distance < distance:
    print("相离")
elif r_distance == distance:
    print("外切")
elif abs(c1.r - c2.r) == distance:
    print("内切")
else:
    print("内部")

③使用面向对象封装一个栈和队列

提供是否满、是否空、数量、入队出队，入栈出站对应方法

class Stack:
    def __init__(self, max_size):
        self.max_size = max_size
        self.stack = []

    def empty(self):
        """
        栈空
        """
        if self.count() == 0:
            return True
        else:
            return False

    def full(self):
        """
        栈满
        """
        if self.count() == self.max_size:
            return True
        else:
            return False

    def count(self):
        """
        统计当前栈中个数
        """
        return len(self.stack)

    def push(self, n):
        """
        入栈
        """
        if self.full():
            print("栈已满，无法入栈。")
        else:
            self.stack.append(n)

    def pop(self):
        """
        出栈
        """
        if self.empty():
            return "目前栈为空，无元素。"
        else:
            result = self.stack.pop()
            return result


s1 = Stack(3)
s1.push(7)
s1.push(8)
s1.push(9)
print(s1.stack)
s1.push(10)
print(s1.stack)
print(s1.pop())
print(s1.pop())
print(s1.pop())

class Queue:
    def __init__(self, max_size):
        self.max_size = max_size
        self.queue = []

    def empty(self):
        """
        队列空
        """
        if self.count() == 0:
            return True
        else:
            return False

    def full(self):
        """
        队列满
        """
        if self.count() == self.max_size:
            return True
        else:
            return False

    def count(self):
        """
        统计当前队列中个数
        """
        return len(self.queue)

    def push(self, n):
        """
        入队
        """
        if self.full():
            print("队列已满，无法入队。")
        else:
            self.queue.append(n)

    def pop(self):
        """
        出队
        """
        if self.empty():
            return "目前队列为空，无元素。"
        else:
            result = self.queue.pop(0)
            return result


s1 = Queue(3)
s1.push(7)
s1.push(8)
s1.push(9)
print(s1.queue)
s1.push(10)
print(s1.queue)
print(s1.pop())
print(s1.pop())
print(s1.pop())
print(s1.pop())

④新建学生类（学号，姓名，年纪）
随机生成10个学生放入列表(年纪随机即可)，按学生的年纪对列表中的学生排序

使用装饰器对不同排序的方法进行时间计算

class Student:
    def __init__(self, id_num, name, age_value):
        """
        初始化学生信息
        :param id_num: 学生ID
        :param name: 学生姓名
        :param age_value: 学生年纪
        """
        self.id = id_num
        self.name = name
        self.age = age_value

    def display(self):
        return f"学号：{self.id}\t姓名：{self.name}\t年纪：{self.age}"

    def __str__(self):
        return self.display()


# 注意 都是字符串才可以使用+拼接
students = [Student(i, "name" + str(i), random.randint(10, 30)) for i in range(10000)]
students1 = [student for student in students]
students2 = [student for student in students]


def time_sort(f):
    def calcu():
        start = time.time()
        f()
        print(time.time() - start)

    return calcu


# sorted 不改变原列表，提供返回值,倒序使用reverse=True
@time_sort
def sorted_item():
    result = sorted(students, key=lambda student: student.age, reverse=True)
    # for student in result:
    #     print(student)

# 列表的排列方法sort，没有返回值，改变原来函数,倒序使用reverse=True
@time_sort
def lis_sort_item():
    students1.sort(key=lambda student: student.age, reverse=True)
    # for student in students1:
    #     print(student)

# 使用选择排序
@time_sort
def select_sort_item():
    for i in range(len(students2) - 1):
        max_index = i
        for j in range(i + 1, len(students2)):
            if students2[j].age < students2[max_index].age:
                max_index = j
        if max_index != i:
            students2[max_index], students2[i] = students2[i], students2[max_index]
    # for student in students2:
    #     print(student)


sorted_item()
lis_sort_item()
select_sort_item()

# 结果：
# 0.0010592937469482422
# 0.002000570297241211
# 4.239386796951294

⑤编写汽车类（颜色，速度）
编写人类（名字，汽车实例）
编写列表 放入三个人， 遍历列表依次打印每个人的信息（包含汽车）

class Car:
    def __init__(self, color, speed):
        self.color = color
        self.speed = speed

    def __str__(self):
        return f"颜色：{self.color},速度：{self.speed}\t"


c1 = Car("白色奔驰", "120")
c2 = Car("红色宝马", "150")
c3 = Car("黑色红旗", "180")


class Person:
    def __init__(self, name, c):
        if isinstance(c, Car):
            self.name = name
            self.car = c

    def __str__(self):
        return f"车主：{self.name}\t车型：{self.car}"


l1 = [Person("张三", c1), Person("李四", c2), Person("王五", c3)]

for e in l1:
    print(e)

⑥使用turtle模块结合类封装一下功能，
绘制圆形，绘制矩形，绘制三角形

class MyTurtle:

    def __init__(self, width=10, color="yellow", bg_color="#FF9999"):
        # turtle.Turtle() 是turtle模块中的一个类，用于创建一个对象。
        # 为turtle.Turtle()创建一个t对象，以后使用turtle的方法时，使用t.即可。
        self.t = turtle.Turtle()
        self.t.width(width)
        # turtle 中画笔颜色与填充颜色的方法
        self.t.color(color, bg_color)

    def draw_circle(self, radius=100, fill=True, extent=360):
        self.t.begin_fill() if fill else None
        self.t.circle(radius, extent=extent)
        self.t.end_fill() if fill else None

    def draw_rect(self, start_position=(-150, 50), width=300, height=100, fill=True):
        self.t.begin_fill() if fill else None
        # 开始位置
        self.move_to(start_position[0], start_position[1])
        # 设置头朝向
        self.t.setheading(0)
        # 画矩形
        for i in range(2):
            self.t.forward(width)
            self.t.right(90)
            self.t.forward(height)
            self.t.right(90)

        self.t.setheading(0)
        self.t.end_fill() if fill else None

    def draw_triangle(self, start_position=(-100, -150), length=300, fill=True):
        self.t.begin_fill() if fill else None
        # 开始位置
        self.move_to(start_position[0], start_position[1])
        # 设置头朝向
        self.t.setheading(0)
        # 画三角形
        for i in range(3):
            self.t.forward(length)
            self.t.left(120)

        self.t.setheading(0)
        self.t.end_fill() if fill else None

    def move_to(self, x, y):
        self.t.up()
        self.t.goto(x, y)
        self.t.down()

    def run(self):
        turtle.mainloop()


mt = MyTurtle(color="#00FF80")
mt.draw_circle()
mt.draw_rect()
mt.draw_triangle()
mt.run()

⑦编写装饰器两个案例（统计时间开销，添加权限校验）

# 统计时间开销（冒泡/选择/l.sort/sorted/）

# 对四个相同的列表进行排序
l1 = [random.randint(1, 50) for i in range(5000)]
l2 = [e for e in l1]
l3 = [e for e in l1]
l4 = [e for e in l1]


# 装饰器
# 外层的time_cost()函数包含内层的calc()函数
# 外层函数返回内层函数
# 内层函数可以使用外层函数的局部变量
def time_cost(f):
    def calc():
        start = time.time()
        f()
        print(f"花费时间：{time.time() - start}")

    return calc


@time_cost
def bubble_sort():
    """
    冒泡排序
    """
    for i in range(len(l1) - 1):
        for j in range(i + 1, len(l1)):
            if l1[i] > l1[j]:
                l1[i], l1[j] = l1[j], l1[i]


@time_cost
def select_sort():
    """
    选择排序
    """
    for i in range(len(l2) - 1):
        max_index = i
        for j in range(i + 1, len(l2)):
            if l2[max_index] > l2[j]:
                max_index = j
        if max_index != i:
            l2[max_index], l2[i] = l2[i], l2[max_index]


@time_cost
def lis_sort_item():
    """
    使用列表的sort()方法排序
    """
    l3.sort()


@time_cost
def sorted_item():
    """
    使用系统sorted()方法排序
    """
    result = sorted(l4)
    return result


bubble_sort()
select_sort()
lis_sort_item()
select_sort()

# 添加权限校验

def login_required(f):
    def check():
        name = input("请输入登录用户姓名：")
        if name == "admin":
            f()
        else:
            print("用户校验失败。")

    return check


@login_required
def mine():
    print("进入：  我的")


@login_required
def cart():
    print("进入：  购物车")


def main():
    print("进入：  首页")


main()
mine()
cart()

⑧创建一个名为 Person 的类，拥有 name 和 age 两个属性。实例化几个 Person 对象，并打印它们的属性。

class Person:
    """
    人类
    """

    def __init__(self, name, age):
        """
        初始化函数，self为调用此类的实例
        """
        self.name = name
        self.age = age

    def __str__(self):
        """
        打印实例自动调用str方法
        :return: 必须返回字符串
        """
        return f"姓名：{self.name}\t年龄：{self.age}\t"

    # 每个属性都有get和set两种方法
    # 便于更改属性的时候进行校验

    def get_name(self):
        """
        获取
        :return:
        """
        return self.name

    def set_name(self, n):
        """
        设置属性，便于校验
        """
        if 2 <= len(n) <= 4:
            self.name = n
        else:
            print("名字输入不合法。")

    def get_age(self):
        """
        获取年龄
        """
        return self.age

    def set_age(self, a):
        """
        更改年龄
        """
        if 18 <= a <= 25:
            self.age = a
        else:
            print("年龄输入不合法。")


p1 = Person("张三", 20)
print(p1.get_name())
p1.set_name("张三11111111111111")
print("*" * 30)
p1.set_name("张三2")
print(p1.get_name())

p1.set_age(100)
print(p1.get_age())

print(Person("张三", 20))
print(Person("李四", 23))
print(Person("王五", 25))

⑨创建一个名为 BankAccount 的类，拥有 balance 属性和 deposit()、withdraw() 两个方法。
实例化一个 BankAccount 对象，然后进行一些存款和取款操作。

class BankAccount:
    def __init__(self, balance):
        """
        初始化总金额
        :param balance:
        """
        self.balance = balance

    def deposit(self, n):
        """
        存钱
        """
        self.balance += n

    def withdraw(self, n):
        """
        取钱
        """
        if self.balance >= n:
            self.balance -= n
        else:
            print("余额不足。")

    def __str__(self):
        """
        可以直接调用获取函数，即get函数
        :return:
        """
        return self.get_balance()

    def get_balance(self):
        """
        获取余额
        :return:
        """
        return f"余额为：{self.balance}"


b1 = BankAccount(300)
b1.deposit(100)
print(f"余额：{b1.balance}")
print("*"*30)
print(b1)

⑩创建一个名为 Car 的类，拥有 brand 和 color 两个属性，以及 start() 和 stop() 两个方法。
实例化一个 Car 对象，并调用 start() 和 stop() 方法。

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color
        self.speed = 0
        self.running = False

    def start(self):
        self.running = True
        self.speed = 0
        return f"品牌为{self.brand},颜色为{self.color}，速度为{self.speed}的车启动~"

    def speed_up(self, n):
        if self.running:
            s = self.speed + n
            if s > 120:
                print("加速不合理，加速完后已超速。")
            else:
                self.speed += n
        else:
            print("车子未启动")

    def speed_down(self, n):
        if self.running:
            s = self.speed - n
            if s < 0:
                print("减速不合理，减速完后已为负值。")
            else:
                self.speed -= n
        else:
            print("车子未启动")

    def get_speed(self):
        return f"现在的速度为：{self.speed}"

    def stop(self):
        self.running = False
        self.speed = 0
        return f"品牌为{self.brand},颜色为{self.color}的车停止。"


c1 = Car("奔驰", "黑色")
c1.speed_up(20)
c1.start()
c1.speed_up(20)
print(c1.get_speed())
c1.speed_up(100)
print(c1.get_speed())
c1.speed_up(20)

⑪创建一个名为 Employee 的类，拥有 name、salary 和 hire_date 三个属性。
实现一个计算员工服务年限的方法，并打印出员工的名字、薪水和服务年限。

class Employee:
    def __init__(self, name, salary, h):
        self.name = name
        self.salary = salary
        self.hire_date = h

    def service_year(self):
        # 如果使用datetime.today() 需要将此方法转换成和下面要求时间一样的type,即：datetime.today().date()
        today = date.today()
        # 相减后，为timedelta类型，返回天数和秒数两部分
        td = today - self.hire_date
        # 整除求余
        hd = divmod(td.days, 365)
        return hd

    def __str__(self):
        # self.service_year()
        return f"员工：{self.name}\t工资：{self.salary}\t服务年限:{self.service_year()[0]}年{self.service_year()[0]}天"


hire_date = date(year=2020, month=1, day=1)
#  datetime.date()
print(Employee("张三", 23000, hire_date))
print(Employee("李四", 13000, hire_date))
print(Employee("王五", 33000, hire_date))

⑫创建一个名为 Student 的类，拥有 name、id 和 scores 三个属性。
scores 是一个字典，包含多个科目的成绩。为 Student 实现一个名为 average_score() 的方法，计算该学生的平均分数

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

    def average_score(self):
        total = 0
        for score in self.scores.values():
            total += score
        return total / len(self.scores)

    def __str__(self):
        return f"姓名：{self.name}\t学号：{self.sid}\t平均成绩：{self.average_score()}"


print(Student("张三", 1, {"c++": 100, "java": 99, "c#": 98, "python": 97, "go": 96}))

print(Student("李四", 2, {"c++": 50, "java": 89, "c#": 58, "python": 90, "go": 66}))

⑬编写角色类，拥有血量【3000,5000】和攻击力【100,300】
随机10个角色（血量，攻击力随机）放入列表
列表中的角色依次攻击下一个（最后一个攻击第一个）
角色死亡后移除列表，输出最后存货角色信息

class Role:
    """
    单个角色类
    """
    def __init__(self, rid, blood_value, damage_value):
        self.rid = rid
        self.blood_value = blood_value
        self.damage = damage_value

    def __str__(self):
        return f"角色：{self.rid}    血量剩余：{self.blood_value}    攻击力：{self.damage}"


class RoleManage:
    """
    角色管理
    """
    def __init__(self):
        self.lis = []
        self.role = Role

    def add_role(self):
        for i in range(10):
            role = self.role("role" + str(i), random.randint(3000, 5000), random.randint(100, 300))
            self.lis.append(role)

    def is_winner(self, i):
        if len(self.lis) == 1:
            print(f"最后存货角色：{self.lis[i]}")
            # 还有一个可以退出
            return False
        else:
            # 否则继续战斗
            self.lis.pop(i) if self.lis[i].blood_value < 0 else None
            return True

    def fight(self):
        count = 0
        flag = True
        while flag:
            # 方法一：
            for i in range(len(self.lis) - 1, -1, -1):
                if i == 0:
                    self.lis[i].blood_value -= self.lis[len(self.lis) - 1].damage
                    # print(self.lis[i])
                    flag = self.is_winner(i)

                else:
                    self.lis[i].blood_value -= self.lis[i - 1].damage
                    # print(self.lis[i])
                    flag = self.is_winner(i)
            # 或者 self.lis[(i+1) % len(self.lis)]
            for i in range(len(self.lis)):
                self.lis[(i+1) % len(self.lis)].blood_value -= self.lis[i - 1].damage


rm1 = RoleManage()
rm1.add_role()
rm1.fight()

⑭饲养员类
数据：名字
方法：喂养(动物，草)
行走()
动物类
数据：名字
方法：吃
行走
食物类
数据：名字
实现饲养员给动物喂食物。

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

    def feed(self, animal, food):
        print(f"饲养员{self.name}喂{animal.eat(food)}。")

    def walk(self):
        print(f"饲养员{self.name}在行走。")


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

    def eat(self, food):
        return f"{self.name}吃{food.name}"

    def walk(self):
        print(f"{self.name}在行走。")


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


a1 = Animal("老虎")
a2 = Animal("鸭子")

f1 = Food("草")
f2 = Food("肉")

Keeper("张三").feed(a1, f2)
Keeper("李四").feed(a2, f1)
# # 饲养员张三在给老虎喂肉。
# # 饲养员李四在给鸭子喂草。