关键字参数

位置实参就是由逗号分隔、按照前后顺序摆放的诸多实际参数，它们按照位置匹配函数定义时的形式参数，以函数 func_1 为例，# a, b, c, d 就是它的形式参数

  1. def func_1(a, b, c, d):
  2.     pass

若按如下方式进行调用 # x, y, z, w 就是它的实际参数，可以跟上面的形参重名

  1. func_1(x, y, z, w)

在函数体执行前就会形成 a = x，b = y，c = z，d = w 的传参效果。
关键字实参同样由逗号分隔，区别在于要在实参前加上形参名=这样的前缀，从而实现了一种显式的参数匹配效果，可以摆脱位置的约束。
比如还是上面的 func_1，我们这次完全使用关键字实参来调用，

  1. def func_1(x, y, z, w):
  2.     print(f"x:{x},y:{y},z:{z},w:{w}")
  5. if __name__ == '__main__':
  6.     func_1(z='梨子', w='柚子', x='西瓜', y='葡萄')

执行结果：

  1. x:西瓜,y:葡萄,z:梨子,w:柚子

这种形式可以无视位置
当然，单纯的摆脱位置约束还不足以体现关键字参数的优势，结合有意义的形参名和合理设定的默认值，关键字参数可以拥有很好的可读性和易用性。

默认参数：

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

  1. def print_info(name, age=8):
  2.     print(f'姓名：{name}')
  3.     print(f'年龄：{age}')
  6. if __name__ == '__main__':
  7.     print_info('张飞')

执行结果：

  1. 姓名：张飞
  2. 年龄：8

注意：默认参数只能放在最后，否则会报错。

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

  1. def functionname([formal_args,] *var_args_tuple ):
  2.    "函数_文档字符串"
  3.    function_suite
  4.    return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

  1. def print_info(arg1, *var_tuples):
  2.     print(arg1)
  3.     for x in var_tuples:
  4.         print(x)
  7. if __name__ == '__main__':
  8.     print_info(10, 20, 30, 80)

执行结果：

  1. 10
  2. 20
  3. 30
  4. 80

加了两个星号 ** 的参数会以字典的形式导入。

  1. def print_dict(arg1, **var_dict):
  2.     print(arg1)
  3.     print(var_dict)
  6. if __name__ == '__main__':
  7.     print_dict(10, a=19, b=20)

执行结果：

  1. 10
  2. {'a': 19, 'b': 20}