Python学习笔记之基础练习

第一题：

        游戏规则:
        1. 游戏背景为10*10；
        2. 游戏会自动生成1个乌龟和10条鱼；
        3. 它们移动方向随机;
        4. 乌龟最大移动能力为2； [-2,-1,1,2]
        5. 鱼最大移动能力为1； [-1,1]
        6. 当移动到场景边界， 自动反方向移动;
        7. 乌龟初始化体能为100<200为上限>;每移动一次消耗体能1；
        8. 当乌龟和鱼的坐标重合， 代表乌龟吃掉鱼， 体能增加20；

        9. 乌龟无体力或者鱼吃光， 游戏结束;

import random

class BaseAmil(object):
    def __init__(self):
        self.x = random.randint(0, 9)
        self.y = random.randint(0, 9)

    def is_vaild(self, point):
        if point < 0 :
            return 0-point
        elif point>9:
            return 9 - (point-9)
        return point

class Turtle(BaseAmil):
    def __init__(self):
        super(Turtle,self).__init__()
        self.power = 100
    def move(self):
        move_skill = [-1, 1, 0, -2, 2]
        new_x = self.x + random.choice(move_skill)
        new_y = self.y + random.choice(move_skill)
        self.x = self.is_vaild(new_x)
        self.y = self.is_vaild(new_y)
        self.power -= 1
    def eat(self):
        self.power +=20
        # 乌龟体能上限为200
        if self.power >=200:
            self.power =200
class Fish(BaseAmil):

    def move(self):
        move_skill = [-1, 0, 1]
        new_x = self.x + random.choice(move_skill)  # 1
        new_y = self.y + random.choice(move_skill)  # 12

        self.x = self.is_vaild(new_x)
        self.y = self.is_vaild(new_y)

def main():
    t1 = Turtle()  #生成一个乌龟对象
    fishs = [Fish() for i in range(10)]
    while True:
        if t1.power < 0:
            print('乌龟死翘桥！Game Over....')
            break
        elif len(fishs)==0:
            print('鱼被乌龟吃完了！Game Over')
            break
        else:
            t1.move()
            for fish in fishs:
                fish.move()
                #通过判断两个坐标是否相等 来判断乌龟是否吃鱼
                if t1.x == fish.x and t1.y == fish.y:
                    t1.eat()
                    #将当前这条鱼从列表中删除
                    fishs.remove(fish)
                    print('鱼被吃掉！,乌龟体能为：%s'%(t1.power))

if __name__ == '__main__':
    main()

第二题：

        简单实现一个图书管理系统，每本书都有自己的属性，书名，作者，位置，是否借出（每一类书只有一本）。

        方法有可以查找指定书籍是否已经借出，图书馆所有书的信息浏览，借出书籍，归还书籍。

class Book(object):
    def __init__(self, name, author, state, bookIndex):
        self.name = name
        self.author = author
        #0表示已经借出，1表示没有借出
        self.state = state
        self.bookIndex = bookIndex

    def __str__(self):
        return '书籍名称《%s》 作者：%s 状态：%s 位置：%s'%(self.name, self.author, self.state, self.bookIndex )

class BookManage(object):
    books = dict()

    def init(self):
        self.books['python']=Book('python', 'Guido', 1, "INS888")
        self.books['java'] = Book('java', 'Guido', 1, "INS888")
        self.books['C/C++'] = Book('C/C++', 'Guido', 1, "INS888")
    # def __str__(self):
    #     return '书籍名称《%s》 作者：%s 状态：%s 位置：%s'%(self.books)

    def addBook(self):
        name = input('书名：')
        self.books[name]=Book(name,input('作者：'),1,input('书籍位置：'))
        print('添加图书%s成功'%(name))

    def borrowBook(self):
        name = input("书籍名称")
        ret = self.checkBook(name)
        if ret !=None:
            if ret.state == 0:
                print('书籍《%s》已经借出'%(name))
            else:
                ret.state = 0  #书籍借出，将状态改变
                print('借阅书籍《%s》成功'%(name))
        else:
            print('书籍《%s》不存在'%(name))

    def checkBook(self,name):
        """
        :param name: 书籍名
        :return: 如果这本书不存在，返回None，否则返回这本书的对象
        """
        if name in self.books.keys():
            return self.books[name]
        else:
            return None

    def findBook(self):
        name = input('书籍名称')
        ret = self.checkBook(name)
        if ret != None:
            print(self.books[name])
        else:
            print('书籍《%s》不存在' % (name))

    def huanbook(self):
        name = input('书籍名称')
        ret = self.checkBook(name)
        if ret != None:
            if self.books[name].state == 0:
                self.books[name].state = 1
                print('书籍《%s》归还成功'%(name))
            else:
                print('书籍《%s》没有被借出' % (name))
        else:
            print('书籍《%s》不存在' % (name))
    def Menu(self):
        self.init()
        while True:
            print("""
                               图书管理系统
                    1. 查询
                    2. 增加
                    3. 借阅
                    4. 归还
                    5. 退出
            """)

            choice = input("Choice:")
            if choice == "1":
                self.findBook()
            elif choice == '2':
                self.addBook()
            elif choice == '3':
                self.borrowBook()
            elif choice == '4':
                self.huanbook()
            elif choice == '5':
                exit(0)
            else:
                print("请输入正确选择!")

bookManage = BookManage()
bookManage.Menu()

第三题：

有一个停车场管理系统实习那下面功能：

（1）添加功能：程序能够添加到达停车场的车辆信息，要求车辆的车牌号要唯一，如果添加了重复的记录时，则提示数据添加重复并取消添加。
（2）查询功能：可根据车牌号、车型等信息对已添加的停车场中的车辆信息进行查询，如果未找到，给出相应的提示信息，
    如果找到，则显示相应的记录信息；
（3）显示功能：可显示当前系统中所有车辆的信息，每条记录占据一行。
（4）编辑功能：可根据查询结果对相应的记录进行修改，修改时注意车牌号的唯一性。
（5）删除功能：主要实现对已添加的车辆记录进行删除。如果当前系统中没有相应的人员记录，则提示“记录为空！”并返回操作。
（6）统计功能：能统计停车场中车辆的总数、按车型进行统计等。

import datetime
import random

class CarInfor(object):
    def __init__(self,name_car,color,models):
        self.__name_car = name_car
        self.color = color
        self.models = models
        self.start_time = 0
        self.end_time = 0

    def __str__(self):
        return '车牌号:%s 颜色:%s 车型:%s 进入时间:%s 离开时间:%s'%(self.__name_car,self.color,self.models,self.start_time,self.end_time)

    def getCarInfor(self):
        return self.__name_car


class Management(object):
    def __init__(self,park_capacity):
        self.park_capacity = park_capacity
        self.__cur_car = 0
        self.__car_dict = dict()

        self.main_menu = '''
            停车管理系统
    1. 停车
    2. 查询
    3. 显示
    4. 编辑
    5. 离开
    6. 统计
    7. 退出
        '''
        self.__inquire_menu = '''
    1.按车牌号查询
    2.按颜色查询
    3.按车的类型查询
    4.返回
        '''
        self.editor_car_menu = '''
    1.按照车牌号修改信息
    2.按车型修改信息
    3.按颜色修改信息
    4.返回
        '''
        self.editor_car_infor_menu='''
        1.修改颜色
        2.修改车型
        3.返回
        '''
        self.statistical_car_menu = '''
    1.按颜色
    2.按车型
    3.返回
    '''
    def park(self):
        if self.__cur_car < self.park_capacity:
            name_car = input('车牌号:')
            if name_car not in self.__car_dict.keys():
                Object_CarInfor = CarInfor(name_car,color=input('车辆颜色:'),models=input('车型:'))
                Object_CarInfor.start_time = datetime.datetime.now()
                self.__car_dict[name_car] = Object_CarInfor
                self.__cur_car +=1
                print('%s 停车成功' % (name_car))
            else:
                print('%s 已经在停车场了，输入正确的车牌号'%(name_car))
        else:
            print('停车场已经没有车位,不能停车')
    def exit_park(self):
        name_car = input('车牌号:')
        if name_car in self.__car_dict.keys():
            self.__car_dict[name_car].end_time = datetime.datetime.now()
            self.__cur_car -= 1
            print('%s 出停车场,本次消费金额%d,' % (name_car, self.park_menoy(name_car)))
            self.__car_dict.pop(name_car)
        else:
            print('请输入正确的车牌号,或%s 进入停车场没有登记,请联系管理员'% (name_car))
    def view_park_all(self):
        for car in self.__car_dict.keys():
            print(self.__car_dict[car])
    def inquire_car_infor(self):
        while True:
            print(self.__inquire_menu)
            choice = input("Choice:")
            if choice == '1':
                print(self.inquire_name_car())
            elif choice == '2':
                color = input('颜色')
                for car in self.inquire_color(color):
                    print(car)
            elif choice == '3':
                models = input('车型')
                for car in self.inquire_models(models):
                    print(car)
            elif choice == '4':
                break
            else:
                print('输入正确的选择：')

    def editor_car_infor(self):
        while True:
            print(self.editor_car_menu)
            choice = input("Choice:")
            if choice == '1':   #按照车牌号修改信息
                name_car = input('车牌号:')
                while True:
                    print(self.editor_car_infor_menu)
                    choice_name = input('Choice')
                    if choice_name == '1':
                        new_color = input('新的颜色')
                        self.editor_color_name(new_color,name_car)
                    elif choice_name == '2':
                        new_models = input('新的车型:')
                        self.editor_models_name(new_models,name_car)
                    elif choice_name == '3':
                        break
                    else:
                        print('输入正确的选择：')
            elif choice == '2':        #按车型修改信息
                old_models = input('需要修改的汽车的车型:')
                while True:
                    print(self.editor_car_infor_menu)
                    choice_models = input('Choice:')
                    if choice_models == '1':

                        new_color = input('新的颜色:')
                        self.editor_models_color(old_models, new_color)
                    elif choice_models == '2':
                        new_models = input('新的车型:')
                        self.editor_models_models(old_models,new_models)
                    elif choice_models == '3':
                        break
                    else:
                        print('输入正确的选择：')
            elif choice == '3':
                old_color = input('需要修改的汽车的颜色')
                while True:
                    print(self.editor_car_infor_menu)
                    choice_color = input('Choice:')
                    if choice_color == '1':
                        new_color = input('新的颜色')
                        self.editor_color_color(old_color,new_color)
                    elif choice_color == '2':
                        new_models = input('新的车型')
                        self.editor_color_models(old_color,new_models)
                    elif choice_color == '3':
                        break
                    else:
                        print('输入正确的选择：')
            if choice == '4':
                break
            else:
                print('输入正确的选择：')

    def statistical_car_class(self):
        while True:
            print(self.statistical_car_menu)
            choice = input('choice:')
            if choice == '1':
                res = self.inquire_color()
                for color in res.keys():
                    print('颜色为%s的车有%s辆'%(color,len(res[color])))
            elif choice == '2':
                res = self.inquire_models()
                for models in res.keys():
                    print('车型为%s的车有%s辆'%(models,len(res[models])))
            elif choice == '3':
                break
            else:
                print('输入正确的选择：')

    def park_menoy(self,name_car):
        money =0
        time = (self.__car_dict[name_car].end_time - self.__car_dict[name_car].start_time).seconds
        money = (int(time) // 3) * 10
        return money

    def Create_num(self):
        """
        :return:  随机生成的编号
        """
        str_num = str()
        for i in range(self.park_capacity):
            str_num += random.randint(0,10)
        return str_num

    def editor_color_name(self,new_color,*name_car):
        '''
        按车牌号 修改颜色
        :param new_color:
        :param name_car:
        :return:
        '''
        if len(name_car)>=1:
            for name in name_car:
                if name in self.__car_dict.keys():
                    self.__car_dict[name].color =new_color
                    print('%s 车辆更改颜色成功' % (name))


    def editor_color_color(self,old_color,new_color):
        name = list()
        # 将停车场同一个颜色的车牌号放入一个列表
        res = self.inquire_color(old_color)
        if res != None:
            for car in res:
                name.append(car.getCarInfor())
            # 按车牌号 修改颜色
            self.editor_color_name(new_color,*name)

    def editor_models_name(self,new_models,*name_car):
        '''
        根据车牌 修改指定车型
        :param new_models:
        :param name_car:
        :return:
        '''
        if len(name_car)>=1:
            for name in name_car:
                if name in self.__car_dict.keys():
                    self.__car_dict[name].models = new_models
                    print ('%s 车辆更改车型成功' % (name))
                else:
                    return '%s 没有进入停车场' % (name_car)

    def editor_models_models(self,old_models,new_models):
        '''
        将所有的车型修改为另一种车型
        :param old_models:
        :param new_models:
        :return:
        '''
        name = list()
        # 将停车场同一个车型的车牌号放入一个列表
        res = self.inquire_models(old_models)
        if res !=  None:
            for car in res:
                name.append(car.getCarInfor())

            # 按车牌号 修改车型
            self.editor_models_name(new_models,*name)

    def editor_models_color(self,old_models,new_color):
        name = list()
        # 将停车场同一个车型的车牌号放入一个列表
        res = self.inquire_models(old_models)
        if res != None:
            for car in res:

                name.append(car.getCarInfor())

            self.editor_color_name(new_color,*name)


    def editor_color_models(self,old_color,new_models):
        name = list()
        # 将停车场同一个颜色的车牌号放入一个列表
        res = self.inquire_color(old_color)
        if res != None:
            for car in res:
                name.append(car.getCarInfor())
            # 按车牌号 修改颜色
            self.editor_models_name(new_models,*name)




    def inquire_name_car(self):
        '''
        根据车牌号查找在停车场的车辆
        :return:
        '''
        name_car = input('车牌号:')
        if name_car in self.__car_dict.keys():
            return self.__car_dict[name_car]
        else:
            return '%s 没有进入停车场'%(name_car)

    def inquire_color(self,color=2):
        """
        根据颜色查找在停车场的车辆,并将结果存入 color_dict{'color1':[],'color1':[]}
        :return: color_dict[color]
        """
        color_dict = dict()
        # 按颜色对车辆分类
        for car in self.__car_dict.keys():
            if self.__car_dict[car].color not in color_dict.keys():
                color_dict[self.__car_dict[car].color] = [self.__car_dict[car]]
            else:
                color_dict[self.__car_dict[car].color].append(self.__car_dict[car])
        if color != 2:
            if color in color_dict.keys():
                return color_dict[color]
            else:
                print('停车场没有%s颜色的车'%(color))
        else:
            return color_dict


    def inquire_models(self,models=2):
        """
        根据车型查找在停车场的车辆,并将结果存入 models_dict{'models1':[],'models2':[]}
        :return: models_dict[models]
        """
        models_dict = dict()
        # 按颜色对车辆分类

        for car in self.__car_dict.keys():
            if self.__car_dict[car].models not in models_dict.keys():
                models_dict[self.__car_dict[car].models] = [self.__car_dict[car]]
            else:
                models_dict[self.__car_dict[car].models].append(self.__car_dict[car])
        if models != 2:
            if models in models_dict.keys():
                return models_dict[models]
            else:
                print('停车场没有%s车型的车'%(models))
        else:
            return models_dict
    def Infor(self):
        while True:
            print(self.main_menu)
            choice = input("Choice:")
            if choice == "1":
                self.park()
            elif choice == '2':
                self.inquire_car_infor()
            elif choice == '3':
                self.view_park_all()
            elif choice == '4':
                self.editor_car_infor()
            elif choice == '5':
                self.exit_park()
            elif choice == '6':
                self.statistical_car_class()
            elif choice == '7':
                exit(0)
            else:
                print('输入正确的选择：')

park = Management(3)
park.Infor()