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

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

12.飞机大战游戏

    1.项目目录结构
        ~/Desktop/Python/03_飞机大战游戏 $ tree -L 1
        .
        ├── __pycache__
        ├── images
        ├── plane_main.py
        └── plane_sprites.py

    2.plane_main.py文件代码

import pygame
from plane_sprites import *


class PlaneGame(object):
    """飞机大战主游戏"""

    def __init__(self):
        pygame.init()
        print("游戏初始化")

        # 1.创建游戏的窗口
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)

        # 2.创建游戏的时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法完成精灵和精灵组的创建
        self.__create_sprites()

        # 4.设置定时器时间-创建敌机 ENEMY_TIME时间出场一次
        pygame.time.set_timer(CREATE_ENEMY_EVENT, ENEMY_TIME)
        # 5.设定定时器时间-英雄子弹 FIRE_TIME时间发射一次
        pygame.time.set_timer(HERO_FIRE_EVENT, FIRE_TIME)
        # 6.设定定时器时间-敌机子弹 ENEMY_FIRE_EVENT时间发射一次
        pass

    def __create_sprites(self):

        # 创建背景精灵和精灵组
        bg1 = Background()
        bg2 = Background(True)

        self.back_group = pygame.sprite.Group(bg1, bg2)

        # 创建敌机的精灵组
        self.enemy_group = pygame.sprite.Group()

        # 创建英雄的精灵和精灵组
        self.hero = Hero()
        self.hero_group = pygame.sprite.Group(self.hero)

    def start_game(self):
        # print("游戏开始...")

        while True:

            # 1.设置刷新帧率
            self.clock.tick(FRAME_PER_SEC)
            # 2.事件监听
            self.__event_handler()
            # 3.碰撞检测
            self.__check_collide()
            # 4.更新/绘制精灵组
            self.__update_sprites()
            # 5.更新显示
            pygame.display.update()

    def __event_handler(self):
        """事件监听"""

        for event in pygame.event.get():

            # 判断是否退出游戏
            if event.type == pygame.QUIT:
                PlaneGame.__game_over()
            # 监听敌机出场事件
            elif event.type == CREATE_ENEMY_EVENT:
                # print(CREATE_ENEMY_EVENT, "敌机出场...")
                # 创建敌机精灵
                enemy = Enemy()

                # 将敌机精灵添加到敌机精灵组
                self.enemy_group.add(enemy)
            # 监听英雄发射子弹事件
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()
            # 事件监听模式获取按键
            # elif event.type == pygame.KEYDOWN and \
            #         event.key == pygame.K_RIGHT:
            #     print("单次向右移动...")

        # 使用键盘提供的方法获取键盘按键-返回按键元组
        # 获取键盘按键键位
        keys_pressed = pygame.key.get_pressed()
        # 判断元组中对应的按键索引值
        if keys_pressed[pygame.K_RIGHT]:
            # print("持续向右移动...")
            self.hero.around = True
            self.hero.speed = HERO_RIGHT_LEFT
        elif keys_pressed[pygame.K_LEFT]:
            self.hero.around = True
            self.hero.speed = -HERO_RIGHT_LEFT
        elif keys_pressed[pygame.K_UP]:
            self.hero.around = False
            self.hero.speed = -HERO_UP_DOWN
        elif keys_pressed[pygame.K_DOWN]:
            self.hero.around = False
            self.hero.speed = HERO_UP_DOWN
        else:
            self.hero.speed = 0

    def __check_collide(self):
        """碰撞检测"""

        # 1.子弹摧毁敌机
        pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)

        # 2.敌机撞毁英雄
        enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)

        #  判断列表是否有类容
        if len(enemies) > 0:

            # 让英雄牺牲
            self.hero.kill()

            # 结束游戏
            PlaneGame.__game_over()

    def __update_sprites(self):
        """更新显示"""

        self.back_group.update()
        self.back_group.draw(self.screen)

        self.enemy_group.update()
        self.enemy_group.draw(self.screen)

        self.hero_group.update()
        self.hero_group.draw(self.screen)

        self.hero.bullets.update()
        self.hero.bullets.draw(self.screen)

    @staticmethod
    def __game_over():
        print("游戏结束")

        pygame.quit()
        exit()


if __name__ == '__main__':
    # 创建游戏对象
    game = PlaneGame()

    # 启动游戏
    game.start_game()

    3.plane_sprites.py文件代码

import random
import pygame


# 屏幕大小的常量
SCREEN_RECT = pygame.Rect(0, 0, 480, 700)
# 屏幕的刷新帧率
FRAME_PER_SEC = 60
# 屏幕的背景图像
BG1_PNG = "./images/background2.png"

# 创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
# 敌人出现时间的间隔,多少毫秒出现
ENEMY_TIME = 300
# 敌机的图片
ENEMY1_PNG = "./images/enemy4.png"
# 敌机的最大/最小速度
ENEMY_MAX_SD = 7
ENEMY_MIN_SD = 3

# 英雄的图片
HERO_PNG = "./images/me3.png"
# 英雄距离屏幕底端的距离
HERO_MAX_Y = 120
# 英雄左右移动速度
HERO_RIGHT_LEFT = 4
# 英雄上下移动速度
HERO_UP_DOWN = 2

# 英雄发射子弹的定时器常量
HERO_FIRE_EVENT = pygame.USEREVENT + 1
# 英雄子弹自动发射间隔 0.5秒发射一次
FIRE_TIME = 500
# 英雄子弹图片
BULLET_PNG = "./images/bomb.png"
# 英雄子弹飞行速度
BULLET_TIME = -3


class GameSprite(pygame.sprite.Sprite):
    """飞机大战游戏精灵"""

    def __init__(self, image_name, speed=1):
        # 调用父类的初始化方法
        super().__init__()

        # 定义对象的属性
        self.image = pygame.image.load(image_name)
        self.rect = self.image.get_rect()
        self.speed = speed

    def update(self):
        # 屏幕的垂直方向上移动
        self.rect.y += self.speed


class Background(GameSprite):
    """游戏背景精灵"""

    def __init__(self, is_alt=False):

        # 1.调用父类方法实现精灵的创建(images/rect/speed)
        super().__init__(BG1_PNG)

        # 2.判断是否是交替图像,如果是则设置初始位置
        if is_alt:
            self.rect.y = -self.rect.height

    def update(self):

        # 1.调用父类的方法实现
        super().update()

        # 2.判断是否移出屏幕,移出则将图像设置到屏幕的上方
        if self.rect.y >= SCREEN_RECT.height:
            self.rect.y = -self.rect.height
        pass


class Enemy(GameSprite):
    """敌机精灵"""

    def __init__(self):
        # 1.调用父类方法,创建敌机精灵,同时指定敌机图片
        super().__init__(ENEMY1_PNG)
        # 2.指定敌机的初始随机速度
        self.speed = random.randint(ENEMY_MIN_SD, ENEMY_MAX_SD)
        # 3.指定敌机的初始随机位置,bottom=y+height
        self.rect.bottom = 0

        max_x = SCREEN_RECT.width - self.rect.width
        self.rect.x = random.randint(0, max_x)

    def update(self):
        # 1.调用父类方法保持垂直方向的飞行
        super().update()
        # 2.判断是否飞出屏幕,是则从精灵组中删除敌机
        if self.rect.y >= SCREEN_RECT.height:
            # print("飞出屏幕,需要从精灵组删除...")
            # kill方法可以将精灵从所有精灵组中移出,自动销毁
            self.kill()

    def __del__(self):
        # print("敌机销毁 %s" % self.rect)
        pass


class Hero(GameSprite):
    """英雄精灵"""

    def __init__(self):

        # 1.调用父类方法,设置images/speed
        super().__init__(HERO_PNG, 0)

        # 2.设置英雄的初始位置
        self.rect.centerx = SCREEN_RECT.centerx
        self.rect.bottom = SCREEN_RECT.bottom - HERO_MAX_Y

        # 3.设置英雄的初始控制模式,True左右飞行,False上下飞行
        self.around = True

        # 4.创建子弹的精灵组
        self.bullets = pygame.sprite.Group()

    def update(self, ):

        # 英雄在水平/垂直方向移动
        if self.around:
            self.rect.x += self.speed
        else:
            self.rect.y += self.speed

        # 控制英雄不能离开屏幕,right=x+width
        if self.rect.x < 0:
            self.rect.x = 0
        elif self.rect.right > SCREEN_RECT.right:
            self.rect.right = SCREEN_RECT.right
        elif self.rect.y < 0:
            self.rect.y = 0
        elif self.rect.bottom > SCREEN_RECT.bottom:
            self.rect.bottom = SCREEN_RECT.bottom

    def fire(self):
        # print("发射子弹...")

        for i in (0, 1):
            # 1.创建子弹精灵
            bullet = Bullet()

            # 2.设置精灵的位置
            bullet.rect.bottom = self.rect.y - i * 50
            bullet.rect.centerx = self.rect.centerx

            # 3.将精灵添加到精灵组
            self.bullets.add(bullet)


class Bullet(GameSprite):
    """子弹精灵"""

    def __init__(self):
        # 调用父类方法,设置子弹图片和初始速度
        super().__init__(BULLET_PNG, BULLET_TIME)

    def update(self):
        # 调用父类方法,让子弹沿垂直方向飞行
        super().update()

        # 判断子弹是否飞出屏幕
        if self.rect.bottom < 0:
            self.kill()

    def __del__(self):
        # print("子弹被销毁...")
        pass

    4.完整项目网盘链接: https://pan.baidu.com/s/1CagTcHaIdt_vH6HyDiOYPA  密码: qkwa