14_Python语法示例(面向对象)

1.自己写一个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()

2.定义一个类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 '')
        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()

3.写一个自行车类有骑行方法,调用时显示骑行里程km,再写一个电动自行车类继承第一个类,添加电池电量属性,同时有两个方法

# fill_charge(vol) 用来充电, vol 为电量(度), 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)

4.写一个实现迭代器协议的类 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

5.实现文件的复制(建议使用二进制方式进行操作)

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()

6.实现两个自定义列表的相加

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])

7.实现有序集合类 OrderSet(), 能实现两个集合的交集 &, 并集 | 补集 -, 对称补集 ^, ==, != 等操作(写集合相同)

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("不相同")  # 不相同

8.模拟英雄联盟写一个游戏人物的类

"""
    (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血

9.暴力摩托程序(完成下列需求)

"""
    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('echo', i, 'male', 'python'))
for i in range(200):
    employ_lst.append(Employee('Rubicon', i, 'male', 'python'))
for i in range(200):
    employ_lst.append(Employee('master', i, 'male', 'python'))

# print(employ_lst)
# set集合的去重机制: 先调用hash,再调用eq,eq不是每次都触发,只有hash值相等的时候才会触发
employ_set = set(employ_lst)
for person in employ_set:
    print(person.__dict__)

11.反射实现选课系统

"""userinfo文件内容
    echo|123456|Manager
    jojo|666|Student
    master|2222|Teacher
"""
class Manager:
    OPERATE_DIC = [
        ('创造学生账号', 'create_student'),
        ('创建课程', 'create_course'),
        ('查看学生信息', 'check_student_info'),
    ]

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

    def create_student(self):
        print('创建学生账号')

    def create_course(self):
        print('创建课程')

    def check_student_info(self):
        print('查看学生信息')

class Student:
    OPERATE_DIC = [
        ('查看所有课程', 'check_course'),
        ('选择课程', 'choose_course'),
        ('查看已选择的课程', 'choosed_course')
    ]

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

    def check_course(self):
        print('check_course')

    def choose_course(self):
        print('choose_course')

    def choosed_course(self):
        print('查看已选择的课程')

def login():
    username = input('user: ')
    password = input('pwd: ')
    with open('userinfo') as f:
        for line in f:
            user, pwd, ident = line.strip().split('|')  # ident = 'Manager'
            if user == username and pwd == password:
                print('登录成功')
                return username, ident

def main():
    usr, id = login()
    print('user,id :', usr, id)
    file = sys.modules['__main__']
    cls = getattr(file, id)  # Manager = getattr(当前文件,'Manager')
    obj = cls(usr)
    operate_dic = cls.OPERATE_DIC
    while True:
        for num, i in enumerate(operate_dic, 1):
            print(num, i[0])
        choice = int(input('num >>>'))
        choice_item = operate_dic[choice-1]
        getattr(obj, choice_item[1])()

if __name__ == '__main__':
    main()