从函数到可变长参数

函数

函数--》工具（需要用的时候才用，题乾造好）：
需要函数的时候，拿来用就行了，题乾写/复制粘贴
造螺丝刀

函数的定义

函数定义的特性：函数定义过程只检测语法，不执行代码
调用阶段会执行代码

函数--》工具

使用工具之前-》必须得造一个工具--》定义函数
'''
def 函数名（等同于变量名）
"""对函数（工具）的描述信息"""
pass

'''

def guesses():
    x = input('输入x')
    y = input('输入y')
    if x > y:
        print(x)
    else:
        print(y)
    """给定两个数字，打印较大的"""

# 函数定义的特性：函数定义过程只检测语法，不执行代码
#调用阶段会执行代码

print(guesses().__doc__)
print(len.__doc__)
s = 'abc'
print(s.startswith.__doc__)

03定义函数的三种形式

空函数

有参函数

无参函数

#空函数
def func():
    pass
def register():
    pass


# 有参函数
def guesses(x,y):

    if x > y:
        print(x)
    else:
        print(y)
    """给定两个数字，打印较大的"""
guesses(50,30)

# 无参函数
def guesses2():
    x = 50#input('输入x')
    y = 30#input('输入y')
    if x > y:
        print(x)
    else:
        print(y)
    """给定两个数字，打印较大的"""

函数的调用

直接看例子吧

def guesses():
    x =50 #input('输入x')
    y =30 #input('输入y')
    if x > y:
        print(x)
    else:
        print(y)
    """给定两个数字，打印较大的"""

print(guesses)#函数的地址<function guesses at 0x0000022DCA354828>
guesses()#没有为什么，加括号就能调用（执行内存中的代码）

函数的返回值

1.return返回一个返回值
2.没有return默认返回值
3.return会终止函数，不运行下面的代码，假设又多个return，运行到第一个就会结束，不i会运行下一个
4.return可以返回多个值，返回的值以元组接受

函数的参数

默认形参： 1. 如果你不给，使用默认值；如果调用的时候传值，使用传的值 2. 默认形参必须得放在位置形参后面

# xianshiping(1)

# xianshiping(1, 300)

实参：调用阶段的产物，传给形参一个具体的值，具有具体的值（可以为所有数据类型）

位置实参：从左到右依次给位置形参传值，一一对应，形参有多少个，实参也必须有多少个

# xianshiping(1, 300)  # 有参数，就必须得传参  # 实参
# xianshiping(1, 300)  # 有参数，就必须得传参  # 实参
# xianshiping(1, 300)  # 有参数，就必须得传参  # 实参
# xianshiping(1, 300)  # 有参数，就必须得传参  # 实参
# xianshiping(1, 300)  # 有参数，就必须得传参  # 实参
# xianshiping(1, 300)  # 有参数，就必须得传参  # 实参
# xianshiping(1, 1000)  # 有参数，就必须得传参  # 实参

关键字实参: 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. 关键字实参必须得放在位置实参的后面

# 可变长形参
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)