一、相关术语
①面向对象
面向对象是将实例的属性及行为进行封装,对不同的实例可以使用同一类实现。即编码的实现更关心实例的数据和操作。
②类
将相类似实例的属性及行为进行封装。即是实例的模版,在模版中实例可以编写属性及进行操作。
③实例
每个具体的对象。
④初始化方法
__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)
# # 饲养员张三在给老虎喂肉。
# # 饲养员李四在给鸭子喂草。