renturn 多返回值

按照返回值的顺序，写对应的多个变量，多个变量之间用逗号隔开，本质返回的是一个元组

# 多返回值
def find_max(lst):
    """

    :param lst: 数据列表
    :return: 最大值和最小值
    """
    v_max = max(lst)
    v_min = min(lst)
    return v_min, v_max  # 返回的是元组


list = [1, 2, 3, 4, 56]
result = find_max(list)
print(result[0])
print(result[1])
# 将返回的第一个给第一个变量,第二个给第二个变量
r_min, r_max = find_max(list)
print(f"最小值{r_min},最大值{r_max}")

# # 练习
# #计算列表的平均值和求和并返回
list = [1, 2, 3, 4, 5, 6]


def find_avg_sum(lst):
    """

    :param lst: 整数列
    :return: 求和和平均值
    """
    v_sum = sum(lst)
    v_avg = v_sum / len(lst)
    return v_sum, v_avg


s_sum, s_avg = find_avg_sum(list)
print(f"和:{s_sum},平均值:{s_avg}")

位置参数和关键字参数

调用函数时根据函数定义的参数位置来传递参数，传递的参数和定义的参数的顺序和个数必须一致，

关键字参数函数调用时通过“键=值，形成传递参数”

函数调用时，位置参数要在关键字参数前面

# 位置参数和关键字参数

def user(name, age, gender="男"):
    print(f"姓名:{name} 年龄:{age} 性别:{gender}")


# 位置参数
user("zjj", 11, "男")
# 关键字参数
user(name="zjj", gender="女", age=13)
# 位置和关键字参数混用但位置参数要在关键字参数前面
user("z1jj", gender="女", age=13)
# 默认值参数
user("zawdj", age=18)

练习

def main_max(x,y,z=100):
    """

    :param x: 参数一
    :param y: 参数二
    :param z: 参数三默认值是100
    :return: 返回最大值
    """
    num_max=0
    if x>num_max:
        num_max=x
    if y>num_max:
        num_max=y
    if z>num_max:
        num_max=z
    return num_max

main_max(x=10,y=20)
print(main_max(10,20))
s=main_max(10,z=20,y=50)
print(s)

缺省参数

这个这个函数的形式参数一个默认值，如果调用这个函数的时候没有给这个参数数值的话，就会使用默认值来展示出来，默认值参数要在没有默认值的右边

def user(name, age, gender="男"):
    print(f"姓名:{name} 年龄:{age} 性别:{gender}")


# 位置参数
user("zjj", 11, "男")
# 关键字参数
user(name="zjj", gender="女", age=13)
# 位置和关键字参数混用但位置参数要在关键字参数前面
user("z1jj", gender="女", age=13)
# 默认值参数
user("zawdj", age=18)

不定长参数

位置传递（元组接受----位置传递 ，一个*号）

可变参数，用于不确定调用会传递多少个参数（不传参）也可以实现的场景看，将传入的参数全部收集 在一个元组中

位置传递（*args）:如果不定长参数在参数列表前。后续参数要使用关键字参数

位置不定长参数

def user_info(*args):
    for i in args:
        print("参数是",i)
    print(args)


user_info('python','python','python')
user_info(1)  # 参数有这些(1,)



def user(name, age, gender="男",*args):
    print(f"姓名:{name} 年龄:{age} 性别:{gender}")
    for i in args:
        print(i)

user("al=jj",11,"男",11231223123)


def user(*args,name, age, gender="男"):
    print(f"姓名:{name} 年龄:{age} 性别:{gender}")
    for i in args:
        print(i)

user("al=jj",name="123",age=11)

def student (*args,name,age,height):
    """

    :param name: 姓名
    :param age: 年龄
    :param height: 身高
    :param args: 幸运数字
    :return: 无
    """
    print(f"我是{name},今年{age}岁,身高{height}cm")
    print(f"我的幸运数字有:",end=" ")
    for i in args:
        print(i,end=" ")

student(1,2,3,name="aaa",age=11,height=123)

关键字传递（字典接收----关键字传递，两个*号）

**关键字传递，只能写在参数列表的最后面，传入的内容是（键=值）

# 关键字参数  **kwargs只能写在最后面
def user(**kwargs):
    print(kwargs)
    print(type(kwargs))

user(a=1,b=2,c=3)


def user(**kwargs):
    for k in kwargs:
        print(f"{k}:{kwargs[k]}")

user(a=1,b=2,c=3)

def user(name,age,**kwargs):
    print(f"{name} {age}")
    print("我的其他信息")
    for k in kwargs:
        print(f"{k}:{kwargs[k]}")

user(name=123,age=11,a=1,b=2,c=3)

练习

def xinxi(name,age,gender,*args,**kwargs):
    print(f"我是{name}今年{age}岁性别{gender}")
    print(f"我的幸运数字是:{args}")
    print("我的其他信息如下:")
    for k in kwargs:
        print(f"{k}:{kwargs[k]}")

xinxi("yaaa",11,"男",1,2,3,4,5,habby="chi",a=1,b=2)

匿名函数

把函数作为参数传递--->将函数作为实际参数去传递/把一个函数当作一个参数传入另一个函数中

传输的是计算逻辑

# 函数作为参数传递

def func_a(f):
    result=f(3,2)
    return result

def add(x,y):
    return x+y
def sub(x,y):
    return x-y
def mul(x,y):
    return x*y
def div(x,y):
    return x/y
print(func_a(add))
print(func_a(sub))
print(func_a(mul))
print(func_a(div))

对于元组：

sorted（变量名，key=函数方法，[revalse=True]）默认使用的是升序排列，为True时为降序排列

# key关键字,决定排序依据
def my_soty(x):
    return x[1]


lst = (("a", 99), ("b", 88), ("c", 66))

print(sorted(lst, key=my_soty))  # 默认是升序
print(sorted(lst, key=my_soty, reverse=True))  # 是降序1

t=((1,"a", 99), (2,"b", 88), (3,"c", 66))

def my_soty2(x):
    return x[2]
print(sorted(t, key=my_soty2))

lambda表达式

 lambda，定义无名称函数（只能使用一次），，函数体只有一行，结果直接通过return返回

语法： lambda 参数：计算逻辑

# lambda表达式
def func_a(f):
    result = f(3, 2)
    print(result)


func_a(lambda x, y: x + y)   #  函数体只有一行,并且内置return
func_a(lambda x, y: x * y)

lst = (("a", 99), ("b", 88), ("c", 66))
# 传入参数是被排序容器的一个元素,返回值是排序依据
print(sorted(lst, key=lambda x: x[1]))

# lambda表达式练习题

def func(x,y,f):
    result=f(x,y)
    return result


print(func(2, 3, lambda x, y: x * y))