10 函数的返回值和参数进阶

函数的返回值和参数进阶

目标

• 函数参数和返回值的作用
• 函数的返回值进阶
• 函数的参数进阶
• 递归函数

1 函数参数和返回值的作用

函数根据有没有参数以及有没有返回值，可以互相组合，一共有4种组合形式

1. 无参数，无返回值
2. 无参数，有返回值
3. 有参数，无返回值
4. 有参数，有返回值

• 函数 —> 封装功能独立的代码，在需要时通过函数名被调用

• 参数 —> 当函数内部需要处理外部的数据时，把外部的数据以参数的形式传递给函数

• 返回值 —> 函数执行结束后可以通过返回值向外界报告函数的执行结果

定义函数时，是否接收函数，或者是否返回结果，是根据实际的功能需求来决定的！

1. 如果函数内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部
2. 如果希望一个函数执行完成后，向外界汇报执行结果，就可以增加函数的返回值

2 函数的返回值进阶

• 在程序开发中，有时候，会希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
• 返回值势函数完成工作后，最后给调用者的一个结果
• 在函数中使用return 关键字可以返回结果
• 调用函数一方，可以使用变量来接收函数的返回结果

问题：一个函数能否返回多个结果？

示例：

• 假设要开发一个函数能够同时返回当前的温度和湿度
• 代码功能如下：

def measure():
    print("测量开始……")
    temp = 37
    wetness = 50
    print("测量结束……")
    # 元祖可以包含多个数据，因此可以使用元祖让函数一次返回多个值
    # 如果函数返回的类型是元祖，小括号可以省略
    # return (temp, wetness)
    return temp, wetness


result = measure()
print(result)

3 函数的参数进阶

不可变和可变的参数

在函数内部，针对参数使用赋值语句，会不会影响到调用函数时传递的实参变量？——不会

• 无论传递的参数是可变还是不可变

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

  def demo(num, num_list):
      print("函数内部的代码")
      # 在函数内部，针对参数使用赋值语句，不会修改到外部的实参变量
      num = 100
      num_list = [1, 2, 3]
      print(num)
      print(num_list)
      print("函数执行完成")
  
  
  gl_num = 99
  gl_list = [4, 5, 6]
  demo(gl_num, gl_list)
  print(gl_num)
  print(gl_list)
  

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

def demo(num_list):
    print("函数内部的参数")
    num_list.append(9)
    print(num_list)
    print("函数执行完成")


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

面试题 +=

• 在 python 中，列表变量调用 += 本质上是在执行变量的 extend 方法，不会修改变量的引用

def demo(num, num_list):
    print("函数开始")
    # num = num + num
    num += num
    # 针对数字或者字符串 += 都是先相加再赋值(不会影响全局变量)
    # 针对列表变量实际上是调用了extend方法(会影响全局变量)
    # num_list.extend(num_list)
    num_list += num_list
    print(num)
    print(num_list)
    print("函数结束")


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

缺省参数

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

gl_list = [6, 3, 9]
# 默认就是升序排序，因为这种需求相对较多
gl_list.sort()
print(gl_list)

# 只有当需要降序排序时，才需要传递 `reverse` 参数
gl_list.sort(reverse=True)
print(gl_list)

// reverse就是一个缺省参数，不指定值是默认调用 Flase 为参数值

指定函数的缺省参数

• 在参数后使用赋值语句，可以指定参数的缺省值

def print_info(name, gender=True):
    """

    :param gender: 性别
    :type name: 姓名
    """
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("%s 是 %s" % (name, gender_text))


# 假设班上男生居多，要设置缺省参数
# 提示：在指定缺省参数的默认值时，应该使用最常见的值作为默认值！
print_info("小明")

提示

1. 缺省参数，需要使用最常见的值作为默认值！
2. 如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递

缺省参数的注意事项

1. 缺省参数的定义位置

• 必须保证带有默认值的缺省参数在参数列表末尾
• 没有默认值的参数应该放在缺省参数的前面
• 所以，以下定义是错误的！

def print_info(name, gender=True, title):	# 错误

def print_info(name, title, gender=True):	# 正确

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

• 在调用函数时，如果有多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系

def print_info(name, title="", gender=True):
    """

    :param title: 职位
    :param gender: 性别
    :type name: 姓名
    """
    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, **persion):
    print(num)
    print(nums)
    print(persion)


# demo(1)
# demo(1, 2, 3)
demo(1, 2, 3, name="小明")

提示：多值参数的应用会经常出现在网络上一些大牛开发的框架中，知道多值参数，有利于我们能够读懂大牛的代码

多值参数案例

——计算任意多个数字的和

需求

1. 定义一个函数sum_numbers，可以接收任意的多个整数
2. 功能要求：将传递的所有数字累加，并返回累加结果

def sum_number(*args):
    num = 0
    print(args)
    # 循环遍历
    for i in args:
        num += i
    return num


result = sum_number(1, 2, 3)
print(result)

元祖和字典的拆包

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

def demo(*args, **kwargs):
    print(args)
    print(kwargs)


# 需要将一个元祖变量/字典变量直接传递给函数对应的参数
gl_num = (1, 2, 3)
gl_dict = {"name": "小明", "age": 18}
# 拆包语法
# 会把gl_num直接传递给args，gl_dict直接传递给kwargs
demo(*gl_num, **gl_dict)

4 函数的递归

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

递归函数的特点

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

示例代码

def demo(num):
    print(num)
    # 递归的出口很重要，否则会出现死循环
    if num == 0:
        return

    # 自己调用自己
    demo(num - 1)


demo(3)

递归案例

需求

• 定义一个函数 sum_numbers
• 能够接收一个num 的整数参数
• 计算 1+2+...num 的结果

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


result = sum_numbers(100)
print(result)