Python_面向对象练习题，,面向对象练习:

Python_面向对象练习题，,面向对象练习:

面向对象练习:
"""侧重于面向对象"""

01.自己写一个Student类,此类的对象有属性name, age, score, 用来保存学生的姓名,年龄,成绩:
1) 写一个函数input_student读入n个学生的信息,用对象来存储这些信息(不用字典),并返回对象的列表
2) 写一个函数output_student 打印这些学生信息(格式不限)
class Student():
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score


def input_student():
L = []
while True:
name = input("姓名:")
if not name:
break
age = input("年龄:")
score = input("成绩:")
s = Student(name, age, score)
L.append(s)
return L


def output_student(lst):
for i in lst:
print("姓名:%s 年龄:%s 成绩:%s" % (i.name, i.age, i.score))


def main():
L = input_student()
output_student(L)


main()

02.定义一个类Huamn(人类),定义函数input_human录入信息,main调用显示信息:
有三个属性:姓名name,年龄age,家庭住址address (可以省略没有)
有方法:show_info 用来显示人的信息,update_age用来让这个人的年龄增加一岁
class Huamn():
total_count = 0
def __init__(self, name, age, address=None):
self.name = name
self.age = age
self.address = address
self.__class__.total_count += 1

def show_info(self):
print("姓名:%s 年龄:%s 地址:%s" % (self.name, self.age, self.address))

def updata_age(self):
self.age += 1

@classmethod
def get_huamn_count(cls):
return cls.total_count

def __del__(self):
self.__class__.total_count -= 1


def input_human():
L = []
while True:
name = input("姓名:")
if not name:
break
age = int(input("年龄:") or ‘0‘)
address = input("地址:")
s = Huamn(name, age, address)
L.append(s)
return L


def main():
L = input_human()
for obj in L:
obj.show_info() # 列出所有人的信息
for obj in L:
obj.updata_age() # 让所有人都长一岁
for obj in L:
obj.show_info() # 再次列表所有人的信息
print("当前总人数是%s" % Huamn.get_huamn_count())


main()

03.写一个Bicycle(自行车)类,有run(骑行)方法, 调用时显示骑行里程km:
再写一个电动自行车类EBicycle继承自Bicycle,添加电池电量valume属性, 同时有两个方法：
1. fill_charge(vol) 用来充电, vol 为电量(度)
2. run(km) 方法用于骑行,每骑行10km消耗电量1度,当电量消耗尽时调用Bicycle的run方法骑行
并显示骑行结果
class Bycycle():
def run(self, km):
print("自行车骑行了%s公里" % km)


class Ebicycle(Bycycle):
def __init__(self, valume):
self.valume = valume

def fill_charge(self, vol):
self.valume += vol

def run(self, km):
e_km = min(km, self.valume * 10)
self.valume -= e_km / 10 # 电量消耗
if e_km > 0:
print("电动自行车骑行了", e_km, "公里")
if km > e_km: # 判断没电后行驶的过程
super().run(km - e_km)


b = Ebicycle(5)
b.run(10)
b.run(100)
b.fill_charge(6)
b.run(70)

04.写一个实现迭代器协议的类 Primes 让此类可以生成从b开始的n个素数:
class Primes:
@staticmethod
def __isprime(x):
for i in range(2, x):
if x % i == 0:
return False
return True

def __init__(self, b, n):
self.begin = b
self.count = n

def __iter__(self):
self.cur_pos = self.begin # 设置迭代的起始值
self.cur_count = 0 # 用于记录已生成几个
return self

def __next__(self):
# 已完成生成, 不需要再生成, 我停止迭代
if self.cur_count >= self.count:
raise StopIteration
self.cur_count += 1 # 计数加1
while True:
if self.__isprime(self.cur_pos):
v = self.cur_pos
self.cur_pos += 1
return v
self.cur_pos += 1 # 为下一次循环做准备

for x in Primes(10, 4):
print(x) # 11 13 17 19

05.实现文件的复制(建议使用二进制方式进行操作):
def mycp(src_file, dst_file):
‘‘‘
src_file 源文件名
dst_file 目标文件名
‘‘‘
try:
with open(src_file, ‘rb‘) as fr, open(dst_file, ‘wb‘) as fw:
# 如果文件太大则分次进行搬移
while True:
b = fr.read(4096) # 如果此文件大怎么办？
if not b: # 如果字节串为空, 停止复制
break
fw.write(b)
except:
return False
return True

def main():
src = input("请输入源文件名:")
dst = input("请输入目标文件名:")
if mycp(src, dst):
print("复制文件成功")
else:
print("复制文件失败")

main()

06.实现两个自定义列表的相加:
class MyList:
def __init__(self, iterable):
self.data = [x for x in iterable]

def __repr__(self):
return ‘MyList(%r)‘ % self.data

def __add__(self, rhs):
return MyList(self.data + rhs.data)

def __mul__(self, rhs):
return MyList(self.data * rhs)

L1 = MyList([1, 2, 3])
L2 = MyList(range(4, 7))
L3 = L1 + L2
print("L3 =", L3) # MyList([1,2,3,4,5,6])
L4 = L1 * 2 # 实现乘法运算
print(‘L4 =‘, L4) # MyList([1,2,3,1,2,3])

07.实现有序集合类 OrderSet(), 能实现两个集合的交集 &, 并集 | 补集 -, 对称补集 ^, ==, != 等操作(写集合相同):
要求: 集合内部用list存储
class OrderSet:
def __init__(self, iterable):
self.data = [x for x in iterable]

def __repr__(self):
return ‘OrderSet(%r)‘ % self.data

def __and__(self, rhs):
return OrderSet(set(self.data) & set(rhs.data))

def __or__(self, rhs):
return OrderSet(set(self.data) | set(rhs.data))

def __xor__(self, rhs):
return OrderSet(set(self.data) ^ set(rhs.data))


s1 = OrderSet([1,2,3,4])
s2 = OrderSet([3,4,5])
print(s1 & s2) # OrderSet([3,4])
print(s1 | s2) # OrderSet([1,2,3,4,5])
print(s1 ^ s2) # OrderSet([1,2,5])
if OrderSet([1,2,3]) != OrderSet([1,2,3,4]):
print("不相同") # 不相同

08. 模拟英雄联盟写一个游戏人物的类:
(1)创建一个 Game_role的类.
(2) 构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性.
(3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能:
例: 实例化一个对象 盖伦,ad为10, hp为100
实例化另个一个对象 剑豪 ad为20, hp为80
盖伦通过attack方法攻击剑豪,此方法要完成 ‘谁攻击谁,谁掉了多少血, 还剩多少血‘的提示功能
class Game_role:
def __init__(self, name, ad, hp):
self.name = name
self.ad = ad
self.hp = hp

def attack(self, p):
p.hp = p.hp - self.ad
print("%s攻击了%s, %s掉了%s血, 还剩%s血" % (self.name, p.name, p.name, self.ad, p.hp))


p1 = Game_role(‘盖伦‘, 10, 100)
p2 = Game_role(‘剑豪‘, 20, 80)

p1.attack(p2) # 盖伦攻击了剑豪, 剑豪掉了10血, 还剩70血

09. 暴力摩托程序（完成下列需求）：
1.1 创建三个游戏人物，分别是：
• 苍井井，女，18，攻击力ad为20，血量200
• 东尼木木，男，20，攻击力ad为30，血量150
• 波多多，女，19，攻击力ad为50，血量80
1.2 创建三个游戏武器，分别是：
• 平底锅，ad为20
• 斧子，ad为50
• 双节棍，ad为65
1.3 创建三个游戏摩托车，分别是：
• 小踏板，速度60迈
• 雅马哈，速度80迈
• 宝马，速度120迈
1.4 完成下列需求（利用武器打人掉的血量为武器的ad + 人的ad）:
（1）苍井井骑着小踏板开着60迈的车行驶在赛道上。
（2）东尼木木骑着宝马开着120迈的车行驶在赛道上。
（3）波多多骑着雅马哈开着80迈的车行驶在赛道上。
（4）苍井井赤手空拳打了波多多20滴血，波多多还剩xx血。
（5）东尼木木赤手空拳打了波多多30滴血，波多多还剩xx血。
（6）波多多利用平底锅打了苍井井一平底锅，苍井井还剩xx血。
（7）波多多利用斧子打了东尼木木一斧子，东尼木木还剩xx血。
（8）苍井井骑着宝马打了骑着小踏板的东尼木木一双节棍，东尼木木哭了，还剩xx血。
（9）波多多骑着小踏板打了骑着雅马哈的东尼木木一斧子，东尼木木哭了，还剩xx血。
class GameRole:
"""游戏角色类"""
def __init__(self, name, sex, age, ad, hp):
self.name = name
self.sex = sex
self.age = age
self.ad = ad
self.hp = hp

def add_moto(self, mo):
self.mo = mo

def attack(self,p):
p.hp = p.hp - self.ad
print(‘%s赤手空拳打了%s%s滴血，%s还剩%s血‘ %(self.name,p.name,self.ad,p.name,p.hp))

def add_weapon(self, wea):
self.wea = wea

def road_rush(self, p):
p.hp = p.hp - self.ad - self.wea.ad
print(‘%s骑着%s打了骑着%s的%s一%s，%s哭了，还剩%s血‘ \
%(self.name, self.mo.name, p.mo.name, p.name, self.wea.name, p.name, p.hp))

class Weapon:
"""武器类"""
def __init__(self, name, ad):
self.name = name
self.ad = ad

def fight(self,p1,p2):
p2.hp = p2.hp - p1.ad - self.ad
# print(‘ %s利用%s打了%s一%s，%s还剩%s血‘ %(p1.name,self.name,p2.name,self.name,p2.name,p2.hp))
print(‘{0}利用{1}打了{2}一{1},{2}还剩{3}血‘.format(p1.name,self.name,p2.name,p2.hp))

class Moto:
"""摩托车类"""
def __init__(self, name, speed):
self.name = name
self.speed = speed

def drive(self, p):
print(‘%s骑着%s开着%d迈的车行驶在赛道上‘ % (p.name, self.name, self.speed))


p1 = GameRole(‘苍井井‘,‘女‘,18,20,200)
p2 = GameRole(‘东尼木木‘,‘男‘,20,30,150)
p3 = GameRole(‘波多多‘,‘女‘,19,50,80)

w1 = Weapon(‘平底锅‘,20)
w2 = Weapon(‘斧子‘,50)
w3 = Weapon(‘双节棍‘,65)

m1 = Moto(‘小踏板‘,60)
m2 = Moto(‘雅马哈‘,80)
m3 = Moto(‘宝马‘,120)

# 组合: 给p1 对象封装了一个属性,属性值 m1这个对象
p1.add_moto(m1)
p1.mo.drive(p1) # 苍井井骑着小踏板开着60迈的车行驶在赛道上

p2.add_moto(m2)
p2.mo.drive(p2) # 东尼木木骑着雅马哈开着80迈的车行驶在赛道上

p3.add_moto(m3)
p3.mo.drive(p3) # 波多多骑着宝马开着120迈的车行驶在赛道上

p1.attack(p3) # 苍井井赤手空拳打了波多多20滴血，波多多还剩60血
p2.attack(p3) # 东尼木木赤手空拳打了波多多30滴血，波多多还剩30血

p3.add_weapon(w1)
p3.wea.fight(p3,p1) # 波多多利用平底锅打了苍井井一平底锅,苍井井还剩130血
p3.add_weapon(w2)
p3.wea.fight(p3, p2) # 波多多利用斧子打了东尼木木一斧子,东尼木木还剩50血

p1.add_moto(m3)
p1.add_weapon(w3)
p2.add_moto(m1)
p1.road_rush(p2) # 苍井井骑着宝马打了骑着小踏板的东尼木木一双节棍，东尼木木哭了，还剩-35血

p3.add_moto(m1)
p2.add_moto(m2)
p3.road_rush(p2) # 波多多骑着小踏板打了骑着雅马哈的东尼木木一斧子，东尼木木哭了，还剩-135血

10. 有1000个员工如果几个员工对象的姓名和性别相同,这是一个人,请对这1000个员工做去重:
class Employee:
def __init__(self,name,age,sex,partment):
self.name = name
self.age = age
self.sex = sex
self.partment = partment
def __hash__(self):
return hash(‘%s%s‘%(self.name,self.sex))
def __eq__(self, other):
if self.name == other.name and self.sex == other.sex:
return True
employ_lst = []
for i in range(200):
employ_lst.append(Employee(‘alex‘,i,‘male‘,‘python‘))
for i in range(200):
employ_lst.append(Employee(‘wusir‘,i,‘male‘,‘python‘))
for i in range(200):
employ_lst.append(Employee(‘taibai‘, i, ‘male‘, ‘python‘))

# print(employ_lst)
employ_set = set(employ_lst)
for person in employ_set:
print(person.__dict__)

# set集合的去重机制 : 先调用hash,再调用eq,eq不是每次都触发,只有hash值相等的时候才会触发

Python_面向对象练习题