Python基础教程：默认参数和可变参数

深碍√TFBOYSˉ_ 2022-10-10 01:35 265阅读 0赞

1. 默认参数

在函数定义时附加一个赋值运算符（=）来为参数指定默认参数值。必选参数在前，默认参数在后，匹配时从左往右进行匹配。

使用默认参数有什么好处？最大的好处是能降低调用函数的难度。

  1. def enroll(name, gender, age=6, city='Beijing'):
  2.     print('name:', name)
  3.     print('gender:', gender)
  4.     print('age:', age)
  5.     print('city:', city)
  7. enroll('Sarah', 'F')
  8. enroll('Bob', 'M', 7)                 # 从左往右匹配，故是age = 7
  9. enroll('Adam', 'M', city='Tianjin')   # 可以直接指定赋值的参数名

默认参数很有用，但使用不当，也会掉坑里。默认参数有个最大的坑，演示如下：

  1. # 你使用默认参数调用时出现如下情况
  2. print(add_end())
  3. print(add_end())   # 再次调用时结果就不对了
  4. print(add_end())
  6. """ output: ['END'] ['END', 'END'] ['END', 'END', 'END'] """

原因如下：Python 函数在定义的时候，默认参数 L 的值就被计算出来了，即[]，因为默认参数 L 也是一个变量，它指向对象[]，每次调用该函数，如果改

变了 L 的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。所以，定义默认参数要牢记一点：默认参数必须指向不变对象！

2. 可变参数

可变参数就是传入的参数个数是可变的，可以是 1 个、2 个到任意个，还可以是 0 个。有以下两种参数形式：

1）*args：接收N个位置参数，转换成元组tuple形式。这个*号到底是做什么用的呢？

a. 打包参数：当*号出现在函数参数中时，即遇到带*号的形参，那么就会把还未分配出去的实参以元组形式打包（pack）,分配给那个带

  1. ''' Python学习交流，免费公开课，免费资料， 免费答疑，系统学习加QQ群：579817333 '''
  2. def foo1(*args):
  3.     print(args)      # 输出 (1, 2, 3, 4, 5)
  5. def foo2(a, *args):
  6.     print('a:', a) 
  7.     print('args:', args)  # 输出 (2, 3, 4, 5)
  9. foo1(1, 2, 3, 4, 5)  # 1,2,3,4,5被打包分配给args
  10. foo2(1, 2, 3, 4, 5)  # 1 配给 a, 2,3,4,5被打包分配给args

这种打包参数的方法也可以使用在不确定元素个数的情况下的赋值，表述有点抽象，直接看个例子：

  1. # 假如 record 后面都是电话号码但是不知道有多少个
  2. record = ('Dave', 'dave@example.com', '773-555-1212', '847-555-1212')
  3. name, email, *phone_numbers = record
  4. print(phone_numbers)  # ['773-555-1212', '847-555-1212']
  6. # 最后一个元素会被 current 占用，其余均被打包
  7. *trailing, current = [10, 8, 7, 1, 9, 5, 10, 3]
  8. print(trailing)  # [10, 8, 7, 1, 9, 5, 10]
  10. # 也可用在循环中
  11. records = [('foo', 1, 2), ('bar', 'hello'), ('foo', 3, 4)]
  12. def do_foo(x, y):
  13.     print('foo', x, y)
  15. def do_bar(s):
  16.     print('bar', s)
  18. for tag, *args in records:
  19.     if tag == 'foo':
  20.         do_foo(*args)   # 这里是拆包，可以看下面理解下
  21.     elif tag == 'bar':
  22.         do_bar(*args)

b. 拆分参数：当*号出现在实参中时，即传入带*号的实参，那么会把打包了的实参（元组或列表），拆分成单个的变量，依次赋值给函数的形参。

  1. ''' Python学习交流，免费公开课，免费资料， 免费答疑，系统学习加QQ群：579817333 '''
  2. def bar(a, b, c, d=10):
  3.     print(a, b, c, d)
  5. bar(*[1, 2, 3])

2）**kwargs：接收N个关键字参数，转换成字典dict形式。**号的作用与*号是一样的，只是打包或拆分的形式不一样：

a. 打包参数：对于带**号的形参，会把多个实参参数打包成字典。

  1. def bar(**kw):
  2.     print(kw)   # 输出：{'a': 1, 'b': 2, 'c': 3}
  4. bar(a=1, b=2, c=3)

b. 拆分参数：对于带**号的实参，会把已经打包的字典的键值拆成单个，依次赋值给函数的形参。

  1. def bar(a, b, c):
  2.     print(a,b,c)   # 输出：1，2，3
  4. bar(**{ 'a': 1, 'b': 2, 'c': 3})  # 每个key必须和bar的形参名一致

如果我们希望检查是否有某个参数，如 city 和 job，可以这样：

  1. def person(name, age, **kw):
  2.     if 'city' in kw:
  3.         # 有 city 参数
  4.         pass
  5.     if 'job' in kw:
  6.         # 有 job 参数
  7.         pass
  8.     print('name:', name, 'age:', age, 'other:', kw)
  10. extra = { 'city': 'Beijing', 'job': 'Engineer'}
  11. person('Jack', 24, **extra)

注：无论函数参数是怎么样的，我们都可以通过拆分参数这种形式进行赋值，看个例子：

args 和 kw 被拆分后会按顺序赋值给 test 的形参。

  1. ''' Python学习交流，免费公开课，免费资料， 免费答疑，系统学习加QQ群：579817333 '''
  2. args = (1,2)
  3. kw = { }
  5. def test(a,b):
  6.     print(a,b)
  8. test(*args, **kw)  # 完全不必去管test的参数有几个或者是怎样的形式

3. 只接受关键字参数

将强制关键字参数放到某个 *参数或者单个*后面就能达到这种效果。比如：

  1. def recv(maxsize, *, block):
  2.     'Receives a message'
  3.     pass
  5. recv(1024, True) # TypeError
  6. recv(1024, block=True) # Ok

发表评论

表情：
评论列表 （有 0 条评论，265人围观）

还没有评论，来说两句吧...

相关阅读