py语法08-函数返回参数

# encoding=utf-8
"""
1、函数描述
（1）函数定义：描述生活中的行为方式
（2）函数优势：提高代码的复用性
（3）函数好处：解决问题的步骤和过程
2、代码重复问题
（1）循环可以使表达重复做的事简化代码，但是循环做的事情不能独立分开：不能控制在什么位置执行；代码的重复量过大，不容易控制重复次数
（2）为了循环处理中间有其他事情的需要重复使用的代码，需要函数来解
决重复事情中断问题
（3）把具有某一段功能的代码提取出来, 封装成一个代码块, 在需要的时候进行调用
（4）函数就是实现特定功能，能够重复使用的代码块(一行或多行)
（5）函数的优点：去除重复的代码；函数功能发生修改时，只需要修改函数体即可(增强程序的拓展性)
3、定义
（1）循环可以使表达重复做的事简化代码，但是循环做的事情不能独立分开
（2）为了循环处理中间有其他事情的需要重复使用的代码，需要函数来解决重复事情中断问题
（3）把具有某一段功能的代码提取出来, 封装成一个代码块, 在需要的时候进行调用
（4）函数就是实现特定功能，能够重复使用的代码块(一行或多行)
4、格式
（1）定义函数，def用于声明一个函数：def 函数名([参数列表]):
（2）函数名：标识符，符合标识符的规则和规范
（3）文档注释：""注释函数的功能作用""
（4）函数体：调用函数要执行的代码
（5）返回值，将函数内的数据返回到函数外：return 要返回的值
（6）参数：外界输入的数据，个数不定
    A、形参：形式上的参数，在函数定义时参数的名字
    B、实参：实际上的参数，在函数调用时传入的名字
    def 函数名():
        ""文档注释""
        函数体
        return 返回值
（7）调用函数：函数名()
5、函数体：实现函数功能的代码
（1）函数声明的时候，不会执行函数体
（2）函数调用的时候，才会执行函数体
（3）函数必须先定义后调用
（4）一个函数体可以被多次执行(一个函数可以被多次调用)
6、函数名
（1）必须满足标识符的命名规则
（2）由数字、字母、下划线组成，数字不能开头
（3）不能是关键字和方法名
（4）不要使用拼音，多个英文单词组成的时候，中间以下划线连接
7、函数使用
（1）必须在声明之后，直接使用函数名([参数列表])即可
（2）调用函数后若有返回值，会将返回值给调用的函数变量
（2）使用函数名只会调取函数名，相当于一个变量
（3）可以反复调用且各次调用互相互不影响
（4）使用的列表、元组、字典、集合等方法都是在调用函数
8、函数规范
（1）函数声明前后空两行
（2）函数中要添加文档注释
（3）函数的名称遵循变量的命名规则：下划线命名法|驼峰命名法
9、扩展声明
（1）函数中的参数，可以接受任意类型的数据
（2）特殊声明：在代码中建议参数接受的数据类型
10、返回值
（1）格式：return 返回值
（2）函数其他位置需要，则需要返回数据，给其他代码使用；若其他位置不需要，则无需返回数据
（3）函数有返回值，会返回执行的结果，多个值以元组形式返回；没有返回值，默认是None
（4）return作用：结束函数的执行；将函数的返回值，返回给调用处；将函数内的数据返回到函数外
11、函数注释
（1）函数注释用于解释说明程序的信息和功能
（2）格式：在函数体中，输入三对引号，回车，自动生成函数说明文档格式
（3）函数名.__doc__：查看函数的说明文档
    A、若有说明文档，会返回说明
    B、若没有说明文档，会返回一个None
12、函数参数
（1）无参数调用：直接使用函数名(相当于使用变量)加小括号(执行函数)
（2）形参（形式参数）：形式上的参数，在函数声明定义时，写在括号里的变量
（3）实参（实际参数）：实际上的参数，在函数调用的时候，写在调用处括号里的值
（4）函数调用时,才能确定实参：函数名(实参匹配形参)
13、位置参数
（1）函数按照形参和实参的位置对应关系传递数值，实参与形参的个数相同且一一对应
（2）形参是定义函数时任意命名的参数名称，实参是调用函数时实际使用的真实参数数据
（3）缺点：调用函数时，对于函数中的参数的可读性不高
14、关键字参数(函数调用时)：函数名(形参=实参)
（1）通过形式参数的名称，作为中间变量进行数据传递的过程；以name=value的形式，提高每个参数value的本身的意义
（2）调用函数时可以看到关键字，根据关键字调用相应的数据
（3）忽略了原本的位置关系，明确指出形参和实参的对应关系
（4）优点：代码的可读性提升，参数的传递顺序不需要强制规范
15、默认值参数(定义函数时)
（1）定义函数时，给参数一个固定值
（2）若调用函数不传入参数时，默认使用定义时固定值数据
（3）若调用函数传入参数时，使用传入的新数据(实参数据)
（4）传递参数时，必须按照从左到右的顺序设置默认参数，不能跳过
（5）使用场景：某个参数变化比较小，就可以指定一个默认值
（6）程序执行过程：顺序执行--函数声明定义(默认值参数的定义赋值)-->调用函数传参(默认值可不传)-->执行函数体
（7）如果默认值参数是一个可变数据类型对象，函数多次调用，操作的是同一个参数对象，如果不想使用同一参数变量，可以使用实参进行覆盖
（8）若函数内对默认值进行了修改，之后调用时使用的是调用执行的后的改变值
16、可变元组参数：*args(*元祖参数名)
（1）*具有打散序列的功能，将元组中的每个元素作为可变参数传入
（2）可变长的参数，个数是不确定的，用于接收(0-N)个参数
（3）元组形式的参数，只能通过位置参数传递
（4）变长参数也称可变参数：可以接收0~n个参数数据，将接收到的数据放在元组中交给函数使用
17、可变字典参数：**kwargs(**字典参数名)
（1）传入实参时，key=value关键字参数形式传入
（2）**具有打散字典的功能, 将字典中的键值对以关键字参数的形式传入
（3）可变长的参数，个数是不确定的，用于接收(0-N)个参数
（4）字典形式的参数，只能通过关键字参数方式传递
18、万能参数(*args接受可变参数,**kwargs接受可变关键字参数)
（1）参数的个数不定，类型不定，只要符合规范都可接收
（2）理论上可以接受任意符合规范格式的参数
（3）通常先有位置参数，后面是关键字参数(关键字参数使用key-value的形式)
19、参数遵守顺序：位置参数, 可变元组参数, 默认值参数, 可变字典参数
（1）定义函数时：位置参数-->默认值参数/可变元组参数*args-->可变字典参数**kwargs
（2）调用函数时：位置参数-->关键字参数-->可变元组参数*args/可变字典参数**kwargs
"""
print("~~~~~~~~~~~~~~函数处理~~~~~~~~~~~~~~")
# 函数的基本语法
# 声明函数
def eat():
    """文档注释：这个函数式展示登录菜单的"""
    print("准备原材料")
    print("洗菜添水")
    print("炒菜做饭")
    print("盛饭吃饭")
    print("洗碗收拾")

# 执行函数，函数调用方式：直接调用执行函数
# # 将函数eat赋值给e
e = eat()
# 调回函数c，相当于调用eat()
print("调用赋值变量-函数：{e}，赋值变量的类型：{type(e)}")
# 打印函数名称，相当于变量
print(f"打印函数名称：{eat}，函数类型：{type(eat)}")
# 调用函数获取返回值
print(f"调用函数：{eat()}，调用函数类型：{type(eat())}")

# 不需要资源，不需要结果--声明
def flush():
    # 函数中的代码
    print("刷新一下网页，确认画面流畅，声音清晰")
# 调用
flush()

# 需要资源，不需要结果--声明
def get_movie(course):
    # 函数中的代码
    print("获取到老师提供的录屏：", course)
# 调用执行；调用函数时，给函数传递参数~括号中的数据就是提供的资源
get_movie("函数课程")

# 不需要资源，需要结果
def get_express():
    """函数中的代码：取快递的行为"""
    print("出门")
    print("找快递")
    print("取快递")
    # 使用return返回结果：生活中的行为需要汇报结果一样
    return "阿米洛花旦娘：机械键盘"
# 执行函数：函数有返回的数据，需要接收，获取返回的结果
res = get_express()
# 等价于： res = "阿米洛花旦娘：机械键盘"
print("取回来的快递：", res)

# 需要资源，需要结果
def get_pay_express(money):
    # 函数中的代码
    print("帮我取一下快递，货到付款", money)
    # 使用return返回结果
    return "阿米洛花旦娘 机械键盘"
res = get_pay_express(1500)
# 调用   给函数传递参数    获取返回的结果
print("获取到物品：",res)

# 需求定义一个函数，给定一个数字，遍历从1到该数字之间的所有数字
def func1(n):
    """遍历从1到该数字之间的所有数字"""
    for i in range(1,n+1):
        print(i,end=" ")
    print()
# 调用
func1(10)

# 需求定义一个函数，给定两个数字，遍历两个数字之间的所有数字(包含边界)
def func2(m,n):
    """遍历从m到n之间的所有数字"""
    for i in range(m,n+1):
        print(i,end=" ")
    print()
# 调用
func2(10,100)

# 参数可以接受任意类型的数据
def info1(msg):
    print(f"接受到数据：{msg}")
# 调用执行函数
info1(["tom", "jerry"])

# 参数的建议类型：函数名称(参数:建议类型)->返回数据类型
def info2(msg: str) -> int:
    print(f"接受到数据：{msg}")
    return 0
info2("DAMU")

def func1(a,b):
    return a+b
print(func1(3,4))

def func2(greet,name):
    print("%s,%s"%(greet,name))
func2(name="world",greet="hello")

def func3(n):
    n = "jack"
    #函数内穿参 不会改变函数外部的值
name = "boy"
func3(name)
print(name)

def func4(money):
    """买菜的行为"""
    if money > 20:
        res = "上海青、土豆、紫茄子、包菜、啤酒"
        print(f"购买：{res}")
    elif money > 10:
        res = "西红柿、鸡蛋、韭菜"
        print(f"购买：{res}")
    elif money > 5:
        res = "豆腐、小葱.."
        print(f"购买：{res}")
    elif money > 1:
        res = "逛逛就好..."
    else:
        res = "穷逼，逛啥？？？ "
    return res
# 买菜
r = func4(36)
print(f"最终的结果：{r}")
# 买菜
r2 = func4(18)
print(f"最终的结果：{r2}")


# 返回单个数据
def test1():
    print("返回单个数据")
    return "python"
print("函数返回一个数据：",test1())

# 返回一组数据
def test2():
    print("返回一组数据")
    return ["python", "java", "javascript"]
print("函数返回一组数据：",test2())

# 返回多个数据
def test3():
    print("返回多个数据")
    return "python","java","javascript"
print("函数返回多个数据：",test3())

# 函数的无参调用
def login():
    print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@")
    print("~~~~~这是一个登陆界面函数~~~~~")
login()

# 形式参数（形参）和实际参数（实参）
# 形式参数  注意：形式参数需要与实际参数个数相同
def ticket(name, count, price, pay):
    print("~~~~~~~~~~~~~~~~~")
    print(f"购买商品：{name}")
    print(f"购买数量：{count}")
    print(f"商品单价：{price}")
    print(f"应付金额：{price * count}")
    print(f"实际付款：{pay}")
    print(f"找零：{pay - price * count}")
    print("~~~~~~~~~~~~~~~~~")
    input("小票打印完成...")
# 调用  实际参数，实际参与运算   给函数传递参数
ticket("键盘", 2, 13, 30)

# 位置参数：1个参数的函数
def func2(name):
    print(f"我是{name}")
# 调用函数，注意要有参数
func2("杜迅")

# 位置参数：多个参数的函数
def func3(name,age):
    print(f"我是{name}，年龄{age}岁")
# 调用函数，注意要有参数
func3("杜迅",24)

# 默认参数：默认不传参数
def func4(name, age, gender="男"):
    print(f"我是{name}，今年{age}岁，性别{gender}")
func4("杜迅",20)

# 默认参数：默认传递参数
def func4(name, age, gender="男"):
    print(f"我是{name}，今年{age}岁，性别{gender}")
func4("林雨仙",20,"女")

# 关键字参数
def func5(name, age, gender="男"):
    print(f"我是{name}，今年{age}岁，性别{gender}")
func5(name="杜迅", age=20)

# 可变参数，*args只能传递位置参数（元组可变参数）
def func6(*args):
    print("元组参数列表：",args)
    print(f"我是{args[0]}，今年{args[1]}岁，现在是一名{args[2]}")
print("传递元组参数：", end=" ")
func6("杜迅", 20, "Python工程师")
print("\n*打散元组参数序列：", end=" ")
func6(*("李小花", "王二狗", "刘三胖"))

# 可变参数，**kwargs只能传递关键字参数（字典可变参数）
def func7(**kwargs):
    print("字典参数列表：",kwargs)
    print(f"我是{kwargs['name']}，今年{kwargs['age']}岁，现在是一名{kwargs['work']}")
print("\n传递字典参数：", end=" ")
func7(name="杜迅", age=20, work="Python工程师")
print("\n**打散字典参数数列，将字典中的键值对作为可变字典参数传入：", end=" ")
func7(**dict(name='小花', age=18, sex='女'))

# 万能参数，*args，**kwargs（注意顺序，关键字参数必须放到位置参数后面）
def func8(*args, **kwargs):
    print(f"我是{args[0]}，今年{args[1]}岁，现在是一名{kwargs['work']}")
func8("杜迅", 20, work="Python工程师")

# 参数顺序
def order1(a, *b, c="定义默认值", **d):
    print("\n位置参数：", a)
    print("可变元组参数：", b)
    print("默认值参数：", c)
    print("可变字典参数：", d)
order1("位置参数", "A", "B", "C", c="赋值默认值", name="小花", friend="二狗")

def order2(a, b="b", *args, **kwargs):
    print("位置参数：", a)
    print("默认值参数：", b)
    print("可变元组参数：", args)
    print("可变字典参数：", kwargs)
order2("位置参数", "a", "b", "c", name="小花", friend="二狗")

# 查看函数的说明文档
def get_sum(a, b):
    """
    求两个数的和
    :param a: 一个数
    :param b: 另一个数
    :return: 两个数的和
    """
    return a + b
print("输出函数的说明文档：")
print(get_sum.__doc__)

print("输出函数print的方法属性：")
print(print.__doc__)

# 给定一个整数，返回从1到该数字之间所有数的和
def my_add(n):
    sum = 0
    for i in range(1 , n +1):
        sum += i
    return sum
print(my_add(10))

# 返回多个值
def func2():
    return 'hello' ,1 ,1.5 ,True ,[1 ,2] ,(3 ,4) ,{1 :1} ,{2 ,3 ,4}
print(func2())

# 函数没有返回值:return 结束函数的作用
def func3():
    i = 0
    while True:
        i += 1
        print(i,end=" ")
        if i == 10:
            print()
            return
print(func3())

# 定义一个求圆的面积和周长的函数，并且将面积和周长返回函数外
def circle(r):
    area = 3.14 * r**2
    perimeter = 2* 3.14 * r
    return area, perimeter
a, p = circle(10)
print(f"圆的周长是{p:.2f},面积是{a}")

# 返回一组数据
# 定义系统中的用户
users = {
    "damu": {"username": "damu", "password": "123", "gender": "male"},
    "tom": {"username": "tom", "password": "111", "gender": "male"},
    "xiaoli": {"username": "xiaoli", "password": "111", "gender": "female"},
    "jerry": {"username": "jerry", "password": "123", "gender": "female"}
}
def get_gender(gender):
    """按照性别筛选获取对应的用户"""
    user_list = list()  # 存储符合条件的用户
    for value in users.values():
        if value.get("gender") == gender:
            # 满足性别需求的用户
            user_list.append(value)
    return user_list
# 获取所有的男性用户
male = get_gender("male")
print("获取所有的男性用户：",male)

# 直接返回多个数据，类似变量的连续赋值
def test():
    """返回多个数据的测试函数"""
    print("运行代码")
    return "hello", 11, True
a, b, c = test()
print(a, b, c)


# 位置参数：实参传递的顺序按照形参定义的顺序进行传递的传参方式
def sum1(a, b):
    return a + b
print("位置参数调用：", sum1(10, 20))

# 关键字参数(函数调用时使用)：使用关键字方式调用
def sum2(num1, num2):
    return num1 + num2
print("关键字参数调用：", sum2(num1=10, num2=20))

def show_info(name, age, gender):
    print(f"姓名：{name}")
    print(f"年龄：{age}")
    print(f"性别：{gender}")
# 关键字参数：传值，让每个一个实际参数的意义更加明确
show_info(age=18, name="大牧", gender="male")  # 正确

# 展示用户资料，有时用户资料不完整，但是需要展示，可读性差
def show_info1(user):
    """查看个人资料"""
    for key, value in user.items():
        print(f"{key} : {value}")
    print("######资料查看完毕")
# 调用函数
show_info1({"name": "damu", "gender": "male", "age": 18})

# key描述具体数据value的作用，提高代码的可读性，解决了数据变化的问题
def show_info2(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}-->{value}")
    print("######资料查看完毕")
# 调用函数
show_info2(name="大牧", gender="男", age=18)

# 默认值参数
def sum3(a, b=100):
    print("参数a的值为:", a)
    print("参数b的值为:", b)
    return a + b
print("使用默认值参数，不传参：", sum3(90))
print("使用默认值参数，传新参：", sum3(90, 1))

# 默认值参数：列表
def lst1(b= ["a", "b", "c"]):
    # 返回值为参数b
    b.append("d")
    return b
print("默认值参数-列表：", lst1())

# 默认值参数：字典
def dct1(b={"age": "三十三", "name": "小黄花"}):
    # chr() 传入编码 给出对应的字符 65A-90Z
    code = random.randint(65, 90)
    b[chr(code)] = code
    return b
print("默认值参数-字典：", dct1())

# 可变元组参数
# 可变元祖参数 参数的个数是不确定的 0- N
def tuple1(*args):
    print(f"元组可变参数：{args}，参数类型：{type(args)}", end=" ")
    print(f"我叫{args[0]},今年{args[1]}岁，性别是{args[2]}")
print("传递元组参数：", end=" ")
tuple1(('小花', 18, '女'))
print("\n*打散元组参数序列：", end=" ")
tuple1(*('小花', 18, '女'))

# 可变字典参数
# key word arguments 关键字参数 可变的是参数个数 0-N
def dict1(**kwargs):
    print(f"字典可变参数：{kwargs}，参数类型：{type(kwargs)}", end=" ")
    print(f"我叫{kwargs['name']},今年{kwargs['age']}岁，性别是{kwargs[2]}")
print("\n传递字典参数：", end=" ")
dict1(name='小花', age=18, sex='女')
print("\n**打散字典参数数列，将字典中的键值对作为可变字典参数传入：", end=" ")
dict1(**dict(name='小花', age=18, sex='女'))

def func(a, b, c=20, *args, **kwargs):
    print(a, b, c)  # a=1 b=2 c=3
    print(args)  # (4,)
    print(kwargs)  # {name:zs,age:20}
func(1, 2, 3, 4, name='zs', age=20)

def func2(a, b, *args, c=20, **kwargs):
    print(a, b, c)  # a=1 b=2 c=20
    print(args)  # (3,4)
    print(kwargs)  # {name:zs,age:20}
func2(1, 2, 3, 4, name='zs', age=20)

# 打印函数的说明文档
def get_big(a, b):
    """获取两个数中较大的数"""
    if a > b:
        return a
    else:
        return b
print("输出函数的说明文档：",get_big.__doc__)

# 求两个数的最大公约数
def divisor1(a, b):
    # 代表a,b中的较小数 temp_num=104
    temp = b
    if a < b:
        temp = a
    for x in range(temp, 0, -1):
        if a % x == 0 and b % x == 0:
            return x
print(divisor1(3, 6))

# 求两个数的最大公约数
def divisor2(a, b):
    # 记录a数的所有约数
    list1 = []
    # 记录b数的所有约数
    list2 = []
    for i in range(1, a + 1):
        if a % i == 0:
            list1.append(i)
    print("a数的所有公约数：", list1)
    for j in range(1, b + 1):
        if b % j == 0:
            list2.append(j)
    print("b数的所有公约数：", list2)
    # 获取两个数的共有交集
    list3 = list(set(list1) & set(list2))
    return max(list3)
print(divisor2(6, 24))

# 求两个数的最小公倍数
def multiple1(a, b):  # 3, 7
    for x in range(1, a * b + 1):
        if x % a == 0 and x % b == 0:
            return x
print(multiple1(3, 6))

# 求两个数的最小公倍数
def multiple2(a, b):  # 3, 7
    temp_num = b  # step1: 找到a,b中较大数
    if a > b :
        temp_num = a
    for x in range(temp_num, a * b + 1):
        if x % a == 0 and x % b == 0:
            return x
print(multiple2(3, 7))

# 借助组合数据类型，查看学员资料
user1 = {"name": "tom", "age": 16}
user2 = {"name": "jerry", "age": 17}
user3 = {"name": "xinxin", "age": 18}
user4 = {"name": "yiming", "age": 20}
user5 = {"name": "dama", "age": 24}
user6 = {"name": "beita", "age": 26}

# 原语法：将所有用户存放于一个列表中
def check1(users):
    for user in users:
        # print(users)
        print(f"姓名：{user['name']}, 年龄：{user['age']}")
print("------原语法：不传参-------")
# 查看0个参数
check1([])
print("------原语法：传递1个参数-------")
# 查看1个参数
check1([user1])
print("------原语法：传递多个参数-------")
# 查看多个参数
check1([user1, user2, user3, user4, user5, user6])


# 新的语法：不确定个数~可变参数
def check2(*users):
    for u in users:
        # print(users)
        print(f"姓名：{u['name']}, 年龄：{u['age']}")
print("------新语法：不传参-------")
# 查看0个用户
check2()
print("------新语法：传递1个参数-------")
# 查看1个用户
check2(user1)
print("------新语法：传递多个参数-------")
# 查看多个用户
check2(user1, user2, user3, user4, user5, user6)

# 班级的学员签到情况，一直动态变化（统计签到：不确定需要接收多少个数据）
def students(*stu):
    """统计有多少学员签到"""
    print(f"已签到学员：{stu}")
    print(f"已签到数量：{len(stu)}")
    if len(stu) > 0:
        print(f"第一个签到的学员：{stu[0]}")
    print("----------------------------------")
# 将接收到的数据封装成数据有顺序的元组，通过编号/索引/下标，可以得到任意一个数据
students("tom", "jerry", "damu", "辉辉")

# 商城购物项目案例
# 定义保存商品的字典
goods_dict = {
    "1": {"gid": "1", "name": "利群", "price": 13.0, "stock": 20},
    "2": {"gid": "2", "name": "帝豪", "price": 10.0, "stock": 30},
}
# 展示购物超市菜单-views0.py
def show_shopping():
    print("商品编号\t商品名称\t商品价格\t商品库存")
    for key, value in goods_dict.items():
        print(f"{key}\t{value.get('name')}\t{value.get('price')}\t{value.get('stock')}")
    # 获取到用户购买的商品
    no = input("请输入您要购买的商品编号:")
    goods = goods_dict.get(no)
    # 开始购买商品
    res = shopping(goods)  # "show_ticket(购买数据)"
    if res != None:  # 加判断为了保障~某些方法如果没有返回值，这里会报错
        return eval(res)  # eval("show_ticket(购买数据)")  # 将字符串转换成表达式执行
# 商品购买流程-英雄联盟-世纪之战.py
def shopping(goods):
    # 提示输入购买数量
    print(f"您要购买的商品是：{goods.get('name')}")
    count = input("请输入您要购买的商品数量：")
    return shop_pay(goods, count)
# 付款-英雄联盟-世纪之战.py
def shop_pay(goods, count):
    # 提示付款
    pay = goods.get('price') * int(count)
    print(f"-------你购买的商品是{goods.get('name')}")
    print(f"-------你需要付款：{pay}")
    money = input("请输入您的付款金额：")
    money = int(money)
    if money < pay:
        input("您的付款金额不足，请重新付款")
        return shop_pay(goods, count)
    # 购买完成，打印小票【菜单】
    input("购买完成，按任意键打印小票")
    # 返回给views.py模块字符串结果："show_ticket(商品, 1, 20)"
    #            views.py模块中：执行返回的结果： eval(res)  res="show_ticket(商品, 1, 20)"
    return f"show_ticket({goods}, {count}, {money})"
# 展示小票-views0.py
def show_ticket(goods, count, money):
    """打印小票"""
    print("用户购物小票")
    print("~~~~~~~~~~~~~~~~~~~~~~~~~~")
    print(f"购买商品：{goods.get('name')}")
    print(f"商品单价：{goods.get('price')}")
    print(f"购买数量：{count}")
    print(f"应付金额：{goods.get('price') * count}")
    print(f"实际付款：{money}")
    print(f"找零：{money - (goods.get('price') * count)}")
    print("~~~~~~~~~~~~~~~~~~~~~~~~~~")
    return input("购物完成.")
# 程序启动
show_shopping()