08函数

"""
小结:
函数:
print(),input(),len(),max(),min(),str(),list(),
tuple(),dict(),set(),frozenset()
系统内部定义好的函数
for while True False in not in is is not
用户定义的函数，函数名()
"""
"""
函数是提前组织好的，完成一个任务的特定的代码块。
定义格式:
def 函数名 (形参):形式参数
    "函数的说明文档
    代码块
    return 表达式
函数体最好与上下文各空两行
函数要先定义后调用，一般定义写在文件的最上方
函数名，要符合标识符的命名规则
函数调用，函数名(实参)实际参数
定义完之后没有任何执行
"""

# def add_1(a, b):  # 函数的定义
#     """用于求两个数的和"""
#     c = a + b
#     print(c)
#     return c  # 函数的返回值


# result = add_1(10, 20)  # 函数的调用，10 20 实参，分别赋值给a和b结果返回赋值给result
# print(result)
# # 计算0-100之间的整数和
# result = 0
# for i in range(0, 101):
#     result += i
# print(result)
# # 调用函数，实现0-10之间的整数和
# result = 0
# # add_1(0)  # TypeError: add_1() missing 1 required positional argument: 'b'
# print(help(add_1))  # 查看自己定义的函数的功能,说明文档


# def add2num(a, b):
#     c = a + b
#     print(c)


# add2num(11, 22)

"""
函数的参数:
1.位置参数:通过参数定义和调用的位置来确定的参数
2.关键字参数:函数在调用传入实参时，使用原来的  形参名=值  这种形式来调用函数并传参
  要在位置参数的后面,调用函数时。可以跟原来的函数定义时的形参顺序不一样
3.默认值参数:函数在定义时，已经提前给形参赋值了默认(default)值,在调用函数传参时，如果默认值
  参数没有被传值，就使用原来的默认值，如果传了值就是用新的值，要跟在位置参数的后面，定义函数时
4.不定长参数:
"""

# 如果(a=20，b，c)把默认参数写在了位置参数的后边，就会报如下错误:
# SyntaxError:non-default argument follow default argument
# def fun_1(a, b, c=80):  # a,b,c都是位置参数，c是默认值参数，c要跟在a,b的后边
#     return a, b, c


# print(fun_1(10, 20, 30))  # 位置参数
# # 10位置参数，c=30，b=20关键字参数,关键字参数必须跟在后边，否则就报错
# print(fun_1(10, c=30, b=20))  # 位置参数与关键字参数混用
# # SyntaxError: positional argument follows keyword argument
# # print(fun_1(c=30,b=20,10))
# print(fun_1(10, b=20))  # c没有被传值，就使用默认值80


# def add3num(a, b, c=100):  # a，b是位置参数；c=100默认值参数
#     print(a)
#     print(b)
#     print(c)
#     return a+b+c
#
#
# result = add3num(a=30, b=50, c=200)  # 30位置参数；b=50，c=200  关键字参数调用时
# print(result)


"""
函数参数的第四种类型:不定长参数，将形参包裹
语法格式:del fun_1([formal_a],*args,**kwargs)
1.formal_a   普通参数
2.*args  元组的形式来接收多余的普通的实参(不是关键字实参，直接写实参)
3.**kwargs字典的形式来接收多余的关键字参数(m=10,n=20)
注意，**kwargs要跟在*args后边，*args要跟在普通参数的后边
"""

"""
传实参时，可以解包裹，*args，**kwargs
*args 用于直接将元组中的元素传给形参
**kwargs 用于直接将字典中的键值对传给形参
与上边的打包裹是两个独立的过程
"""

# def fun_1(a, b, *args, **kwargs):
#     print(a)
#     print(b)
#     print(args)
#     print(kwargs)


# fun_1(10, 20)  # 10传给a，b传给20
# fun_1(10, 20, 30, 40, 50)  # 10传给a，b传给20；30；40,50全部传给args，args以元组的形式来保存这三个实参
# fun_1(10, 20, 30, 40, 50)
# # 10-a,b-20;30;40;50全部传给args,aegs以元组形式来保存这三个实参
# # m=60,n=70,x=80,y=90关键字参数会赋值给kwargs，kwargs以字典的形式来保存数据
# fun_1(10, 20, 30, 40, 50, m=60, n=70, x=80, y=90)
# def fun_1(a, b, c):  # 三个普通的位置参数
#     print(a)
#     print(b)
#     print(c)


# args = (1, 2, 3)
# # TypeError: fun_1() missing 2 required positional arguments: 'b' and 'c'
# # fun_1(args)  # 解包裹，将元组中的三个包裹分别传给a，b，c
# fun_1(*args)
# kwargs = {"a": 10, "b": 20, "c": 30}
# # ypeError: fun_1() missing 2 required positional arguments: 'b' and 'c'
# # fun_1(kwargs)
# fun_1(**kwargs)

"""
混合使用的基本原则如下:
(1)先位置参数传递。
(2)再关键字参数传递。
(3)再可变参数传递。 *args  **args
"""

"""
函数的返回值:
1.无return，返回None
2.return a  ,返回一个值，返回值的数据类型就是后边那个值的类型
3.return a,b,c,返回值大于1，返回值就是元组，元组的形式来保存这些值
"""

# def fun_1():
#     print("hello world!")
# # hello world!
#
# result = fun_1()
# print(result)
# print(type(result))
# # None
# # <class 'NoneType'>
#
#
# def fun_2(a, b):
#     c = a + b
#     return c
#
#
# result_1 = fun_2(10, 100)
# print(result_1)
# print(type(result_1))
# # 110
# # <class 'int'>
#
#
# def fun_3(a, b, c):
#     return a, b, c
#
#
# result_2 = fun_3(100, 200, 300)
# print(result_2)
# print(type(result_2))
# # (100, 200, 300)
# # <class 'tuple'>

"""
函数定义时的四种类型
1.无参数，无返回值
2.有参数，无返回值
3.无参数，有返回值
4.有参数，有返回值
"""

# 1.无参数，无返回值，经常用于显示菜单
# def print_menu():
#     print("---1907c火锅城点菜系统  v8.8---")
#     print("1.清汤火锅")
#     print("2.麻辣火锅")
#     print("3.鸳鸯火锅")
#     print("4.咖喱火锅")
#     print("5.蔬菜火锅")
#     print("-----请点菜-----")
#
#
# while True:
#     print_menu()
#     choice = input("请输入您的选择")
#     if choice in ["1", "2", "3", "4", "5"]:
#         print("您选择了%s号火锅，请稍等，马上上菜" % choice)
#         break
#     else:
#         print("选择错误，请重新输入")
#
#
# 2.有参数，无返回值
# def fun_1(a, b):
#     print(a)
#     print(b)
#
#
# fun_1(35, 78)


# 3.无参数，有返回值
# def fun_1():
#     return "欢迎光临本店"
#
#
# result = fun_1()
# print(result, "环境优雅，整洁")


# 4.有参数，有返回值，频繁使用
# def fun_1(a, b, c):
#     d = (a + b) * c
#     return d
#
#
# result = fun_1    # 函数名可以赋值给另一个变量
# aaa = result(10, 20, 30)  # 通过调用另一个变量，变成函数的调用
# print(aaa)


"""
函数的嵌套调用:函数中在调用别的函数，函数中在调用自己
"""

# def test_B():
#     print("test_B开始执行")
#
#
# def test_A():
#     print("test_A开始执行")
#     test_B()
#     print("test_A执行结束")
#
#
# test_A()  # 函数调用
"""
变量的作用域:
1.局部变量，作用域:函数内部。定义在函数内的变量，只在函数内部起作用
2.全局变量，作用域:全局。定义在函数外的，文件中的变量，可以在文件的任意位置使用，包括函数内
"""
"""
两个关键字:
1.global  a   :用于在函数中指明使用全局变量a
2.nonlocal b  :???

"""

# def fun_1(b, c):
#     global result  # 声明当前的result变量用的是全局变量result
#     # a也是全局变量，但是在函数中只是被调用没有被修改值，所以不适用global进行声明
#     result = a + b + c  # a是全部变量的a;b,c是局部变量;result是局部变量
#     # 为什么result是局部变量，a是全局变量
#     # a是直接拿来用，没有重新赋值，result在这里被重新赋值，则变为另一个变量
#     print("函数内的result变量值为%d" % result)
#
#
# a = 100  # 全局变量
# result = 50  # result，全局变量
# fun_1(200, 300)
# print("全局变量result的值为%d" % result)
# # 运行结果:
# # 函数内的result变量值为600
# # 全局变量result的值为50
# # 当我们在fun_1()函数体中，声明了 global result ,结果发生了变化
# # 函数内的result变量值为600
# # 全局变量result的值为600

"""
匿名函数，没有名称的函数，只能完成简单的任务
lambda  a,b,c,...:expression
使用lambda 关键字来声明，参数数量不限，但是只能跟一个表达式，表达式的结果就是函数的返回值
匿名函数可以当做另一个函数的参数进行传递。
匿名函数可以作为内置函数的参数来使用。比如  列表排序sort(key=lambda x:x['name'])
"""
# a = lambda x, y: x+y
# print(a(10, 20))


# sum_1 = lambda a, b: a+b
# print(sum_1(10, 20))
# print(sum_1(100, 200))
# # 30
# # 300
#
# sum_2 = lambda x, y, z: x+y+z
# print(sum_2(10, 20, 30))
# print(sum_2(100, 200, 300))
# # 60
# # 600

# # 能计算两个数不同的算数运算的函数
# def fun_1(a, b, c):  # a=10,b=20,c=lambda x,y:x+y
#     print("a=", a)
#     print("b=", b)
#     print("result=", c(a, b))  # c(10, 20)
#
#
# fun_1(10, 20, lambda x, y: x + y)
# fun_1(10, 20, lambda x, y: x - y)
# fun_1(10, 20, lambda x, y: x * y)
# fun_1(10, 20, lambda x, y: x / y)
# # a= 10
# # b= 20
# # result= 30
# # a= 10
# # b= 20
# # result= -10
# # a= 10
# # b= 20
# # result= 200
# # a= 10
# # b= 20
# # result= 0.5

# list_1 = [{"name": "a", "age": 18}, {"name": "b", "age": 19},
#           {"name": "c", "age": 17}]
# # # TypeError: '<' not supported between instances of 'dict' and 'dict'
# # list_1.sort()
# # 对列表中的数据按照年龄大小进行排序
# list_1.sort(key=lambda x: x['age'])
# print(list_1)
# # [{'name': 'c', 'age': 17}, {'name': 'a', 'age': 18}, {'name': 'b', 'age': 19}]
# # 对列表中的数据按照姓名进行排序。
# list_1.sort(key=lambda x: x['name'])
# print(list_1)
# # {'name': 'a', 'age': 18}, {'name': 'b', 'age': 19}, {'name': 'c', 'age': 17}]

"""
随机数函数，引入随机数模块，引入后使用其中的随机函数
import random  # 写在文件最上方，只需引入一次
1.random.random()  # 随机生成0-1之间的浮点数
2.random.randint(a, b)  # 随机生成大于等于a，小于等于b，之间的整数
"""
# import random

# print(random.random())  # 随机生成0-1之间的浮点数
# print(random.randint(0, 2))  # 随机生成大于等于0且小于等于2之间的整数

# 使用随机数函数，写猜拳游戏0,1,2分别代表石头剪刀布
# # while True:
# #     get_1 = int(input("请出拳:(0代表布，1代表剪刀，2代表石头)"))
# #     get_2 = random.randint(0, 2)  # 随机生成大于等于0且小于等于2之间的整数
# #     if (get_1 == 0 and get_2 == 2) or(get_1 == 1 and get_2 == 0) or 
# #         (get_1 == 2 and get_2 == 1):
# #         print("电脑出拳是%d,你出的拳是%d，你赢了" % (get_2, get_1))
# #         break
# #     elif get_1 == get_2:
# #         print("平局，请来")
# #     else:
# #         print("电脑出的拳是%d,你出的拳是%d,你输了" % (get_2, get_1))
# 题库。


# def func(a1, b1):
#     global a  # 声明此处变量a为全局变量
#     a = a1 + b1
#     print("c =", c)
#     a += c
#     return a  # a=40
#
#
# a = 10
# b = 20
# c = 30
# b = func(a, b)  # 调用func函数，把ab的值作为实参传递，函数的返回值被b接收
# print(a, b)

"""
python创建变量，变量名=值
全局变量，定义在文件中，函数外的变量，可以再文化的任意地方使用
如果要修改这个全局变量的值，就需要使用global关键字进行声明
"""