Python学习笔记_2

一、函数

1. 定义：

def 函数名(参数1，参数2）：            ----（参数可有可无）

           语句体

           return 变量                 ----（return可有可无）

2. 调用：

函数名

变量=函数名(参数1，参数2)      ----（变量，参数可有可无）

① 调用 ②传参 ③ 接收返回值

3. 举例：

①第一种：无参无返回值

# 定义函数calc 
def calc():
    a = int(input('请输入第一个数：'))
    b = int(input('请输入第二个数：'))
    c = a + b
    # print('结果为：',c)
    print('结果为：%d'%c)
# 调用
calc()

运行结果为：

　　请输入第一个数：1
　　请输入第二个数：3
　　结果为：4

② 第二种：无参有返回值

def calc():
    a = int(input('请输入第一个数：'))
    b = int(input('请输入第二个数：'))
    c = a + b
    return c
# 调用
# print(calc())
result = calc()
print(result)

③ 第三种：有参有返回值

def calc(x,y):
    c = x + y
    return c

a = int(input('请输入第一个数：'))
b = int(input('请输入第二个数：'))

result = calc(a,b)
print(result)

4. 练习：设计一个计算器

① 输入两个数，自动实现加减乘除

x = int(input('请输入第一个数：'))
y = int(input('请输入第二个数：'))
def add():
    z = x + y
    return z
def sub():
    z = x - y
    return z
def mul():
    z = x * y
    return z
def div():
    z = x / y
    return z

print('两数相加为：',add())
print('两数相减为：',sub())
print('两数相乘为：',mul())
print('两数相除为：',div())
运行结果为：

　　请输入第一个数：6
　　请输入第二个数：2
　　两数相加为： 8
　　两数相减为： 4
　　两数相乘为： 12
　　两数相除为： 3.0

② 进阶：根据用户输入的计算符号计算结果

def calc():
    x = int(input('请输入第一个数：'))
    y = int(input('请输入第二个数：'))
    z = input('请输入运算符号：+ - * /:')
    if z == '+':
        result = x + y
        print('两数相加为：',result)
    elif z == '-':
        result = x - y
        print('两数相减为：',result)
    elif z == '*':
        result = x * y
        print('两数相乘为：',result)
    elif z == '/':
        try:
            result = x / y
            print('两数相除为：',result)
        except ZeroDivisionError:
            print('除数不能为0！')
    else:
        print('运算符号输入错误，请重新输入！')
calc()

5. 参数的几种类型：

① 位置参数：调用函数时根据函数定义的参数位置来传递参数

def person(name,sex):
    sex_dict = {1:'先生',2:'女士'}
    print('hello %s %s,welcome~'%(name,sex_dict.get(sex,'女士')))
person('baby',2)
运行结果为：
hello baby 女士,welcome~

注意：位置参数的两个参数的顺序必须一一对应，且少一个参数都不可以

② 默认参数：用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值

注意：定义默认参数时，必选参数在前、默认参数在后（包括函数定义和调用），否则python解释器会报错，且默认参数必须执行不变对象！

 1）默认参数指向可变对象时：（保留了上次执行的结果）

def add_end(L = []):
    L.append('end')
    return L

print(add_end())
print(add_end())
运行结果：

['end']
['end', 'end']

 2）默认参数指向不变对象时：

def add_end(L = None):
    if L is None:
        L = []
    L.append('end')
    return L

print(add_end())
print(add_end())
运行结果：

['end']
['end']

③ 可变参数：定义函数时，有时候我们不确定调用的时候会传递多少个参数(不传参也可以)。此时，可用位置参数，或者关键字参数，来进行参数传递

我们传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递

1）

def calc(*args):
    print(*args)    # *args打印出来是一个一个的整型的数
    print(args,type(args))   # args默认保存为元组，打印出来是一个元组
    for i in args:
        print('传入的值分别为：',i)

# 可变参数传参形式1 - 常用（通过引用的方式必须带*）
m = [1,2,3]
calc(*m)

运行结果：
1 2 3
(1, 2, 3) <class 'tuple'>
传入的值分别为： 1
传入的值分别为： 2
传入的值分别为： 3

2）

def calc(*args):
    print(*args)    # *args打印出来是一个一个的整型的数
    print(args,type(args))   # args默认保存为元组，打印出来是一个元组
    for i in args:
        print('传入的值分别为：',i)

n = (3,4,5)
calc(*n)

3）

def calc(*args):
    print(*args)    # *args打印出来是一个一个的整型的数
    print(args,type(args))   # args默认保存为元组，打印出来是一个元组
    for i in args:
        print('传入的值分别为：',i)

# 可变参数传参形式2
calc(1,2,3)

④ 关键字参数：用于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

kargs是一个字典(dict)，收集所有关键字参数

def person(name,age,**kwargs):
    print('name',name,'age',age,kwargs)
    print(kwargs,type(kwargs))

person('xiaoming',21,sex = 'male',color = 'blue')
person('xiaoming',21)  # 可变参数和关键字参数可以不传
person('xiaoming',21,sex = 1)
person('xiaoming',21,sex = 'male')

总结：

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

关键字参数有什么用？

它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

def person(name,age,**kwargs):
    print('name',name,'age',age,kwargs)

extra = {'city':'beijing','job':'Engineer'}
person('xiaoming',25,**extra)

运行结果为：
name xiaoming age 25 {'job': 'Engineer', 'city': 'beijing'}

6. 异常处理：

① 已知类型：try ... except

def calc(a,b):
    try:
        print(a/b)
    except ZeroDivisionError:
        print('除数不能为0！')

a = int(input('-'))
b = int(input('-'))

calc(a,b)

运行结果为：
-2
-0
除数不能为0！

② 未知类型：https://www.cnblogs.com/zln1021/p/6106185.html

def calc(a,b):
    try:
        print(a/b)
    except Exception:   # BaseException
        print('除数不能为0！')

a = int(input('-'))
b = int(input('-'))

calc(a,b)

③ 多重异常：

def calc(a,b):
    try:
        print(a/b)
    except NameError:
        print('该对象未申明')
    except ZeroDivisionError:
        print('除数不能为0')

a = int(input('-'))
b = int(input('-'))

calc(a,b)

④ 最终处理：

def calc(a,b):
    try:
        print(a/b)
    except NameError:
        print('该对象未申明')
    except ZeroDivisionError as msg:
        # print(msg)
        print('除数不能为0',msg)
    finally:
        print('程序执行完毕')

a = int(input('-'))
b = int(input('-'))
calc(a,b)

⑤ else：在程序没有抛出异常的时候，继续执行else语句

def calc(a,b):
    try:
        print(a/b)
    except NameError:
        print('该对象未申明')
    except TypeError as msg:
        print(msg)
    else:
        print('程序执行完毕！')

a = int(input('请输入第一个数：'))
b = int(input('请输入第二个数：'))
calc(a,b)

⑥抛出异常：异常必须为exception的子类

raise TypeError（'类型错误'）

def calc(a,b):
    try:
        print(a/b)
    except NameError:
        print('该对象未申明')
        # 查看异常后不做处理继续抛出异常
        raise
    except ZeroDivisionError as msg:
        # print(msg)
        print('除数不能为0',msg)
    else:
        print('程序执行完毕')

a = int(input('-'))
b = int(input('-'))
calc(a,b)

⑦ 练习：name没有定义，type异常，并抛出是何种异常

def calc(a,b):
    try:
        print(a/b)
    except NameError as msg:
        print('该对象未申明',msg)
        raise
    except TypeError as msg:
        print(msg)
        raise
    else:
        print('程序执行完毕！')

a = int(input('请输入第一个数：'))
b = int(input('请输入第二个数：'))
calc(a,b)

7. 文件IO：

文件操作流程：

① 找到文件 ：新建文件new --> file-->data.txt，查看文件路径：右键data，选择Show in Explorer（路径支持绝对路径和相对路径）

data文件内容如下：

a,b,c
tom,lucy,lily
1,2,3

② 打开文件：（文件路径和打开模式）

打开文件的模式有：

• r：只读模式（默认）。
• w：只写模式（不可读；不存在则创建；存在则删除内容）
• a：追加模式 -- append（可读；不存在则创建；存在则只追加内容）

　　"+" 表示可以同时读写某个文件

• r+：可读写文件（可读；可写；可追加）
• w+：写读
• a+：同a

f = open('F:CodeVIPtest2data.txt','r')

③ 操作文件：读、写

读取文件所有内容：print(f.read())   -- 文件大时不要用

读取指定长度字节的数据：print(f.read(4))   -- 读取前4个字节的内容

读取整行：print(f.readline())   -- 读取光标所在位置的整行

读取前5行：

for i in range(5):
    print(f.readline())

如果需要读取5-10行，中间加个if判断即可

读取所有行：print(f.readlines())    -- 列表形式输出

运行结果：['a,b,c ', 'tom,lucy,lily ', '1,2,3 ', ' ']

写：

f = open('F:CodeVIPtest2data2.txt','r+')
f.write('hello python!
')
f.write('welcome~')
f.close()

④ 关闭文件：f.close()

作业：只取出data中的数字并写入另外的文件

思路：

① 读取文件中的所有数据 -- readlines

② 从列表中找出含有的数字 

    判断列表中的每一个元素是否含有数字 -- 将列表中的每一个元素（数据的行）取出来，作为一个小的列表

    判断每一个小的列表是否含有数字 isdigit()，如果是数字，则追加到一个新的列表

③ 排序、写入

data：

a,b,c
tom,lucy,lily
1,3,9,6,8,4,5

代码：

f = open('F:CodeVIPtest2data.txt','r')
lines = f.readlines()
# print(lines)
lists = []
for l in lines:
    # print(l)
    s = l.split(',')   # 切片
    # print(s)
    for m in s:
        if m.strip().isdigit():   # 判断是否为数字
            lists.append(m.strip())
        else:
            continue
    for i in range(1,len(lists)):   # 冒泡排序
        for j in range(0,len(lists)-i):
            if lists[j] > lists[j+1]:
                lists[j],lists[j+1] = lists[j+1],lists[j]
print(lists)
f.close()
f1 = open('F:CodeVIPtest2data3.txt','r+')
f1.write(str(lists))
f1.close()

8. 模块和包：

① 模块：模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py，模块可以被别的程序引入，以使用该模块中的函数等功能，这也是使用python标准库的方法。

Mymodule:

def fun1():
    print('我是fun1函数')

def fun2():
    print('我是fun2函数')

print('name的值为：',__name__)

# 每个模块都有一个__name__属性，当其值为：'__main__'时，表明该模块自身在运行，否则是被引入

if __name__ == '__main__':
    fun1()
    fun2()

__name__的作用：一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

② 包：当一个目录内含有__init__.py文件时，就可以视该目录为一个包。

③ 调用包和模块：

第一种调用方式：import 模块名/ 包名（只能导入名称）

右键practice-->mark directory as->resource root(将当前路径加入python查找的默认路径

如果通过import调用，使用包内的方法需要通过包名.函数名的形式

Mymodule.fun1()

第二种调用方式：from 包名 import 模块名

from ... import的形式导入，from后面只能跟包和模块名，不能跟函数名，import后面跟函数或者类名

绝对导入：from practice import module

from Mymodule import fun1

通过from-import的形式可以直接使用函数名

fun1()
fun2()

第三种调用方式：相对导入

from .database import Database   # 点号表示使用当前路径的database模块

from ..database import Database  # 使用两个点号表示访问上层的父类

第四种调用方式：通过import* 可以导入多个函数

from Mymodule import *

二、面向对象的类、属性、方法

1. 基础：

类：具有相同的特性，且能够完成某些动作的事物组成的一个集合

属性：类中的事物所具有的特性，趋于静态

方法：类中的事物所能够完成的动作或功能，趋于动态

实例/对象：类中某一个具体的对象或实例

实例化：定义类中某一个对象的过程

2. 类的定义：

class 类名（object）：

            属性

            方法

注意：

① 属性和方法可以为空，里面直接写pass即可，表示是一个空类

② 方法一般都是动作，能完成某些功能，属性一般都是特点，静态，用来描述事物的特性

举例：

# 类的定义
class Person:
    # 类属性/方法 -- 初始化方法，类中必须存在的且在实例化过程中自动被调用的方法（定义属性）
    def __init__(self,name):
        self.name = name
        print('此方法被调用！')

    def eat(self,food):
        print('%s吃%s'%(self.name,food))
        # print(self.sleep()) #调用别的方法需要加self
    def sleep(self):
        print('睡觉')

# 类的调用第一步：实例化（创建一个对象：变量名=类名()）---是否需要传参就看__init__方法中除了self是否还有其他参数
a =  Person('xiaoming')
b = Person('xiaohong')
# 类的调用第二步：调用类中的方法（实例名.方法名()） ---是否需要传参就看该方法中除了self是否还有其他参数
a.eat('rice')
b.eat('noodle')
运行结果为：
此方法被调用！
此方法被调用！
xiaoming吃rice
xiaohong吃noodle

3. 类的实例化：

变量=类名('xx')  ---是否需要传参就看__init__方法中除了self是否还有其他参数

4. 类中方法的调用：

实例名.方法名('xx')  ---是否需要传参就看该方法中除了self是否还有其他参数

练习：

① 定义一个学生类：Student、内部含有一个方法：study，实现打印：小明学习xx课程

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

    def study(self,course):
        print('%s学习%s'%(self.name,course))

a = person('xiaoming')
a.study('math')
运行结果为：
xiaoming学习math

② 定义一个类名：Student—学生、类内部含有一个属性：sno—学号，一个方法：study—学习，实现打印：学号为xx的学生，学习xx课程

class Student():
    def __init__(self,sno):
        self.sno = sno

    def study(self,course):
        print('学号为%s的学生,学习%s的课程'%(self.sno,course))

a = Student('6')
a.study('math')
运行结果为：
学号为6的学生,学习math的课程

5. 继承：为了提高代码的复用性，可以通过继承来减少属性和方法的编写

语法：继承谁就在括号中写谁-类名

 注意事项：

① 继承后，子类就具有父类的所有属性和方法，但是父类不能具备子类的属性和方法

② 如果父类中没有子类需要的方法，可以在子类中自行定义

③ 实例化和调用方法的时候要区分是否需要传参

④ 继承的时候需要用到父类的属性时，需要在子类中再次进行初始化

例子：

class Animal:
    def eat(self):
        print('吃饭')
    def drink(self):
        print('喝水')
class Dog:
    def eat(self):
        print('吃饭')
    def drink(self):
        print('喝水')

class Dog(Animal):    # 继承
    def bark(self):
        print('汪汪叫')

class Cat(Animal):
    def catch(self):
        print('抓老鼠')

a = Cat()
a.eat()
运行结果：
吃饭

练习：

定义一个Teacher类，继承Person类，拥有自身的属性工号gh，自身的方法：teach教课（课程）；

① 实现gh为xx的老师，教xx课

② 实现gh为xx老师，在xx上班，一月工资xx

③ 名字是xx，工号为xx的老师，吃饭

class Person:
    def __init__(self,name):
        self.name = name
        print('此方法被调用！')
    def eat(self,food):
        print('%s吃%s'%(self.name,food))
    def sleep(self):
        print('睡觉')
class Teacher(Person):
    def __init__(self,gh,salary,name):
        self.gh = gh
        self.salary = salary
        self.name = name
    def teach(self,course):
        print('工号为%s的老师，教%s课'%(self.gh,course))
    def address(self,place):
        print('工号为%s的老师，在%s上班，一月薪资%s'%(self.gh,place,self.salary))
    def eat(self,food):
        print('名字是%s，工号为%s的老师吃%s'%(self.name,self.gh,food))
a = Person('xiaoming')
b = Person('xiaohong')
c = Teacher('66','20000','梁老师')
a.eat('rice')
b.eat('noodle')
c.teach('math')
c.address('beijing')
c.eat('rice')

运行结果为：
此方法被调用！
此方法被调用！
xiaoming吃rice
xiaohong吃noodle
工号为66的老师，教math课
工号为66的老师，在beijing上班，一月薪资20000
名字是梁老师，工号为66的老师吃rice

6.重写：当继承的父类方法不满足自身需要的时候，我们可以重写该父类的方法，注意，必须同名

例子：

class Animal:
    def eat(self):
        print('吃饭')
    def drink(self):
        print('喝水')

class Dog(Animal):
    def bark(self):
        print('汪汪叫')

class Xiaotq(Dog):
    def fly(self):
        print('飞翔')
    def bark(self):
        print('哮天犬狂叫')

a = Xiaotq()
a.fly()
a.bark()

调用父类的方法：

class Animal:
    def eat(self):
        print('吃饭')
    def drink(self):
        print('喝水')

class Dog(Animal):
    def bark(self):
        print('汪汪叫')

class Xiaotq(Dog):
    def fly(self):
        print('飞翔')
    def bark(self):
        print('哮天犬狂叫')
        # 第一种调用被重写的方法，父类的名字.方法名()
        Dog.bark()
        # 第二种
        super().bark()

a = Xiaotq()
a.fly()
a.bark()
# 子类可以拥有父类的功能
a.eat()

多重继承的注意事项：

# 尽可能不要出现相同的方法名字
class Base(object):
    def test(self):
        print('------base')

class A(Base):
    def test1(self):
        print('------test1')

class B(Base):
    def test2(self):
        print('------test2')

class C(A,B):
    pass

# 方法的查找顺序是按照继承的最近来，先查找自身，再查找A,再查找B,再查找Base
c = C()
c.test()
c.test1()
c.test2()

7.多态：多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

class Dog(object):
    def print_self(self):
        print('大家好，我是xxx')

class Xiaotq(Dog):
    def print_self(self):
        print('hello,everyboby,我是xxx')

def introduce(temp):
    temp.print_self()

dog1 = Dog()
dog2 = Xiaotq()

# 多态的关键在于，同样是调用相同的方法，但是完成的内容却不同，普通狗的自我介绍是与哮天犬的自我介绍不一样
introduce(dog1)
introduce(dog2)

8.私有属性和私有方法

类的私有属性

__abc：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__abc。

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法

__method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__ methods。

# 如果调用的是继承父类中的公有方法，可以在这个公有方法中访问父类中的私有属性和私有方法
# 但是如果在子类中实现了一个公有方法，那么这个方法是不能够调用继承的父类中的私有方法和私有属性的

class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200
        # print(self.num1,self.__num2)
    def test1(self):
        print('公有方法')

    def __test2(self):
        print('私有方法')

    def test3(self):
        print('公有方法中调用私有方法和私有属性')
        self.__test2()
        print(self.num1)
        print(self.__num2)

class B(A):
    def test4(self):
        # self.__num2
        self.__test2()

b = B()
b.test4()

Python练习题：

1.打印小猫爱吃鱼，小猫要喝水

class Animal():
    def __init__(self,name):
        self.name = name
        print('此方法被调用')
    def eat(self,food):
        print('%s爱吃%s'%(self.name,food))
    def drink(self,drinks):
        print('%s要喝%s'%(self.name,drinks))
a = Animal('小猫')
a.eat('鱼')
a.drink('水')

2.小明爱跑步，爱吃东西。
① 小明体重75.0公斤

② 每次跑步会减肥0.5公斤

③ 每次吃东西体重会增加1公斤

④ 小美的体重是45.0公斤

class Person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
        print('此方法被调用')
    def person1(self):
        print('%s的体重是%s'%(self.name,self.weight))
    def run(self):
        print('%s爱跑步,每次跑步会减肥%s'%(self.name,self.weight))
    def eat(self,food):
        print('%s爱吃%s,每次吃东西体重会增加%s'%(self.name,food,self.weight))
    def person2(self):
        print('%s的体重是%s'%(self.name,self.weight))
a = Person('小明','75kg')
b = Person('小明','0.5kg')
c = Person('小明','1kg')
d = Person('小美','45kg')
a.person1()
b.run()
c.eat('东西')
d.person2()

运行结果为：
此方法被调用
此方法被调用
此方法被调用
此方法被调用
小明的体重是75kg
小明爱跑步,每次跑步会减肥0.5kg
小明爱吃东西,每次吃东西体重会增加1kg
小美的体重是45kg

3.摆放家具
需求：

① 房子有户型，总面积和家具名称列表，新房子没有任何的家具

② 家具有名字和占地面积，其中
床：占4平米
衣柜：占2平面
餐桌：占1.5平米

③将以上三件家具添加到房子中

④打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

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):
        return ('户型:%s
总面积:%.2f[剩余:%.2f]
家具:%s' % (self.house_type, self.area, self.free_area, self.item_list))
    def add_item(self, item):
        # 1.判断家具的面积
        if item.area > self.free_area:
            print('%s的面积太大，无法添加' % item.name)
        # 2.将家具的名称添加到列表中
        self.item_list.append(item.name)
        # 3.计算剩余面积
        self.free_area -= item.area
# 1.创建家具对象
bed = HouseItem('bed', 4)
yg = HouseItem('yg', 2)
table = HouseItem('table', 1.5)
# 2.创建房子对象
my_house = House('两室一厅', 100)
# 3.添加家具
my_house.add_item(bed)
my_house.add_item(yg)
my_house.add_item(table)
print(my_house)
运行结果为：
户型:两室一厅
总面积:100.00[剩余:92.50]
家具:['bed', 'yg', 'table']

4.士兵开枪
需求：

① 士兵瑞恩有一把AK47

② 士兵可以开火(士兵开火扣动的是扳机)

③ 枪 能够 发射子弹(把子弹发射出去)

④ 枪 能够 装填子弹 --增加子弹的数量

class Soldier:
    def __init__(self, name):
        self.name = name
        self.gun = None
    def __str__(self):
        return '%s士兵的枪为%s' % (self.name, self.gun)
    def fire(self):
        if self.gun == None:
            print('士兵还没有枪')
        else:
            self.gun.shoot()
class Gun:
    def __init__(self, model):
        self.model = model
        self.bullet_count = 0
    def __str__(self):
        return '%s的子弹有%s颗' % (self.model,self.bullet_count)
    def shoot(self):
        if self.bullet_count < 1:
            print('没有子弹了，请补充子弹再射击')
        else:
            self.bullet_count -= 1
            return self.bullet_count
    def add_bullet(self, count):
        if self.bullet_count >= 50:
            print('子弹已经装满，不可再加')
        else:
            self.bullet_count += count
ryan = Soldier('Ryan')
AK47 = Gun('AK47')
AK47.shoot() # 此时没有子弹不能射击
AK47.add_bullet(50) # 加50发子弹
AK47.shoot()
print(AK47)
ryan.gun = AK47
ryan.fire()
print(ryan)
print(AK47)
运行结果为：
没有子弹了，请补充子弹再射击
AK47的子弹有49颗
Ryan士兵的枪为AK47的子弹有48颗
AK47的子弹有48颗