1.函数引入
函数--》 工具（需要的时候才用，提前造好）
函数不会改变某一个功能的代码。它只做了一件事情-->封装（接口），只会让你的代码更加简洁而已
2.函数的定义
def 函数名 (等同于变量名) ():
"""对函数的描述信息"""
代码块
def guess():
"""给定两个数，打印较大的数"""
x = 30
y = 20
if x > y
print(x)
else:
print(y)
print(guess.__doc__)
print(len.__doc__)
s = 'abc'
print(s.startswith.__doc__)
函数定义的特性：函数定义的过程，只检测语法，不执行代码
def func()
print(x)
func() # 调用阶段，会执行代码
3.定义函数的三种方式
空函数
def func():
pass
def register():
pass
def login():
pass
def shopping():
pass
有参函数
def guess1(x,y):
"""给定两个数，打印较大的数"""
if x > y:
print(x)
else:
print(y)
guess1(50,20)
无参函数
def guess2():
"""给定两个数，打印较大的数"""
x = 30
y = 20
if x > y:
print(x)
else:
print(y)
4.函数的调用
def guess1():
"""给定两个数，打印较大的数"""
x = 20
y = 30
if x > y:
print(x)
else:
print(y)
# 函数的调用
print(guess1) # 函数的地址
guess1() # 没有为什么，加括号就能调用(执行内存中的代码)
5.函数的返回值
返回值：返回一个值（所有数据类型）
def guess1():
"""给定两个数，打印较大的数"""
# return
# print(1)
x = 20
y = 30
if x > y:
# print(x)
return x
else:
# print(y)
return y
num = guess1() # num = 30
print('num:',num)
z = 2
# 获取最大值，乘以z
print(z * num)
lt = [num]
return的特性：
- return返回一个返回值，如果没有返回值，则返回None
- 没有return 默认返回None
- return会种植函数，不运行下面的代码，假设有多个return的时候，运行到第一个就会结束，不会运行第二个
- return通过逗号隔开，可以返回多个值，返回值以元组的行式被接受
6.函数的参数
有参函数：有参数（手电筒/弱光，强弱你自己调控的）的函数
使用时，你告诉手电筒，他是强光还是弱光
后面规定是参数的数据类型，约定俗成的；后面规定的是返回值的数据类型，约定俗成的
def xiaoshiping(liangdu:int,duibidu:int) ->int: #形参
"""给定两个数，打印较大的数"""
if liangdu == 0:
print('黑屏')
return 0
if duibidu > 300:
print('高清无码')
else:
print('av画质')
xianshiping(1, 1000) # 有参数，就必须得传参 # 实参
形参：定义函数阶段的产物，具有接受实参的作用，具有描述意义
位置形参：从左到右依次接受实参的值
def xianshiping(liangdu: int, duibidu: int = 150) -> int: # 形参
"""给定两个数，打印较大的数"""
if liangdu == 0:
print('黑屏')
return 0
if duibidu > 299:
print('高清无码')
else:
print('av画质')
默认形参： 1. 如果你不给，使用默认值；如果调用的时候传值，使用传的值 2. 默认形参必须得放在位置形参后面
xianshiping(1)
xianshiping(1, 300)
实参：调用阶段的产物，传给形参一个具体的值，具有具体的值（可以为所有数据类型）
位置实参：从左到右依次给位置形参传值，一一对应，形参有多少个，实参也必须有多少个
xianshiping(1, 300) # 有参数，就必须得传参 # 实参
xianshiping(1, 300) # 有参数，就必须得传参 # 实参
xianshiping(1, 300) # 有参数，就必须得传参 # 实参
关键字实参: 1.位置实参必须写在关键字实参的前面 2.按照形参名给形参传值（使用情况，基本为0）---》函数的参数一般0-3个，尽量不要超过3个
def xianshiping(duibidu, liangdu, resolution_ratio, length, width): # 形参
"""给定两个数，打印较大的数"""
print(liangdu, duibidu, resolution_ratio, length, width)
xianshiping(1, 2, 3, 4, 5)
xianshiping(5, liangdu=1, resolution_ratio=2, length=3, width=4)
位置形参：从左到右依次接收实参的值
位置实参：从左到右依次传值给形参
默认形参： 1. 有默认值，如果调用传参了，使用传的值；没有传参，使用默认值 2. 默认形参必须得放在位置形参后面
关键字实参：1. 按照形参名传参 2. 关键字实参必须得放在位置实参的后面
7.可变长参数
可变长形参
def min_2(x, y):
if x > y:
return y
else:
return x
def min_4(a, b, c, d):
res1 = min_2(a, b)
res2 = min_2(c, d)
return min_2(res1, res2)
def min_8(a, b, c, d, e, f, g, h):
res1 = min_4(a, b, c, d)
res2 = min_4(e, f, g, h)
return min_2(res1, res2)
def min_10(a, b, c, *lt): # *lt，把所有传过来的实参全部接收，并且以元组的形式存储
print(lt)
a, b, c, d, e, f, g, h, i, j, *_ = lt
print(_)
res1 = min_8(a, b, c, d, e, f, g, h)
res2 = min_2(i, j)
return min_2(res1, res2)
res = min_10(1, 2, 3, 4, 5, 6, 7, -1, 9, 10, 11, 12, 13, 1, 1, 1, 1, 1, 1, 1, 11,
1, ) # *,相当于做了解压缩，也就是把lt内的元素一个一个取出来传给形参
print(res)
# 可变长实参
def min_2(x, y):
if x > y:
return y
else:
return x
def min_4(a, b, c, d):
res1 = min_2(a, b)
res2 = min_2(c, d)
return min_2(res1, res2)
def min_8(a, b, c, d, e, f, g, h):
res1 = min_4(a, b, c, d)
res2 = min_4(e, f, g, h)
return min_2(res1, res2)
def min_10(a, b, c, d, e, f, g, h, i, j):
print(a, b, c, d, e, f, g, h, i, j)
res1 = min_8(a, b, c, d, e, f, g, h)
res2 = min_2(i, j)
return min_2(res1, res2)
lt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
res = min_10(*lt) # *,相当于做了解压缩，也就是把lt内的元素一个一个取出来传给形参
# print(res)