精华内容
下载资源
问答
  • python面向对象编程实例

    千次阅读 2019-10-23 22:34:52
    案例介绍 本案例设计的是 :为购置的新房添置家具 ,在本案例中,我们需要给出指定的房屋和面积,在为其添置家具的...最后用户通过创建房屋和家具的对象来实现实例,并给出需要添加的家具,输出结果之后结束程序。

    案例介绍

    本案例设计的是:为购置的新房添置家具,在本案例中,我们需要给出指定的房屋和面积,在为其添置家具的过程中,各家具的面积之和不能超过房屋面积的总和。房屋及家具的面积需要由用户手动输入,也可以自定义增加房屋选项或家具选项。

    代码呈现

    #房子要使用到家具,被使用的类通常先开发
    class HouseItem:
        def __init__(self,name,area):
            self.name=name
            self.area=area
        def __str__(self):
            return "[%s] 占地 %.2f" % (self.name,self.area)
     
    class House:
        #只有需要外部传递的参数,才要在初始化函数中定义形参
        def __init__(self,house_type,area):
            self.house_type=house_type
            self.area=area
            #剩余面积
            self.free_area=area
            #家具名称列表
            self.item_list=[]
     
        def __str__(self):
            #Python 能够自动的将一对括号内部的代码连接在一起
            return ("户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s"
                    % (self.house_type,self.area,
                       self.free_area,self.item_list))
     
        def add_item(self,item):
            print("要添加%s" % item)
            #1.判断家具的面积
            if item.area > self.free_area:
                print("%s的面积太大了,无法添加" % item.name)
                return #只要return执行,下发代码就不会继续执行
            #2.将家具的名称添加到列表中
            self.item_list.append(item.name)
            #3.计算剩余面积
            self.free_area-=item.area
     
    #1.创建家具
     
    bed=HouseItem('席梦思',50)
    chest = HouseItem('衣柜',60)
    table = HouseItem('餐桌',20)
     
    # print(bed)
    # print(chest)
    # print(table)
     
    #2.创建房子对象
    my_home = House("两室一厅",100)
    my_home.add_item(bed)
    my_home.add_item(chest)
    my_home.add_item(table)
    print(my_home)
    

    输出结果:

    要添加[席梦思] 占地 50.00
    要添加[衣柜] 占地 60.00
    衣柜的面积太大了,无法添加
    要添加[餐桌] 占地 20.00
    户型:两室一厅
    总面积:100.00[剩余:30.00]
    家具:['席梦思', '餐桌']
    

    设计思路

    本案例需要设计两个类,分别为家具类HouseItem、房屋类House
    在这两个类的定义过程中需要用到使用__init____str__方法:
    __init__方法定义房屋和家具的属性,用__str__定义房屋和家具返回的信息。

    家具只需定义名称面积即可。

    在房屋的属性中定义了房屋的类型面积剩余面积已选择的家具,类型及面积由用户输入值作为参数传入到对象属性中来,剩余面积默认等于房屋给定面积,并根据添加的家具面积递减。已选择家具指定位列表形式,默认为空,当面积符合添加要求后由self.item_list.append(item.name)方法将家具名称添加到列表中。

    在房屋中还需要添加的一个重要方法就是添置家具,可以理解为给房屋指定具有添置家具的行为,这里以实例方法的形式构造了add_item函数,在此函数中,只需要传递家具对象的名称进来,而在函数中,首先要调用家具的面积与房屋的剩余面积,二者进行比较,当家具面积小于房屋面积时可以进行添加,并同时在房屋剩余面积上减去已添加的家具面积,然后再将家具的名称添加到房屋对象的已选择的家具属性中。

    最后用户通过创建房屋和家具的对象来实现实例,并给出需要添加的家具,输出结果之后结束程序。

    展开全文
  • python面向对象编程实例:飞机大战

    千次阅读 2018-01-30 21:26:13
    说明:此则博客只是自己学习python编程的学习记录,其中完成的程序设计只是飞机大战的小小小demo,只为自己熟悉python语言和pygame,所以程序并不完善,只当练手和记录,当然可基于次程序进行后续的完善开发。...

    说明:此则博客只是自己学习python编程的学习记录,其中完成的程序设计只是飞机大战的小小小demo,只为自己熟悉python语言和pygame,所以程序并不完善,只当练手和记录,当然可基于次程序进行后续的完善开发。最后感谢一下hm的python教程。至于程序中的图片素材,如果大家有需要可在本文下方留言,可私发。


    开头 祭出程序开发文档:

    #01. 使用pygame创建图形窗口


    #1.1 游戏的初始化和退出
    # 方法:           说明:
    #   pygame.init()   导入并初始化所有pygame模块
    #   pygame.quit()   卸载所有pygame模块,在游戏结束之前调用


    #1.2 理解游戏中的坐标系
    # ·坐标系:
    #      1. 原点在左上角(0,0)
    #      2. x轴水平方法向右,逐渐增加
    #      3. y轴垂直方向向下,逐渐增加


    # ·在游戏中,所有的可见元素都是以矩形区域来描述位置的
    #      1.要描述一个矩形区域有四个元素:(x, y) (width, heigth)


    # ·pygame专门提供了一个类pygame.Rect用于描述矩形区域
    #      Rect(x, y, width, heigth) -> Rect


    #1.3 创建游戏的主窗口
    # ·pygame专门提供了一个模块pygame.display用于创建,管理游戏窗口
    #     方法:                         说明:
    #       pygame.display.set_mode()     初始化游戏显示窗口
    #       pygame.display.update()       刷新屏幕内容显示,稍后使用
    #     使用:
    #       set_mode(resolution=(0,0), flags=0, depth=0) -> Surface
    # ·参数
    #     1.resolution指定屏幕的宽和高,默认创建的窗口大小和屏幕大小一致
    #     2.flags参数指定屏幕的附加选项,例如是否全屏等等,默认不需要传递
    #     3.depth参数表示颜色的位数,默认自动匹配
    # ·注意
    #     必须使用变量记录set_mode方法的返回结果!因为:后续所有的图像绘制都基于这个返回结果




    #02. 理解图像并实现图像绘制
    # ·在屏幕上看到某一个图像的内容,需要三个步骤:
    #     1.使用pygame.image.load()加载图像的数据
    #     2.使用游戏屏幕对象,调用blit方法将图像绘制到指定的位置
    #     3.调用pygame.display.update()方法更新整个屏幕的显示




    #03. 理解游戏循环和游戏时钟
    #3.1 游戏中的动画实现原理
    #    一秒60帧的高质量视频


    #3.2 游戏循环
    #    1.设置刷新帧率
    #    2.检测用户交互
    #    3.更新所有的图像位置
    #    4.更新屏幕显示


    #3.3 游戏时钟
    # ·pygame专门提供了一个类pygame.time.Clock可以非常方便的设置屏幕绘制速度--刷新帧率
    # ·使用时钟步骤:
    #            1.在游戏初始化创建一个时钟对象
    #            2.在游戏循环中让时钟对象调用tick(帧率)方法
    # ·tick方法会根据上次被调用的时间,自动设置游戏循环中的延时


    #3.4 英雄的简单动画实现
    # ·提示:
    #      1.每一次调用update()方法之前,需要把所有的游戏图像都重新绘制一遍
    #      2.而且应该最先重新绘制背景图像


    #3.5 在游戏循环中监听事件
    # ·事件 event
    #       ·就是游戏启动后,用户针对游戏所做的操作
    #       ·例如:点击关闭按钮,点击鼠标,按下键盘
    # ·监听
    #       ·在游戏循环中,判断用户具体的操作(只有捕获到用户具体的操作,才能有针对性的做出相应)
    # ·实现
    #       ·pygame中通过pygame.event.get()可以获得用户当前所做动作的事件列表




    #04. 理解精灵和精灵组
    #4.1 精灵和精灵组
    # ·为了简化开发步骤,pygame提供了两个类
    #       1.pygame.sprite.Sprite -- 存储图像数据image和位置rect的对象
    #       2.pygame.sprite.Group
    # ·精灵
    #       image    记录图像数据
    #       rect     记录在屏幕上的位置
    #       update(*args): 更新精灵位置
    #       kill():        从所有组中删除
    # ·精灵组
    #       __init__(self, *精灵):
    #       add(*sprites):    向组中增加精灵
    #       sprites():        返回所有精灵列表
    #       upadte(*args):    让组中所有精灵调用update方法
    #       draw(Surface):    将组中所有精灵的image,绘制到Surface的rect位置


    #4.2 派生精灵子类
    # ·定义如下GameSprite继承自pygame.sprite.Sprite
    # ·GameSprite
    #       image       精灵图像,使用image_name加载
    #       rect        精灵大小,默认使用图像大小
    #       speed       精灵移动速度,默认为1
    #       __init————(self, image_name, speed=1):
    #       update(self):       每次更新屏幕时在游戏循环内调用,让精灵的self.rect.y += self.speed
    # ·注意
    #       ·在重写初始化方法时,一定要先super()一下父类的__int__方法
    #       ·进而保证父类中实现的__init__代码能够被正常执行
    # ·提示
    #       ·image的get_rect()方法,可以返回pygame.Rect(0, 0, 图像宽, 图像高)的对象


    #4.3 使用游戏精灵和精灵组创建敌机
    # ·精灵
    #       ·封装image,rect,speed
    #       ·提供update()方法,根据游戏需求,更新位置rect
    # ·精灵组
    #       ·包含多个精灵组
    #       ·update方法,让精灵组中的所有精灵调用update方法更新位置
    #       ·draw(screen)方法,在screen上绘制精灵组中的所有精灵




    # 游戏框架搭建
    #01. 明确主程序职责
    # ·游戏主程序主要负责:
    #       1.游戏的初始化
    #       2.游戏循环


    # ·设计PlaneGame类
    #       screen
    #       clock
    #       精灵或精灵组
    # --------------------------
    #       __init__(self):
    #       __create_sprites(self):
    #       start_game(self):
    #       __event_handle(self):
    #       __check_collide(self):
    #       __update_sprites(self):
    #       __game_over():


    #02. 实现飞机大战主游戏类
    # ·plane_main
    #       1.封装主游戏类
    #       2.创建游戏对象
    #       3.启动游戏
    # ·plane_sprites
    #       1.封装游戏中所有需要使用的精灵类
    #       2.提供游戏的相关工具
    # ·常量
    #       常量的命名应该所有字母都使用大写,单词和单词之间使用下划线连接


    # 背景图像
    #01. 背景交替滚动的思路确定
    #02. 设计背景类
    # ·由GameSprite继承而来
    #       Background
    #           __init__(self, is_alt):
    #           update(self):
    # ·初始化方法
    #       1.直接指定背景图片
    #       2.is_alt判断是否是另一张图
    # ·update()方法
    #       ·判断是否移动出屏幕,如果是,将图像设置到屏幕的正上方,从而实现交替滚动




    # 敌机出场
    #01. 使用定时器添加敌机
    # ·定时器
    #       pygame.time.set_timer(eventid, milliseconds) -> None
    #       ·set_timer可以创建一个事件
    # ·定时器事件的监听
    #       通过pygame.event.get()可以获得当前时刻所有的时间列表
    #       遍历判断event.type是否等于eventid


    #1.1 定义并监听创建敌机的定时器事件
    # ·步骤
    #       1.定义定时器常量 -- eventid
    #       2.在初始化方法中,调用set_timer方法设置定时器时间
    #       3.在游戏循环中,监听定时器事件


    #02. 设计敌机类
    # ·Enemy(GameSprite)
    #       __init__(self):
    #       update(self):
    # ·初始化方法
    #       ·指定敌机图片
    #       ·随机敌机的初始位置和初始速度
    # ·重写update方法
    #       ·判断是否飞出屏幕,如果是,从精灵组删除


    #2.1 创建敌机
    # ·在__create_sprites中创建敌机精灵组
    # ·在__event_handler中创建敌机,并且添加到精灵组
    # ·在__update_sprites中调用update和draw


    #2.2 随机敌机位置和速度
    # ·import random


    #2.3 移出屏幕销毁敌机
    # ·从敌机组删除




    # 英雄登场
    #01. 设计英雄和子弹类
    # ·Hero -- 英雄
    #   ·初始化方法
    #       ·指定英雄图片
    #       ·初始速度 = 0 -- 英雄默认静止不动
    #       ·定义bullets子弹精灵组保存子弹精灵
    #   ·重写update()方法
    #       ·英雄需要水平移动
    #       ·并且需要保证不能移出屏幕
    #   ·增加bullets属性,记录所有子弹精灵
    #   ·增加fire方法,用于发射子弹
    #---------------------------------
    #   Hero(GameSprite)
    #       bulltes
    #       __init__(self):
    #       update(self):
    #       fire(self):
    #---------------------------------
    #   Bullet(GameSprite)
    #       __init__(self):
    #       update(self):
    #---------------------------------


    #02. 绘制英雄
    #03. 移动英雄位置(键盘按键的捕获)
    # ·方式一(单次按键)
    #       if event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
    # ·方式二(支持连按)
    #       keys_pressed = pygame.key.get_pressed()
    #       if keys_pressed[pygame.K_RIGHT]:
    #           print("向右移动...")


    #04. 发射子弹
    #4.1 添加发射子弹事件
    # ·使用定时器完成子弹事件


    #4.2 定义子弹类
    # ·Bullet -- 子弹
    #   ·初始化方法
    #       ·指定子弹图片
    #       ·初始速度 = -2 -- 子弹需要向上飞行
    #   ·重写update方法
    #       ·判断是否飞出屏幕,如果是,从精灵组删除


    #4.3 发射子弹
    # ·步骤
    #       1.在hero的初始化方法中创建子弹精灵组属性
    #       2.修改plane_main.pyde __update_sprites方法,让子弹精灵组调用update和draw方法
    #       3.实现fire方法
    #           ·创建子弹精灵
    #           ·设置初始位置 -- 在英雄的正上方
    #           ·将子弹添加到精灵组




    #碰撞检测
    #01. 碰撞检测方法
    #-----------------------------------------------------------------------
    # ·pygame.sprite.groupcollide()
    #       ·两个精灵组中的所有精灵的碰撞检测
    #       groupcollide(group1, group2, dokill1, dokill2, collided = None) -> Sprite_dict
    #       ·如果将dokill设置为True,则发生碰撞的精灵将被自动移除
    #       ·collided参数是用于计算碰撞的回调函数
    #           ·如果没有指定,则每一个精灵必须有一个rect属性
    #-----------------------------------------------------------------------
    # ·pygame.sprite.spritecollide()
    #       ·判断某个精灵和指定精灵组中的精灵的碰撞
    #       spritecollide(sprite, group, dokill, collided = None) -> Sprite_list
    #-----------------------------------------------------------------------


    然后祭出两个py文件:

    文件1. plane_sprites.py

    作用: 完成精灵类的编写


    #plane_sprites.py
    import random
    import pygame
    
    # 屏幕大小的常量
    SCREEN_RECT = pygame.Rect(0, 0, 480, 852)
    # 刷新的帧率
    FRAME_PER_SEC = 60
    # 创建敌机的定时器常量
    CREATE_ENEMY_EVENT = pygame.USEREVENT
    # 英雄发射子弹事件
    HERO_FIRE_EVENT = pygame.USEREVENT + 1
    
    
    class GameSprite(pygame.sprite.Sprite):
        """飞机大战游戏精灵"""
    
        def __init__(self, image_name, speed=1):
    
            # 调用父类的初始化方法
            super(GameSprite, self).__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. 调用父类方法实现精灵的创建(image,rect,speed)
            super().__init__(r".\Image\background.png")
    
            # 2. 判断是否是交替图像,如果是,需要设置初始位置
            if is_alt:
                self.rect.y = -SCREEN_RECT.height
    
        def update(self):
    
            #1. 调用父类的方法实现
            super().update()
    
            #2. 判断是否移动出屏幕,如果移动出,将图像设置到屏幕的上方
            if self.rect.y >= SCREEN_RECT.height:
                self.rect.y = -self.rect.height
    
    
    class Enemy(GameSprite):
        """敌机精灵"""
    
        def __init__(self):
    
            #1. 调用父类方法,创建敌机精灵,同时指定敌机图片
            super().__init__(r".\Image\small_enemy.png")
    
            #2. 指定敌机的初始随机速度 1 ~ 3
            self.speed = random.randint(1, 3)
    
            #3. 指定敌机的初始随机位置
            self.rect.x = random.randint(0, SCREEN_RECT.width - self.rect.width)
            #self.rect.y = -self.rect.height
            self.rect.bottom = 0
    
        def update(self):
    
            #1. 调用父类方法,保持垂直方向的飞行
            super().update()
    
            #2. 判断是否飞出屏幕,如果是,需要从精灵组删除敌机
            if self.rect.y >= SCREEN_RECT.height:
                #print("飞出屏幕,需要从精灵组删除")
                self.kill()
    
        def __del__(self):
            #print("敌机挂了 %s" % self.rect)
            pass
    
    
    class Hero(GameSprite):
        """英雄精灵"""
    
        def __init__(self):
    
            #1. 调用父类方法,设置image和speed
            super().__init__(r".\Image\hero1.png", 0)
    
            #2. 设置英雄的初始位置
            self.rect.centerx = SCREEN_RECT.centerx
            self.rect.bottom = SCREEN_RECT.bottom - 120
    
            #3. 创建子弹的精灵组
            self.bullets = pygame.sprite.Group()
    
        def update(self):
    
            # 用速度和英雄的x进行叠加
            self.rect.x += self.speed
    
            # 控制英雄不能离开屏幕
            if self.rect.x < 0:
                self.rect.x = 0
    
            if self.rect.right > SCREEN_RECT.right:
                self.rect.right = SCREEN_RECT.right
    
        def fire(self):
    
            # 英雄发射子弹
            print("突突突...")
    
            # 一次发射三颗子弹
            for i in (0, 1, 2):
    
                #1. 创建子弹精灵
                bullet = Bullet()
    
                #2. 设置精灵的位置
                bullet.rect.bottom = self.rect.y - 20 * i
                bullet.rect.centerx = self.rect.centerx
    
                #3. 将精灵添加到精灵组
                self.bullets.add(bullet)
    
    
    class Bullet(GameSprite):
        """子弹精灵"""
    
        def __init__(self):
    
            # 调用父类方法,设置子弹图片,设置初始速度
            super().__init__(r".\Image\normal_bullet.png", -2)
    
        def update(self):
    
            # 调用父类方法,让子弹沿垂直方向飞行
            super().update()
    
            # 判断子弹是否飞出屏幕
            if self.rect.bottom < 0:
                self.kill()
    
        def __del__(self):
            print("子弹被销毁...")


    文件2. plane_main.py

    作用: 主程序(构建起程序框架)

    #plane_main.py
    import pygame
    from plane_sprites import *
    
    
    class PlaneGame(object):
        """飞机大战主游戏"""
    
        def __init__(self):
            print("游戏初始化")
    
            #1. 创建游戏窗口
            self.screen = pygame.display.set_mode(SCREEN_RECT.size)
            #2. 创建游戏的时钟
            self.clock = pygame.time.Clock()
            #3. 调用私有方法,精灵和精灵组的创建
            self.__create_sprites()
    
            #4. 设置定时器事件 -- 创建敌机 1s
            pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
    
            #5. 设置发射子弹事件
            pygame.time.set_timer(HERO_FIRE_EVENT, 500)
    
        def __create_sprites(self):
    
            # 创建背景精灵和精灵组
            bg1 = Background(False)
            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("敌机出场...")
                    # 创建敌机精灵
                    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.speed = 2
            elif keys_pressed[pygame.K_LEFT]:
                print("向左移动...")
                self.hero.speed = -2
            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)
    
            # 判断列表enemies是否有内容
            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()


    小小小demo编程实现效果:




    展开全文
  • 要求:创建一套预订航班的预订系统。不同航班坐位收费不一样。 譬如头等舱要比经济舱贵。记录下何时有空房可供预订。 类的需求:用户类、用户管理类、航班类、航班管理类、订票系统 #乘客类:姓名,年龄,预定航班...

    要求:创建一套预订航班的预订系统。不同航班坐位收费不一样。 譬如头等舱要比经济舱贵。记录下何时有空房可供预订。

    类的需求:用户类、用户管理类、航班类、航班管理类、订票系统

    #乘客类:姓名,年龄,预定航班,余额(balance)
    class Passenger:
        def __init__(self,name="",age=20,flight=[],balance):
            self.name=name
            self.age=age
            self.flight=flight
            self.balance=balance
        def setname(self,name):
        def setbalance(self,balance):
        def getflight(self):
        def getbalance(self):

     

    #用户管理类
    class PassengerManager:
        def __init__(self):
            self.passenger=[]
        def addpassenger(self,passenger):
        def delpassenger(self,passenger):
        def findpassger(self,name):
        def getpassenger(self):
            

     

    #航班信息类:航班号,起飞地点,降落地点,日期,起飞和降落时间,不同等级位置的余票数和票价
    class FlightInfomation:
        def __init__(self,index,startcity,endcity,date,starttime,endtime,firstticket,fisrtprice,seconodticket,secondprice):
            self.index=index
            self.startcity=startcity
            self.endcity=endcity
            self.date=date
            self.starttime=starttime
            self.endtime=endtime
            self.firstticket=firstticket
            self.fisrtprice=firstprice
            self.seconodticketsecondticket
            self.secondprice=secondprice
        def setdate(self,date):
        def setstarttime(self,starttime):
        def setendtime(self,endtime):
        def setfirstprice(self,firstprice):
        def setsecondprice(self,secondprice):
        def getindex(self):
        def getstartcity(self):
        def getendcity(self):
        def getdate(self):
        def getstarttime(self):
        def getendtime(self):
        def getfirstticket(self):
        def getfisrtprice(self):
        def getseconodticket(self):
        def getsecondprice(self):

     

    #管理航班类
    class FlightManager:
        def __init__(self):
            self.flight=[]
        def addflightinfo(self,flightinformation):
        def delflightinfo(self,flightinformation):
        def changeflightinfo(self,index,date,flightinformation):
        def findflight_ind(self,index,date):
        def findfligth_city(self,startcity,endcity):

     

    class system:
        def __init__(self,flightmanager,passengermanager):
            self.flight=flightmanager.flight
            self.passenger=passengermanager.passenger
        def BuyTicket(self,passenger,flightinformation):
        def ReturnTicket(self,passenger,flightformation):

     

    展开全文
  • 要求:产品库存管理——创建一个管理产品库存的应用。 建立一个产品类:价格、id、库存数量。 建立一个库存类:记录各种产品并能计算库存.../usr/bin/env python3 # -*- coding: utf-8 -*- class product: def __init...

    要求:产品库存管理——创建一个管理产品库存的应用。
    建立一个产品类:价格、id、库存数量。
    建立一个库存类:记录各种产品并能计算库存的总价值。

    理论分析:

    1.产品类:

    2.库存类:

    代码如下:

    产品类:product.py

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    class product:
        def __init__(self,name,price,number,index):
            self.name=name
            self.price=price
            self.number=number
            self.index=index
    
        def __str__(self):
            return 'name:%s,price:%s,numde:%s,index:%s'%(self.name,self.price,self.number,self.index)

    库存类:stock.py

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    class stock(object):
        def __init__(self):
            self.goods=[]
        def add(self,product):
            """
            添加新产品:
            如果有新产品,直接添加到原有库存中。
            不是新产品则添加数量。
            """
            #goods中有库存
            if len(self.goods)>0:
                flag=0
                for i in range(len(self.goods)):
                    if(self.goods[i].index==product.index):
                        self.goods[i].number+=product.number
                        flag=1
                        break
                    if(flag!=0):
                        self.goods.append(product)
            #goods中无库存
            else:
                self.goods.append(product)
                
        def dele(self,product):
            """
            取出产品产品:
                库存中有产品:
                    产品数量小于所需数量:
                        输出提示--库存不够,只有多少数量
                    产品数大于或等于所需数量:
                        减少库存,并输出提示--剩余库存数量
                库存中没有产品:
                    输出提示--没有产品
            """
            flag=0
            for i in range(len(self.goods)):
                if(self.goods[i].index==product.index and self.goods[i].name==product.name):
                    flag=1
                    if(self.goods[i].number>=product.number):
                        self.goods[i].number-=product.number
                        print('产品ID:%s | 产品名称:%s | 产品剩余数量:%s | 产品价格:%s'%(self.goods[i].index,self.goods[i].name,self.goods[i].number,self.goods[i].price))
                    else:
                        print('产品ID:%s | 产品名称:%s | 产品数量:%s | 产品价格:%s'%(self.goods[i].index,self.goods[i].name,self.goods[i].number,self.goods[i].price))
                        print("库存数量不足!!")
                    break
            if(flag==0):
                print("库存中没有该产品!!")
                        
        def List(self,l):
            """
            查找产品:
                库存中有产品:
                    输出产品详情
                库存中没有产品:
                    输出提示--没有产品
            """
            flag=0
            if ( isinstance(l,int) ):
                for i in range(len(self.goods)):
                    if(self.goods[i].index==l):
                        flag=1
                        print('产品ID:%s | 产品名称:%s | 产品数量:%s | 产品价格:%s'%(self.goods[i].index,self.goods[i].name,self.goods[i].number,self.goods[i].price))
                if(flag==0):
                    print("库存中没有该产品!!")
    
            else:
    	    for i in range(len(self.goods)):
    	        if(self.goods[i].name==l):
    	            flag=1
    	            print('产品ID:%s | 产品名称:%s | 产品数量:%s | 产品价格:%s'%(self.goods[i].index,self.goods[i].name,self.goods[i].number,self.goods[i].price))
    	    if(flag==0):
                    print("库存中没有该产品!!")
    
        def List_all(self):
            n=0
            c=0
            for i in range(len(self.goods)):
                n+=self.goods[i].number
                c+=self.goods[i].number*self.goods[i].price
                print('产品ID:%s | 产品名称:%s | 产品数量:%s | 产品价格:%s'%(self.goods[i].index,self.goods[i].name,self.goods[i].number,self.goods[i].price))
            print('-'*50)
            print('总计:     |             | 产品总数:%s |产品总价:%s'%(n,c))

    测试代码:

    展开全文
  • 主要介绍了Python面向对象编程基础,结合实例形式分析了Python面向对象编程类的定义、继承、特殊方法及模块相关原理与操作技巧,需要的朋友可以参考下
  • 自己整理的Python面向对象编程速记速学小例子和源码,只有6页,可以迅速学会Python面向对象编程。原书已加入书签方便阅读。介绍了类的声明,实例化,绑定属性,构造函数,数据封装,继承,多态,实例属性和类属性。...
  • 1. 面向对象编程概述 面向对象编程是一种编程方式,这种编程方式需要使用对象来实现 1.1 对象的特征 世间万物皆是对象 每个对象都是唯一的 对象具有属性和行为 对象的行为包括具有的功能及具体的实现 ...
  • 面向对象编程,重点在于对象(可以理解成who),即以对象为核心,这个对象有什么技能(不止一个技能的),这个对象所拥有的哪些技能够帮你实现你的目标。前者比较关注怎么做,后者比较关注谁来做。来看张图片:图注:知乎...
  • Python设计之初就是一门面向对象的语言,正因为如此,在Python中创建一个类的对象是很容易的,学过C++和Java的同学对面向对象应该比较了解,在面向对象编程中万物皆对象。更多具体的详细的信息大家可以查阅专业的...
  • Python面向对象编程

    2020-12-22 07:18:25
    Python中变量的赋值和传递,操作的总是对象的引用。一个对象可以绑定多个名字,多个变量可以指向同一个对象Python对象更加强调鸭子类型,特定情况下看起来像鸭子,就是鸭子。 命名空间和作用域 命名空间是名字...
  • 主要介绍了Python面向对象编程之继承与多态,结合实例形式详细分析了Python面向对象编程中继承与多态的概念、使用方法及相关注意事项,需要的朋友可以参考下
  • python面向对象编程

    2017-12-05 15:58:00
    在进行python面向对象编程之前,我们先来了解几个术语:类,类对象,实例对象,属性,函数和方法。 类是对现实世界中一切事物的封装,定义一个类可以采用下面的方式来定义: class className: block 当一...
  • Python是一门完全面向对象的编程语言,在Python中一切皆对象。...该课程会从面向过程开始讲起,再逐步地深入讲解Python面向对象的基础概念,高阶概念,涵盖从基础到高级的所有知识点,课程同时包含翔实的代码实例
  • python基础系列教程——python面向对象编程全解

    万次阅读 多人点赞 2017-12-04 19:32:54
    python面向对象编程全解。面向对象技术简介类(Class):用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例(对象是类实例化之后的结果)。类变量:类变量在...
  • 古人云:万丈高楼平地起,要想有长足的发展,打好基础很重要,本文主要讲解Python面向对象相关知识,仅供学习分享使用,如有不足之处,还请指正。 面向对象的特征 类:用来描述相同事物的特征的集合,如:Person ...
  • 接下来我们就来了解关于Python面向对象编程的知识点吧。 类与实例 类是对象的定义,而实例是”真正的实物”,它存放了类中所定义的对象的具体信息。 类、属性和方法命名规范 类名通常由大写字母打头。这是标准惯例,...
  • 这篇教程中,我们不谈类和面向对象的基本知识,而专注在更好地理解Python面向对象编程上。假设我们使用新风格的python类,它们继承自object父类。 定义类 class 语句可以定义一系列的属性、变量、方法,他们被该类的...
  • python面向对象编程——面向对象编程概述、实例对象属性、类对象属性、实例方法: https://blog.csdn.net/weixin_43799652/article/details/89879929 python面向对象编程——函数装饰器、类方法、静态方法、访问...
  • Python面向对象编程指南

    万次阅读 多人点赞 2014-04-16 14:30:54
    虽然Python是解释性语言,但是它是面向... 在进行python面向对象编程之前,先来了解几个术语:类,类对象,实例对象,属性,函数和方法。  类是对现实世界中一些事物的封装,定义一个类可以采用下面的方式来定义:
  • 主要介绍了Python3.5面向对象编程,结合图文与实例形式详细分析了Python面向对象编程相关的概念、类定义、实例化、实例变量、类变量、析构函数等相关原理及使用技巧,需要的朋友可以参考下
  • 【Python】python面向对象编程

    千次阅读 2015-06-04 11:21:34
    python中,面向对象编程主要有两个主题,就是类和类实例。 1、类 新式类—— class ClassName(bases): 'ClassName class doc string' class_suite 经典类—— class ClassName: 'ClassName class doc string' ...
  • Python 面向对象编程(一) ... 在进行python面向对象编程之前,先来了解几个术语:类,类对象,实例对象,属性,函数和方法。  类是对现实世界中一些事物的封装,定义一个类可以采用下面的方式来定义:
  • 史上最全 Python 面向对象编程.pdf
  • Python不只是解释性语言,也是一门...Python面向对象编程系列之学习目标 (1) 了解面向对象编程的发展、实例、优点。 (2) 了解使用面向对象编程的情形。 (3) 掌握类的定义、使用和专有方法。 (4) 掌握self参数...
  • 前面我们已经做了大量的基础的学习 和 准备工作,从今天开始正式进入Python面向对象编程。对于Python而言,它是支持前面的面向过程、OOP和函数式编程等大量编程范式。 至于OOP这个东西也比较简单,我们在C++的时候...
  • python 面向对象编程:类和实例

    千次阅读 2018-10-18 20:40:19
    深度学习在构建网络模型时,看到用类来构建一个模型实例,清晰明了,所以这篇博文主要学习一下python类 类和实例: 类可以起到模板的作用,因此,可以在创建实例的时候,把一些我们认为必须绑定的属性强制填写进去...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,545
精华内容 19,818
关键字:

python面向对象编程实例

python 订阅