晨曦的博客

技术博客

0%

Python中的*可变参数与**关键字参数

发表于 更新于 分类于

详情请点阅读全文

1、定义了一个需要两个参数的函数

1
2
3
4
5
6
def print_str(first, second):
    print first
    print second
 
if __name__ == "__main__":
    print_str("hello", "world")
  • 如果传一个参数调用，print_str(“hello”)，那么一定会抛出异常的：
    明确告诉你需要准确的两个参数，现在只确定给了一个参数
    1
    TypeError: print_str() takes exactly 2 arguments (1 given)

    2、传一个参数行，两个参数行，多个参数也行的函数

    上面的问题，我们有个需求，就是我想传一个参数也行（还有种办法是用到默认参数），传两个参数或多个参数也行的函数有没有？像java一样，必须的有，让我们改造一下最后参数为可变参数（也就是说可变参数，你可以不传）
1
2
3
def print_str(first, *second):
    print first
    print second

此时调用：print_str("hello")

输出结果：

1
2
hello
()

可以看到字符串”hello”打印出来了，而没有传参的*second，打印出的是一个元组tuple，0个元素的元组，因为我就传了一个参数

如果我们多传几个参数呢

1
2
3
4
5
print_str("hello","one","two","three")

输出结果：
hello
('one', 'two', 'three')
  • 果然从可变参数开始起，即第二个参数”one”开始，会作为元组的第一个元素，后面的参数也会相继成为元组的元素

3、总结一下 *参数

在调用时，从*参数 起，对传入的参数，自动组成tuple

4、函数调用时，传入*参数，会对传入的元组参数进行一个解包功能，每一个元素自动作为函数的位置参数

print_str(*numbers_strings)，传入*元组，看看是怎么解包的，元组的第一个元素，仍然是代表位置参数first

等同于print_str("1","2","3","4","5")

1
numbers_strings = ("1","2","3","4","5")
1
2
3
4
5
6
7
8
9
10
11
def print_str(first, *second):
    print first
    print second
 
if __name__ == "__main__":
    print_str(*numbers_strings)
 
 
输出结果：
1
('2', '3', '4', '5')

5、一个没有可变参数的函数，可用解包功能一次性传入多个参数

看下例子

1
2
3
4
5
6
7
8
9
10
11
12
numbers_strings = ("1","2")
 
def print_str(first, second):
    print first
    print second
 
if __name__ == "__main__":
    print_str(*numbers_strings)
    
输出结果：
1
2

6、**参数，参数名称前两个**，代表的是关键字参数，也叫做字典参数，看下例子

1
2
3
4
5
def printStr(**anything):
    print anything
 
printStr(first = 5, second = 100)
{'second': 100, 'first': 5}

关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict

6.1、函数调用时，也可以传入一个字典（需要前面加两个*），这样函数那块就会解包，它会把dictionary中所有键值对转换为一个一个的关键字参数传进去

1
2
3
4
5
6
7
8
def printStr(first, **dict):
    print str(first) + "\n"
    print dict


printDic = {"name": "tyson", "age":"99"}
printStr(100, **printDic)
printStr(100, name = "tyson", age = "99") #等同于上面**printDic

7、总结

在python中，当*和**符号同时出现在函数定义的参数中时，都表示参数列表可接受任意数量的参数，它们均称为可变参数：

  1. *second表示任意多个（包含0个）无名参数，又称为元组参数，最终的类型为tuple（注意：就算传递一个元素，也会最终变为tuple）

  2. **anything表示任意多个关键字参数，又称为字典参数，最终的类型为dictionary

注意：

  1. 二者同时存在时，一定需要将*second放在**anything之前 （重要的事情说三遍）
  2. 二者同时存在时，一定需要将*second放在**anything之前
  3. 二者同时存在时，一定需要将*second放在**anything之前

8、注意事项，再提一次

a、首先只要是可变参数（无名参数或者关键字参数），可以传0个参数，也可以传1个，同样也可以传多个

b、只要是可变参数（元组参数或者字典参数），一定要在普通参数（也称位置参数）的后面

c、*参数一定必须在**参数的前面（元组参数与字典参数同时存在时，元组参数一定在前）

1
2
def printStr(参数，*参数，**参数):
    pass

d、*参数，虽然叫元组参数，你可别传个完整的元组对象进来哈（只算一个参数而已，它还是会作为tuple的一个元素），如果是个元组，记得做解封，不然就要背锅了，就是要这样*turple传进去

e、**参数，虽然叫字典参数，你可别传个完整的字典对象进来哈（只算一个参数而已，应该会报错，因为不符合关键字参数的规范），如果是个字典，记得也是做解包，对，就是要这样 **dict传进去

f、*参数，叫元组参数，如果传一个参数进去，它也会最终组成turple，这点要注意了 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def jsonify(*args, **kwargs):
    indent = None
    separators = (',', ':')
 
    if current_app.config['JSONIFY_PRETTYPRINT_REGULAR'] or current_app.debug:
        indent = 2
        separators = (', ', ': ')
 
    if args and kwargs:
        raise TypeError('jsonify() behavior undefined when passed both args and kwargs')
    elif len(args) == 1:  # single args are passed directly to dumps() 
        data = args[0]    #注意看这里
    else:
        data = args or kwargs
 
    return current_app.response_class(
        dumps(data, indent=indent, separators=separators) + '\n',
        mimetype=current_app.config['JSONIFY_MIMETYPE']
    )

g、**参数，我相信字典参数也一样，传一个进去的时候，同样最终也会转换为dict

h、还有一个big bang，还是和上面f条的那个例子有关，就是为元组参数，那我就传一个dict参数，这时候特别容易混淆，跟e条的关系很大，注意了