Python基础之函数参数与返回值进阶

参数作用：如果外界希望在函数内部处理数据，就可以将数据作为参数传入函数内部；
返回值作用：如果希望一个函数函数执行完成后，向外界报告函数的执行结果，就可以使用函数的返回值。

函数的返回值 进阶

利用元组返回多个函数值

可以用元组让函数返回多个值；如果函数返回的类型时元组，那么小括号可以省略；比如，以下两个就相等：
return (temp, humidity) = return temp, humidity

def measure():
    """
    测量温度和湿度
    :return: 返回温度和湿度结果的元组
    """
    print("开始测量")
    temp = "37"
    humidity = "50"
    print("测量结束")

    # 可以用元组让函数返回多个值；如果函数返回的类型时元组，那么小括号可以省略
    # return (temp, humidity)
    return temp, humidity


result = measure()
print("温度为：", result[0])
print("湿度为：", result[1])

用多个变量接收函数的返回值

• 如果函数返回的类型是元组，同时希望单独的处理元组的元素时，可以用多个变量，一次性接收函数的返回结果；
• 注意，多个变量接收返回结果时，变量个数应该和函数返回元组元素个数一致，否则报错；

多个变量接收函数返回值示例

def measure():
    """
    测量温度和湿度
    :return: 返回温度和湿度结果的元组
    """
    print("开始测量")
    temp = "37"
    humidity = "50"
    print("测量结束")

    return temp, humidity


result = gl_temp, gl_humidity = measure()
print("温度为：", gl_temp)
print("湿度为：", gl_humidity)
print("温度为：", result[0])
print("湿度为：", result[1])

函数的参数进阶

函数内部变量和参数的关系

函数内部形参重赋值不会影响外部实参

只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用

• 函数内部针对参数的赋值不影响实参在外部的使用，但在函数内部 同名局部变量会覆盖形参；
• 我们可以理解为局部变量和全局变量，传进来的就相当于全局变量，在函数内对参数重新赋值，就相当于在函数内部定义一个同名局部变量；

形参重赋值示例

def test(num, num_list):
    print("现在是函数内部")
    
    num = 1000
    num_list = [22, 33, 44, 55]
    print(num)
    print(num_list)


num = 10
num_list = [1, 2, 3, 4]
test(num, num_list)  # 1000 [22, 33, 44, 55]

print(num)  # 10
print(num_list)  # [1, 2, 3, 4]

函数内部形参修改会影响外部实参

如果传递的参数是可变类型，在函数内部，使用方法修改了数据的内容，同样会影响到外部的数据。

但如果我们针对可变类型参数 只用方法改变参数数据，不重新赋值，就会影响到形参在函数外部的使用了；
这是因为我们在传参是传的是变量的引用，而在函数内部也没有对形参进行局部变量覆盖，一直用的就是变量的引用，所以当我们用方法修改可变类型参数时，会直接修改外部的变量。

def test(num_list):
    print("现在是函数内部")
    num_list.append(9)
    print(num_list)


num_list = [2, 4, 6]
print("进入函数前列表：", num_list)
test(num_list)
print("现在是函数外部")
print("从函数出来后列表：", num_list)

# 进入函数前列表： [2, 4, 6]
# 现在是函数内部
# [2, 4, 6, 9]
# 现在是函数外部
# 从函数出来后列表： [2, 4, 6, 9]

列表调用+=本质是extend方法

• 如果我们在函数内部使用num_list += num_list就相当于num_list.extend(num_list)，而列表又是可变类型的变量参数，所以会修改传入的外部的列表；
• 而我们使用num_list = num_list + num_list时，就不会修改外部的列表变量

extend方法与+= 示例

# 列表调用+=本质是调用extend方法
def test(num, num_list):
    print("进入函数内，尚未修改前的传参变量如下两个")
    print(num)
    print("num_list:", num_list)

    # num_list = num_list + num_list  # 不会修改函数外部的变量
    num_list += num_list
    print("+=修改后的num_list:", num_list)
    pass


num = 10
num_list = [1, 3, 5]
print("原始的num_list:", num_list)
test(num, num_list)

print("函数执行完成后的num_list:", num_list)

# 原始的num_list: [1, 3, 5]
# 进入函数内，尚未修改前的传参变量如下两个
# 10
# num_list: [1, 3, 5]
# +=修改后的num_list: [1, 3, 5, 1, 3, 5]
# 函数执行完成后的num_list: [1, 3, 5, 1, 3, 5]

缺省参数

缺省参数的介绍

• 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数；
• 调用函数时，如果没有传入缺省参数的值，则在函数内部 使用定义函数时指定的参数默认值；
• 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用。

其实在列表的sort方法，就是使用的缺省参数，默认reverse为True，只有在需要降序的时候才会写reverse = False

缺省参数语法

def 函数名(参数1，参数2，...，参数x=默认值):
    pass

缺省参数的使用示例

指定缺省函数的默认值

def test(name, gender=True):
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("%s 是 %s" % (name, gender_text))


test("喜羊羊")
test("沸羊羊")
test("美羊羊", gender=False)

# 喜羊羊 是 男生
# 沸羊羊 是 男生
# 美羊羊 是 女生

指定缺省函数的默认值，只需要在函数传参处定义一个赋值语句给定默认值即可；应注意，默认值应该是出现最常见的值；

缺省参数的注意事项

1. 带有默认值的缺省参数，必须确保 放在参数列表末尾；
2. 在调用参数时，如果有多个缺省参数，需要指定参数名，避免参数对应错误。

调用带有多个缺省参数的函数

def test(name, title="干事", gender=True):
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("%s 是 %s， 职位是 %s" % (name, gender_text, title))


test("喜羊羊")
test("沸羊羊", "劳动委员")
test("美羊羊", gender=False)
test("暖羊羊", "班长", gender=False)

# 喜羊羊 是 男生， 职位是 干事
# 沸羊羊 是 男生， 职位是 劳动委员
# 美羊羊 是 女生， 职位是 干事
# 暖羊羊 是 女生， 职位是 班长

多值参数

• 有时可能需要一个函数能够处理的参数个数是不确定的，这个时候，就可以使用多值参数；
• python中有两种多值参数：参数名前加*对应一个元组，参数名前加**对应一个字典；
• 一般在给多值参数命名时，习惯使用以下两个名字：*args--存放元组参数;**kwargs--存放字典参数；

多值参数示例

def test(num, *nums_list, **info_dict):
    print(num)
    print(nums_list)
    print(info_dict)


test(1)
test(1, 2, 3, 4, 5, name="zhangsan", gender="boy")

# 1
# ()
# {}

# 1
# (2, 3, 4, 5)
# {'name': 'zhangsan', 'gender': 'boy'}

多值参数求和案例

def sums(*args):
    print(args)
    s = 0
    for num in args:
        s += num
    return s


result = sums(1, 2, 3, 4)
print(result)


# (1, 2, 3, 4)
# 10

元组和字典的拆包

在调用带有多值参数的函数时，如果希望 1.将一个元组变量，直接传递给args 2.将一个字典变量，直接传递给kwargs 的话，就可以使用拆包，简化参数的传递；
拆包的方式是：在元组变量前，增加一个*；在字典变量前，增加**

拆包示例

def test(*args, **kwargs):
    """传入一个元组和一个字典，并对它们分别进行输出"""
    print(args)
    print(kwargs)


t_tuple = (1, 2, 3, 4)
t_dict = {"name": "zhangsan", "age": "20"}

test(t_tuple, t_dict)  # 这个并不能按照我们的想法进行传输
# 用拆包，简化元组/字典变量的传递
test(*t_tuple, **t_dict)  # 这个的和下面是一样的
test(1, 2, 3, 4, name="zhangsan", age="20")

# ((1, 2, 3, 4), {'name': 'zhangsan', 'age': '20'})
# {}

# (1, 2, 3, 4)
# {'name': 'zhangsan', 'age': '20'}
# (1, 2, 3, 4)
# {'name': 'zhangsan', 'age': '20'}

函数的递归

函数调用自身的编程技巧称为递归。

递归函数的特点

1. 一个函数内部调用自己；(函数内部可以调用其他函数，当然也可以在函数内部调用自己)
   代码特点：
2. 函数内部的代码是相同的，只是针对参数的不同，处理的结果不同；
3. 当一个参数满足条件时，函数不再执行；(这个非常重要，通常被称为递归的出口，否则会出现死循环)

函数递归示例

def sums(num):
    print(num)
    if num == 1:
        return
    sums(num-1)


sums(4)  # 4 3 2 1

递归实现数字累加示例

def test(num):
    """计算1+...+num的结果"""
    if num == 1:
        return 1

    temp = test(num-1)
    # 两个相邻数字的相加
    return num+temp


result = test(100)
print(result)