一，复习
# 什么是函数：具体特定功能的代码块 - 特定功能代码块作为一个整体，并给该整体命名，就是函数
# 函数的优点：
# 1.减少代码的冗余
# 2.结构清晰，可读性强
# 3.具有复用性，开发效率高，维护成本低
# 如何定义一个函数：用def关键词来声明函数
'''
def fn(参数列表):
函数体
return 函数的返回值
'''
# -- 定义函数时，函数体不会被执行 | 函数必须先定义后使用
# 函数的四部分：
# 函数名：存放着函数的地址，是调用函数的依据
# 函数体：解决问题的代码块
# 参数列表：外界为内部提供数据的途径 - 内部需要外部的数据，就需要定义参数列表
# 返回值：将内部的结果返回给外部
# 函数的使用
# 1.通过函数名找到函数的地址
# 2.函数名() 来调用执行函数
# 3.得到函数执行的结果 - 返回值
def add(n1, n2):
return n1 + n2
add(10, 20) # 只执行的函数体
res = add(10, 20) # 执行的函数体，并拿到函数的执行结果
print(add(10, 20) + 100) # 执行的函数体，并拿到函数的执行结果，再使用
# 函数的分类
# 有无函数体：空函数 - pass填充 | 非空函数 - 有函数体
# 有无参数：
#无参函数 - 内部不需要外部数据
#有参函数 - 内部需要外部数据
# 有无返回值：
#不主动明确返回值的函数 - 系统主动在函数体末尾添加return
#主动明确返回值的函数 - 按需求明确return
# 函数的返回值
# 没有return关键字的函数：不关系函数的返回值，但函数的返回值为None
# 有空return：不关系函数的返回值，但在特定条件下要主动结束函数，空return，函数的返回值为None
# return一个值：外界就可以接收到返回的一个值
# return多个值：外界用一个值接收，接收到的是元组 | 外界用多个值接收，接收的个数与返回的个数一定要统一(本质采用解压赋值)
# return的作用：1.结束函数 2.携带内部参数给外部
二，今日内容
# 函数的参数： ****
# 函数对象 - 函数名：*****
# 函数的嵌套调用：***
三，形参与实参
# 参数介绍：
# 函数为什么要有参数：因为内部的函数体需要外部的数据
# 怎么定义函数的参数：在定义函数阶段，函数名后面()中来定义函数的参数
# 怎么使用函数的参数：在函数体中用定义的参数名直接使用
# 实参：有实际意义的参数
# -- 在函数调用的时候，()中传入的参数
# 形参：参数本身没有意义，有实参赋予形参值后，该形参就具备了意义
# 补充：有默认值的形参，在没有被实参赋值，具备的是自身意义，但一旦被实参赋值，意义同实参 - def add(n1, n2=2):
# -- 在定义函数的时候，()中出现的参数
# 形参范畴
def add(n1, n2): # 形参n1，n2在没有被实参赋值时，没有实际意义，被什么意义的实参赋值，就被赋予了什么意义
return n1 + n2
# 实参范畴
print(add('a', 'b')) # 实际的字符串
print(add(10, 20)) # 实际的数字
a = 200
b = 300
print(add(a, b)) # 存放实际数字的变量
四，形参是对实参的值拷贝
# 形参与实参可以重名，但是代表的是两个不同的变量
# 不可变类型，形参发生重指向，实参不变
def fn(num):
print('1>>>:', num) # 10
num = 20
print('2>>>:', num) # 20
num = 10
fn(num)
print('3>>>:', num) # 10
# 可变类型，形参发生值的内部变化，实参变，两个指向的是同一个地址
def func(ls):
print('1>>>:', ls) # [10]
ls.append(20)
print('2>>>:', ls) # [10, 20]
ls = [10]
func(ls)
print('3>>>:', ls) # [10, 20]
五，实参的分类
# 实参分为：1.位置实参 2.关键字实参
def fn(a, b):
print(a, b)
# 1）拿实际值进行传参
fn(10, 20) # 10 => a | 20 => b
# 2）拿位置实参进行传参：形参与实参进行位置一一对应，eg:1号位的实参一定传给1号位的形参
a = 100
b = 200
fn(a, b) # a:100 => a | b:200 => b
fn(b, a) # b:200 => a | a:100 => b
# 3）拿关键字实参进行传参：指名道姓进行传参 - 传参的过程过指名道姓形参
# 明确：形参名目前为a和b
fn(a=1000, b=2000) # a:1000 => a | b:2000 => b
fn(b=2000, a=1000) # b:2000 => b | a:1000 => a
a = 666
b = 888
# 前面的是形参名，后面的是传递的实参名
fn(a=a, b=b) # a:666 => a | b:888 => b
# 位置实参：一定按照位置，且个数要一一对应进行传参
# 关键字实参：指名道姓进行传参，个数一致位置可以改变进行传参
# 实参组合传参规则：必须先传位置实参，再传关键字实参
六， 形参的分类
# 六大分类：
# 1.无值位置形参(位置形参)：可以被位置与关键字实参进行传参，必须传值
# 2.有值位置形参(默认形参)：可以被位置与关键字实参进行传参，可以不用传参采用默认值
# 3.可变长位置形参（*args）：可以接受前两个没有接收完位置实参，接收的个数可以为0~n个，0个是就是空元组
# 4.无值关键字形参（c）：只能由关键字实参进行传参，必须传值
# 5.有值关键字形参（d = 10）：只能由关键字实参进行传参，可以不用传参采用默认值
# 6.可变长关键字形参（**kwargs）：接收4，5没有接收完的关键字实参，接收的个数可以为0~n个，0个是就是空字典
# 声明顺序：
# 位置形参:a -> 默认形参:b -> 可变长位置形参:args -> 有无默认值关键字形参:cde -> 可变长关键字形参:kwargs
def fn(a, b=10, *args, c, d=20, e, **kwargs): pass
# 注意点：
# 1.可变长位置形参只能接受位置实参，要想被赋上值，前面的有值位置形参的默认值没有多大意义
# 2.args与kwargs是可变长形参的变量名，所以可以自定义，但约定俗成就用它俩
# 位置形参一定遵循：无值在前，有值在后
# 关键字形参顺序可以任意
# 常出现的组合
def f1(*args, **kwargs): pass
def f2(a, b=10, **kwargs): pass
def f3(a, *args, **kwargs): pass
def f4(a, *, x, **kwargs): pass
def f5(a, *args, x, **kwargs): pass
# 使用法则：
# 1.所有位置形参全部采用位置实参进行传值
# 2.所有关键字形参全部采用关键字实参进行传值
# 3.不管位置还是关键字形参，全部按照顺序进行传参
七，打散机制
def fn(*args, **kwargs):
print(args)
print(kwargs)
t = (1, 2, 3)
dic = {'a': 100, 'b': 200, 'c': 300}
# *单列容器 会打散单列容器（字符串，列表，元组，集合）
# **双列容器 会打散双列容器（字典）
fn(1, 2, 3, a=100, b=200, c=300) # (1, 2, 3) {'a': 100, 'b': 200, 'c': 300}
fn(*t, **dic) # (1, 2, 3) {'a': 100, 'b': 200, 'c': 300}
fn(*(1, 2, 3), **{'a': 100, 'b': 200, 'c': 300}) # (1, 2, 3) {'a': 100, 'b': 200, 'c': 300}
# 字符串也可以被打散
fn(*'abc') # ('a', 'b', 'c') {}
print(*'abc') # a b c
八，函数的嵌套调用
# 函数的嵌套调用：在一个被调用的函数内部调用另一个函数
# -- 复用之前已定义好的函数功能 - 功能有重叠
def a():
b()
def b():
pass
a() # a的调用必须在b的声明之后，原因a中要使用b
# 注意：在提前声明的函数中可以嵌套调用之后声明的函数，
# 但是本函数的调用必须在嵌套被调用的函数声明之后
# 应用场景
# 求两个数的大者
def max_two(a, b):
if a > b:
return a
return b
print(max_two(100, 20))
# 求三个数的大者
# def max_three(a, b, c):
# # if b < a > c:
# # return a
# # if a < b > c:
# # return b
# # if a < c > b:
# # return c
def max_three(a, b, c):
max_num = max_two(a, b)
return max_two(max_num, c)
# print(max_three(20, 10, 5))
# 求四个数的大者
def max_four(a, b, c, d):
max_num = max_three(a, b, c)
return max_two(max_num, d)
