19-函数的返回值和参数进阶

函数

函数根据有无参数以及有无返回值，可分为

• 有返回值，有参数
• 有返回值，无参数
• 无返回值，有参数
• 无返回值，无参数

利用元组函数可以返回多个返回值

def measure():
    """测量温度和湿度"""
    print("开始测量")
    temp = 39
    wetness = 50
    print("测量结束")
    # 元组-可以包含多个数据，因此可以使用元组让函数一次范湖多个值
    return temp, wetness


# 如果函数返回的类型是元组，同时西瓦网单独的处理元组中的元素
# 可以使用多个变量，一次接收函数的返回结果
gl_temp, gl_wetness = measure()
print(gl_temp, gl_wetness)

接收返回元组函数的方式,如上所示

交换两个变量的值

a = 6
b = 100
# 解法1
# c = a
# a = b
# b = c
# 解法2
# a = a + b
# b = a - b
# a = a - b
# 解法3 python专有
a, b = b, a
print(a, b)

在函数内部针对参数赋值不会影响外部实参

def demo(num, num_list):
    print("函数内部")
    num = 20
    num_list = [1, 2, 3]
    print(num, num_list)


gl_num = 99
gl_num_list = [3, 4, 5]
demo(gl_num, gl_num_list)
print(gl_num, gl_num_list)

在函数内部使用方法修改可变参数会影响外部实参

def demo(num_list):
    print("函数内部")
    num_list.append(9)
    print(num_list)


gl_num_list = [1, 2, 3]
demo(gl_num_list)
print(gl_num_list)

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

def demo(num_list):
    print("函数内部")
    num_list += num_list
    print(num_list)


gl_num_list = [1, 2, 3]
demo(gl_num_list)
print(gl_num_list)

缺省参数

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

gl_list = [6, 3, 9]
# 默认按照升序排序
# gl_list.sort()
# 如果需要降序排序，需要执行reverse参数
gl_list.sort(reverse=True)

指定函数缺省参数的默认值

def print_info(name, gender=True):  # 缺省参数的默认值是True
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("%s 是 %s" % (name, gender_text))


print_info("小明")
print_info("小美", False)

缺省参数的注意事项

• 缺省参数应该放在函数参数列表的最后面
• 调用带有多个缺省参数的函数时，需要指定参数名，这样解释器才能知道缺省参数的对应关系

def print_info(name, title="", gender=True):  # 缺省参数的默认值是True
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("[%s]%s 是 %s" % (title, name, gender_text))


print_info("小明")
print_info("小美", gender=False)

多值参数

定义支持多值参数的函数

• 有时可能需要一个函数能够处理的参数个数是不固定的，就可以使用多值参数
• python中有两种多值参数
  参数名前增加一个，可以接收元组
  参数名前增加两个*，可以接收字典
• 一般在给多值参数命名时，习惯使用以下两个名字
  *args--存放元组参数，前面有一个“ * ”
  **kwargs--存放字典参数，前面有两个“ ** ”
• args是arguments的缩写，有变量的含义
• kw是keyword的缩写，kwargs可以记忆键值对参数

def demo(num, *nums, **person):

    print(num)
    print(nums)
    print(person)


# demo(1)
demo(1, 2, 3, 4, 5, name="小明", age=18)

> 输出结果
1
(2, 3, 4, 5)
{'name': '小明', 'age': 18}

def sum_numbers(*args):
# def sum_numbers(args):
    """ 数字累加
    :param args: 传递的元组参数
    :return: 返回累加结果
    """
    num = 0
    for arg in args:
        num += arg
    return num
result = sum_numbers(1, 2, 3)
# result = sum_numbers((1, 2, 3))
print(result)

元组和字典的拆包

在调用带有多个参数的函数时，如果希望：

• 将一个元组变量，直接传递给args
• 将一个字典变量，直接传递给kwargs

就可以使用拆包，简化参数的传递。拆包的方法

• 在元组变量前增加一个*
• 在字典变量钱增加两个**

def demo(*args, **kwargs):
    print(args)
    print(kwargs)
# 元组变量、字典变量
gl_nums = (1, 2, 3)
gl_dict = {"name": "小明", "age": 18}

# demo(gl_nums, gl_dict)
# 拆包语法，简化元组、字典参数的传递
demo(*gl_nums, **gl_dict)
# demo(1, 2, 3, name="小明", age=18)

递归的特点

一个函数内部调用自己
代码特点

• 函数内部的代码是相同的，只是针对参数不同，处理的结果不同
• 当参数满足一定条件时，函数不再执行。
  这个非常重要，通常被称为递归函数的出口，否则会出现死循环。

def sum_number(num):
    print(num)
    # 递归的出口，当参数满足某个条件时，不再执行函数
    if num == 1:
        return 
    # 自己调用自己
    sum_number(num - 1)

sum_number(3)

def sum_numbers(num):
    # 1. 出口
    if num == 1:
        return 1
    # 2. 数字累加
    # 假设sum_numbers能够正确处理1...num-1
    temp = sum_numbers(num - 1)
    return num + temp

result = sum_numbers(2)
print(result)