Python基础-类和对象

Love The Way You Lie 2023-07-10 08:40 37阅读 0赞

#                                    Python基础-类和对象 #

## 1.类的定义和对象的创建 ##

"""------------------ 定义类 ------------------"""
    class Person:
        pass
    
    class Dog:
        pass
    """------------------ 创建对象 ------------------"""
    p1 = Person()
    p2 = Person()
    dog = Dog()
    print(dog)
    # print(p1)
    # print(p2)

类的组成:

# 设计Person
    class Person:
        def sayHello(self):
            print('hello')
    
        def run(self):
            # 调用sayHello
            # 调用方法 需要通过self参数调用
            self.sayHello()
            print('跑')
    
    # def myMax(a,b):
    #     if a>b:
    #         return a
    #     else:
    #         return b
    #
    # def myThreeMax(a,b,c):
    #     return myMax(myMax(a,b),c)
    """------------------ 实例属性 ------------------"""
    # p1 = Person()
    # 添加实例属性
    # p1.name = '张三'
    # p1.age = 30
    # # 访问属性
    # print(p1.name,p1.age)
    
    # p1添加的属性 p2不能使用
    # p2 = Person()
    # print(p2.name)
    
    """------------------ 行为定义 ------------------"""
    # 函数
    # def sum(a, b):
    #     return a + b
    #
    # l = [1,2,3]
    # l.sort()
    
    """------------------ 调用方法 ------------------"""
    p1 = Person()
    # Person.sayHello()
    # 调用sayHello方法
    # p1.sayHello()
    # 调用run方法
    p1.run()

self:

print('开始')
    a = 10
    class Person:
        def sayHello(self):
            '''
            :param self p1 p2对象
            :return:
            '''
            # print(self.name)
            print('hello')
    
    # 对象
    p1 = Person()
    # 实例属性
    p1.name = '张三'
    # 调用方法
    # p1.sayHello()
    
    p2 = Person()
    p2.sayHello()
    
    print('结束')

\_init\_\_方法:

# 定义类
    class Person:
        # 构造函数
        # 只要创建新的对象 自动执行init方法
        def __init__(self):
            print('执行了init方法')
            print(self)
    
        def sayHello(self):
            print('hello')
    
    class Dog:
        def __init__(self):
            pass
        pass
    
    # 创建对象
    p1 = Person()
    p2 = Person()
    print('p1',p1)
    print('p2',p2)
    # p1.name = '张三'

成员属性:

# 定义类
    class Person:
        # 只要创建新的对象 自动执行init方法
        def __init__(self,name,age):
            # 成员属性
            self.name = name
            self.age = age
    
    # 每一个人都需要具备name以及age属性
    # 创建对象
    p1 = Person('张三',30)
    # 实例属性
    # p1.name = '张三'
    # p1.age = 30
    print(p1.name,p1.age)
    
    p2 = Person('李四',40)
    print(p2.name,p2.age)
    # p2.name = '李四'
    # p2.age = 40

\_\_str\_\_:

class Person:
        def __init__(self,name,age):
            # 成员属性
            self.name = name
            self.age = age
    
        def __str__(self):
            '''
            以字符串输出对象,把对象变成我们能够读懂的形式输出出来
            :return:
            '''
            return 'name:{},age:{}'.format(self.name,self.age)
    
    # 创建对象
    p1 = Person('张三',30)
    p2 = Person('李四',40)
    print(p1)
    print(p2)

手机案例:

"""
    需求:
    	手机电量默认是100
    	打游戏每次消耗电量10
    	听歌每次消耗电量5
    	打电话每次消耗电量4
    	接电话每次消耗电量3
    	充电可以为手机补充电量
    
    
    分析:
    1.定义类手机类  MobilePhone
    2.类具备属性 battery :100
    3.定义方法playGame battery -= 10
    4.listenMusic battery -= 5
    5.call battery -= 4
    6.receive  battery -= 3
    7.charge   battery += 10
    """
    
    
    class MobilePhone:
        def __init__(self,name):
            self.name = name
            self.battery = 5
    
        def __str__(self):
            return 'name:{},battery:{}'.format(self.name,self.battery)
    
        def playGame(self):
            '''
            打游戏
            :return:
            '''
            # 电量是否满足打游戏的条件
            if self.battery>=10:
                print('打游戏')
                # 消耗10个电量
                self.battery -= 10
            else:
                print('不能打游戏')
    
        def listenMusic(self):
            '''
            听歌
            :return:
            '''
            if self.battery >= 5:
                print('听歌')
                # 消耗10个电量
                self.battery -= 5
            else:
                print('不能打听歌')
    
        def call(self):
            '''
            打电话
            :return:
            '''
            if self.battery >= 4:
                print('打电话')
                # 消耗10个电量
                self.battery -= 4
            else:
                print('不能打打电话')
    
        def receiveCall(self):
            '''
            接电话
            :return:
            '''
            if self.battery >= 3:
                print('接电话')
                # 消耗10个电量
                self.battery -= 3
            else:
                print('不能接电话')
    
        def charge(self):
            '''
            充电
            :return:
            '''
            print('充电')
            self.battery += 10
    
    
    # 定义手机对象
    phone = MobilePhone('苹果手机')
    # print(phone)
    
    phone.playGame()
    # phone.listenMusic()
    # phone.charge()
    print(phone)

搬家具:

"""------------------ 家具类 ------------------"""
    class Item:
        def __init__(self,type,area):
            '''
            创建家具类的初始化方法
            :param type: 家具类型
            :param area: 家具面积
            '''
            self.type = type
            self.area = area
    
        def __str__(self):
            return '家具类型:{},家具占用面积:{}'.format(self.type,self.area)
        
    
    """------------------ Home ------------------"""
    class Home:
        def __init__(self,address,area):
            '''
            房子的初始化方法
            :param address: 房子地址
            :param area: 房子面积
            '''
            self.address = address
            self.area = area
            # 剩余面积
            self.free_area = self.area
            # 家具列表
            self.items = []
    
        def __str__(self):
            return '房子地址:{},占地面积:{},剩余面积:{}'.format(self.address,self.area,self.free_area)
    
    
        # 有问题  1  没问题 2
        def add_item(self,item):
            '''
            添加家具到房子中
            :param item: 家具类Item的实例
            :return:
            '''
            if self.free_area >=  item.area:
                # 家具添加到列表中
                self.items.append(item)
                # 修改剩余面积
                self.free_area -= item.area
                # 可以添加
                print('添加成功')
            else:
                # 不能添加
                print('面积不足,不能添加家具')
    
    # 创建家具
    item1 = Item('桌子',10)
    item2 = Item('椅子',5)
    
    # 创建房子
    home = Home('深圳湾一号',300)
    # 打印家具
    # print(item1)
    # print(item2)
    print(home)
    
    """------------------ 添加家具 ------------------"""
    home.add_item(item1)
    # print(home)
    # print(home.items[0])
    home.add_item(item2)
    print(home)
    print(home.items[0],home.items[1])

属性私有化:

"""
    需求:
    写一个圆形类,传递圆的半径,定义方法求圆的周长
    2*pi*r
    
    分析:
    1.定义圆形类 Circle
    2.属性:半径 pi
    3.方法:返回周长 perimeter
    """
    class Circle:
        def __init__(self,radius):
            # 半径
            self.radius = radius
            # 圆周率 需要在类外面避免修改圆周率
            self.__PI = 3.1415926
    
        def getPi(self):
            return self.__PI
    
        def perimeter(self):
            '''
            求圆的周长
            :return: 圆的周长
            '''
            return 2*self.__PI*self.radius
    
    # 创建圆
    c = Circle(10)
    
    print(c.perimeter())
    # 修改半径
    c.radius = 20
    # 不是修改PI 定义新的实例属性__PI
    c.__PI = 30
    # 打印内部的PI
    print(c.getPi())
    # print(c.perimeter())

私有化方法:

class Person:
        def __sayHello(self):
            print('hello')
    
        def run(self):
            self.__sayHello()
    
    p1 = Person()
    # p1.__sayHello()
    p1.run()

私有补充:

class Person:
        def __init__(self,name,age):
            self.name = name
            self.__age = age
    
        def getAge(self):
            '''
            获取age属性
            :return:
            '''
            return self.__age
    
        def setAge(self,age):
            '''
            修改age属性
            :param age:
            :return:
            '''
            if age>0 and age<150:
                self.__age = age
    
    
        def __str__(self):
            return 'name:{},age:{}'.format(self.name,self.__age)
    
    p1 = Person('张三',30)
    # 不能修改age 定义新的实例属性
    # p1.__age = 300
    # 获取age
    # print(p1.__age)
    
    # 获取age
    print(p1.getAge())
    # 修改
    p1.setAge(170)
    print(p1.getAge())
    
    # print(p1)

面向对象-封装:

"""------------------ 洗衣机生产商 定义洗衣机类型 ------------------"""
    class WashMachine:
        def __init__(self, brand, capacity):
            '''
            初始化
            :param brand: 品牌
            :param capacity:  容量
            '''
            self.brand = brand
            self.capacity = capacity
            # 是否关闭
            self.hasClosed = False
            # 模式 0:默认模式 1:轻揉模式  2:狂揉模式
            self.__mode = 0
            # 马达转速
            self.motorSpeed = 0
    
        def openDoor(self):
            self.hasClosed = False
            print('打开洗衣机门')
    
        def closeDoor(self):
            self.hasClosed = True
            print('关闭洗衣机门')
    
        def setMode(self,mode):
            '''
            调节模式
            :param mode:
            :return:
            '''
            if mode !=1 and mode !=2:
                print('设置模式错误')
            else:
                self.__mode = mode
    
        def __setMotorSpeed(self,speed):
            '''
            设置马达的转速
            :param speed:  1000: 轻揉模式  2000:狂揉模式
            :return:
            '''
            self.motorSpeed = speed
    
    
        def wash(self):
            if not self.hasClosed:
                # 洗衣机门是否关闭 ,没有关闭  提示
                print('请关闭洗衣机门,哔哔哔哔...')
            elif self.__mode==0:
                print('请设置模式')
            else:
                # 关闭了  执行下面的操作
                print('放水...')
                print('放满了...')
                if self.__mode==1:
                    print('轻揉模式,洗内衣')
                    # 调节马达转速
                    self.__setMotorSpeed(1000)
                    print('马达转速:{}'.format(self.motorSpeed))
                    print('开始洗...')
                elif self.__mode==2:
                    print('狂揉模式,洗外套')
                    # 调节马达抓霉素
                    self.__setMotorSpeed(2000)
                    print('马达转速:{}'.format(self.motorSpeed))
                    print('开始洗...')
    
                print('洗完了')
    
    
    """------------------  消费者 创建洗衣机的实例 ------------------"""
    washMachine = WashMachine('海尔', 5)
    # 打开洗衣机门
    washMachine.openDoor()
    # 放入衣服
    print('放入衣服')
    # 伸手到洗衣机内部调节马达的模式
    # washMachine.__mode = 5
    # 设置模式
    washMachine.setMode(2)
    # 外部可以直接调节马达转速
    # washMachine.__setMotorSpeed(100000)
    # 关闭洗衣机门
    washMachine.closeDoor()
    # 开始洗衣服
    washMachine.wash()

非继承:

"""
    需求:
    1.定义学生类,具有name和age属性,具有study方法和打招呼sayHello方法
    2.定义老师类,具有name和age属性,具有teach方法和打招呼sayHello方法
    
    """
    """------------------ 定义Person类 ------------------"""
    class Person:
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def sayHello(self):
            print('hello')
    
    """------------------ 定义Student类 ------------------"""
    class Student:
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def study(self):
            print('开始学习')
    
        def sayHello(self):
            print('hello')
    """------------------ 定义Teacher类 ------------------"""
    class Teacher:
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def teach(self):
            print('教学生')
    
        def sayHello(self):
            print('hello')
    
    # 创建学生类
    stu = Student('小明',15)
    # 创建老师类
    tea = Teacher('李老师',40)
    print(stu.name,stu.age)
    stu.study()
    stu.sayHello()

继承实现:

"""
    需求:
    1.定义学生类,具有name和age属性,具有study方法和打招呼sayHello方法
    2.定义老师类,具有name和age属性,具有teach方法和打招呼sayHello方法
    
    """
    """------------------ 定义Person类 ------------------"""
    class Person:
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def sayHello(self):
            print('hello')
    
    """------------------ 定义Student类 ------------------"""
    class Student(Person):
        # def __init__(self,name,age):
        #     self.name = name
        #     self.age = age
    
        def study(self):
            print('开始学习')
    
        # def sayHello(self):
        #     print('hello')
    """------------------ 定义Teacher类 ------------------"""
    class Teacher(Person):
        # def __init__(self,name,age):
        #     self.name = name
        #     self.age = age
    
        def teach(self):
            print('教学生')
    
        # def sayHello(self):
        #     print('hello')
    
    # 创建学生类
    stu = Student('小明',15)
    # 创建老师类
    tea = Teacher('李老师',40)
    print(stu.name,stu.age)
    stu.study()
    stu.sayHello()
    
    print(tea.name,tea.age)
    tea.sayHello()
    tea.teach()

继承误区:

"""------------------ 子类只能使用父类公有的属性和方法 ------------------"""
    # # 父类
    # class Father:
    #     def __init__(self,name):
    #         # 私有的属性只能在当前类使用 子类也不能使用
    #         self.__name = name
    #     # 私有的方法只能在当前类使用 子类也不能使用
    #     def __func(self):
    #         print('执行了func')
    # # 子类
    # # 子类可以使用父类公有的方法和属性
    # class Son(Father):
    #     pass
    #
    # son = Son('张三')
    # # print(son.__name)
    # son.__func()
    #
    
    """------------------ 继承关系的误区 ------------------"""
    # 不要为了复用代码而继承
    
    class Father:
        def func1(self):
            print('func1')
    
    class A(Father):
        # def func1(self):
        #     print('func1')
    
        def func2(self):
            print('func2')
    
    
    class B(Father):
        # def func1(self):
        #     print('func1')
    
        def func3(self):
            print('func3')
    
    b = B()
    b.func1()
    b.func3()
    # b.func2()

继承关系图:

"""
    python里面任何类型最终都是继承自object
    """
    # 父类
    class Father:
        pass
    
    # 子类
    class Son(Father):
        pass
    
    class Teacher:
        pass
    
    son = Son()
    # 查看Son的继承关系
    print(Son.__mro__)
    # 查看Teacher的继承关系
    print(Teacher.__mro__)

子类重写父类的方法:

"""
    需求:
    1.定义父类,具有sayHello方法
    2.子类继承父类,修改sayHello方法
    
    """
    
    
    # 1.定义父类,具有sayHello方法
    class Father:
        def sayHello(self):
            print('同志好')
    
    
    # 2.子类继承父类,修改sayHello方法
    class Son(Father):
        def sayHello(self):
            print('美女好')
    
    
    
    son = Son()
    son.sayHello()

子类对父类方法加强:

"""
    需求:
    1.定义洗衣机,具有wash洗衣服功能
    2.定义智能洗衣机,继承洗衣机,wash洗衣服还可以有烘干功能
    
    """
    # 1.定义洗衣机,具有wash洗衣服功能
    class WashMachine:
        def wash(self):
            print('洗衣服')
    
    # 2.定义智能洗衣机,继承洗衣机,wash洗衣服还可以有烘干功能
    class SmartWashMachine(WashMachine):
        def wash(self):
            # 重用父类的功能,调用父类的wash方法
            """------------------ 第一种调用父类方法 ------------------"""
            # WashMachine.wash(self)
            """------------------ 第二种调用父类方法 ------------------"""
            # 快速提示
            # super(SmartWashMachine, self).wash()
            """------------------ 第三种调用父类方法 ------------------"""
            # 只支持python
            # super().wash()
    
    
            # 添加新的功能
            print('烘干衣服')
    
    swm = SmartWashMachine()
    swm.wash()

属性继承问题:

class Person:
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
    class Student(Person):
        # 只要子类重写了__init__方法,父类成员属性都不能再使用了
        # 既想使用父类的成员属性  又想添加一些新的属性
    
        def __init__(self,name,age,id):
            # 调用父类的init方法
            """------------------ 第一种 ------------------"""
            # Person.__init__(self,name,age)
            """------------------ 第二种 ------------------"""
            # super(Student, self).__init__(name,age)
            """------------------ 第三种 ------------------"""
            super().__init__(name,age)
            # 添加新的属性id
            id = id
    
    
    # 创建Student对象
    stu = Student('张三',30,'123123')
    print(stu.name)
    # stu = Student('张三',30)
    # print(stu.name,stu.age)

多继承方法问题:

"""
    需求:
    定义Mother类,Mother具有cook方法
    定义Father类,Father具有makeMoney方法
    
    """
    """
    多继承:子类可以使用父类中公有的方法
    """
    
    # 定义Mother类,Mother具有cook方法
    class Mother:
        def cook(self):
            print('做饭')
    
    
    # 定义Father类,Father具有makeMoney方法
    class Father:
        def makeMoney(self):
            print('赚钱')
    
    
    # 定义Son类
    class Son(Mother, Father):
        pass
    
    
    # 创建Son对象
    son = Son()
    # 调用Mother的功能
    # son.cook()
    # 调用Father的功能
    # son.makeMoney()

多继承属性问题:

"""
    需求:
    Mother类还具有money属性
    Father类还具备wage工资属性
    
    """
    
    """
    多继承 不能够直接使用所有父类的属性
    """
    class Mother:
        def __init__(self,money):
            self.money = money
    
        def cook(self):
            print('做饭')
    
    
    class Father:
        # def __init__(self,wage):
        #     self.wage = wage
    
        def makeMoney(self):
            print('赚钱')
    
    
    # 定义Son类
    class Son(Father,Mother):
        pass
        # 既想使用Mother的属性 又想使用Father的属性
        # def __init__(self,money,wage):
        #     # 第一种
        #     # 定义Mother属性 调用Mother的__init__
        #     Mother.__init__(self,money)
        #     # 定义Father属性 调用Father的__init__
        #     Father.__init__(self,wage)
    
    
    
    # 创建Son对象
    son = Son(9500)
    # 调用Mother的money属性
    print(son.money)
    
    # 调用父类的wage属性
    # print(son.wage)
    
    """------------------ 多继承,默认能够使用继承链下一个类的属性 ------------------"""
    print(Son.__mro__)

多继承同名方法:

"""
    需求:
    定义Mother类,Mother具有cook方法
    定义Father类,Father具有cook方法
    定义Son继承Mother和Father
    
    """
    
    """
    多继承出现同名方法:只会执行继承链下一个类的方法
    """
    # 定义Mother类,Mother具有cook方法
    class Mother:
        def cook(self):
            print('妈妈做饭')
    
    
    # 定义Father类,Father具有cook方法
    class Father:
        def cook(self):
            print('爸爸做饭')
    
    
    # 定义Son继承Mother和Father
    class Son(Father,Mother):
        def cook(self):
            # 执行Mother的cook
            Mother.cook(self)
            # 执行Father的cook
            Father.cook(self)
    
    # 创建Son对象
    son = Son()
    son.cook()

多继承同名属性:

"""
    需求:
    定义Mother类,Mother具有name和age属性
    定义Father类,Father具有name和age属性
    定义Son继承Mother和Father
    
    """
    # 定义Mother类,Mother具有name和age属性
    class Mother:
        def __init__(self):
            self.name = '围裙妈妈'
            self.age = 30
    
    # 定义Father类,Father具有name和age属性
    class Father:
        def __init__(self):
            self.name = '小头爸爸'
            self.age = 34
    
    # 定义Son继承Mother和Father
    class Son(Mother,Father):
        def __init__(self):
            # 调用Mother的init
            Mother.__init__(self)
            # 调用Father的init  修改了前面Mother的name和age
            Father.__init__(self)
    
    # 创建Son对象
    son = Son()
    print(son.name,son.age)

多层继承:

"""
    需求:
    1.定义爷爷类,具有name和age属性,具有smoke方法
    2.定义爸爸类,具有name、age以及phone属性,具有smoke和drink方法
    3.定义儿子类,具有爷爷和爸爸所有的属性和方法
    
    """
    
    
    # 1.定义爷爷类,具有name和age属性,具有smoke方法
    class GrandFather:
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def smoke(self):
            print('抽烟')
    
    
    # 2.定义爸爸类,具有name、age以及phone属性,具有smoke和drink方法
    class Father(GrandFather):
        def __init__(self, name, age, phone):
            # 调用GrandFather的init方法
            super(Father, self).__init__(name, age)
            # 添加phone属性
            self.phone = phone
    
        def drink(self):
            print('喝酒')
    
    
    # 3.定义儿子类,具有爷爷和爸爸所有的属性和方法
    class Son(Father):
        pass
    
    
    # 创建Son对象
    son = Son('小明',20,'1243123')
    # son有哪些属性?
    print(son.name,son.age,son.phone)
    # son有哪些功能呢?
    son.drink()
    son.smoke()

多态和鸭子模型:

"""------------------ 多态 ------------------"""
    # # 父类
    # class Human:
    #     def eat(self):
    #         print('人类吃饭')
    #
    # # 中国人
    # class ZhHuman(Human):
    #     def eat(self):
    #         print('中国人使用筷子吃饭')
    #
    # # 美国人
    # class UsHuman(Human):
    #     def eat(self):
    #         print('美国人使用刀叉吃饭')
    #
    # # 非洲人
    # class AfricaHuman(Human):
    #     def eat(self):
    #         print('非洲人直接用手吃恩希玛')
    #
    # # 函数
    # def tranlate(human):
    #     '''
    #     接收一个具备吃放功能的Human对象
    #     :param human:Human对象
    #     :return:
    #     '''
    #     human.eat()
    
    # 创建四个对象
    # human = Human()
    # zhHuman = ZhHuman()
    # usHuman = UsHuman()
    # africaHuamn = AfricaHuman()
    
    # 调用translate方法
    # tranlate(human)
    # tranlate(zhHuman)
    # tranlate(usHuman)
    # tranlate(africaHuamn)
    
    
    """------------------ 鸭子模型 ------------------"""
    # 动态类型语言:
    # java静态类型语言:
    class Dog:
        def eat(self):
            print('狗吃骨头')
    # 函数
    def tranlate(human):
        '''
        接收一个具备吃饭功能的Human对象
        :param human:Human对象
        :return:
        '''
        human.eat()
    
    dog = Dog()
    tranlate(dog)
    
    # tranlate(10)

反恐精英:

"""------------------ 枪支类 ------------------"""
    
    
    class Gun:
        def __init__(self, model, damage):
            '''
            初始化枪支
            :param model: 型号
            :param damage: 伤害
            '''
            self.model = model
            self.damage = damage
            # 默认子弹数量
            self.bullet_count = 0
    
        def __str__(self):
            return '型号:{},伤害:{},子弹数量:{}'.format(self.model, self.damage, self.bullet_count)
    
        def add_bullets(self, count):
            '''
            添加子弹
            :param count:
            :return:
            '''
            self.bullet_count += count
            print('添加子弹成功')
    
        def shoot(self, enemy):
            '''
            射击敌人
            :param enemy: 敌方Player类型
            :return:
            '''
            # 判断子弹是否为0
            if self.bullet_count == 0:
                print('请填充子弹')
            else:
                # 有子弹
                # 减少子弹
                self.bullet_count -= 1
                # 默认击中敌人
                enemy.hurt(self)
    
    
    """------------------ 游戏玩家 ------------------"""
    
    
    class Player:
        def __init__(self, role):
            '''
            初始化玩家
            :param role: 玩家角色
            '''
            self.role = role
            # 默认血量为100
            self.hp = 100
            # 枪支 默认没有枪支 为None
            self.gun = None
            # 状态
            self.state = '活着'
    
        def __str__(self):
            return '角色:{},状态:{},血量:{},枪支:{}'.format(self.role, self.state, self.hp, self.gun)
    
        def fire(self, enemy):
            '''
            射击敌人
            :param enemy: 敌人Player类型
            :return:
            '''
            # 判断有没有枪
            if self.gun:
                # 有枪
                # 判断是否有子弹
                if self.gun.bullet_count > 0:
                    # 有子弹
                    self.gun.shoot(enemy)
                else:
                    # 没有子弹,添加子弹
                    self.gun.add_bullets(5)
            else:
                # 没枪
                print('现在还没有枪支')
    
        def hurt(self, enemy_gun):
            '''
            玩家受到伤害
            :param enemy_gun:受到哪个枪支的伤害
            :return:
            '''
            # 减少血量
            self.hp -= enemy_gun.damage
            if self.hp<=0:
                # 死亡
                print('玩家:{}死亡'.format(self.role))
            else:
                # 提示玩家受伤  提示当前血量
                print('玩家受伤,当前血量:{}'.format(self.hp))
    
    # 创建枪支
    gun = Gun('ak47',10)
    # 创建警察
    player1 = Player('警察')
    # 创建土匪
    player2 = Player('土匪')
    
    # 把枪支交给警察
    player1.gun = gun
    
    # 警察射击土匪
    while player2.hp>0:
        player1.fire(player2)