编程语言python中的*和**

参考链接1 参考链接2

简介： Python中的*与**操作符使用最多的就是两种用法。

1.用做运算符，即*表示乘号，**表示次方。

2.用于指定函数传入参数的类型的。 *用于参数前面，表示传入的多个参数将按照元组的形式存储，是一个元组；

**用于参数前则表示传入的(多个)参数将按照字典的形式存储，是一个字典。

*args必须要在**kwargs,否则将会提示语法错误"SyntaxError: non-keyword arg after keyword arg."

代码展示：

 1 def func(*args):
 2   print(type(args))
 3   for index, item in enumerate(args):
 4     '''
 5     enumerate()是python的内置函数
 6     对于一个可迭代的(iterable)/可遍历的对象(list, str,tuple),enumerate将其组成一个索引序列，利用它可以同时获得索引和值
 7     >>> list1 = ['life', 'is', 'too', 'short', 'you', 'need', 'python.']
 8     >>> for index, item in enumerate(list1):
 9     ...     print(index, item)
10     ...
11     0 life
12     1 is
13     2 too
14     3 short
15     4 you
16     5 need
17     6 python.
18     '''
19     # 下面的参数化打印的教程待会儿写，可以直接搜python format。
20     print("{}:{}".format(index, item))
21 
22 def function(**kwarg):
23   print(type(kwarg))
24   for key, value in kwarg.items():
25     print("{}:{}".format(key, value))
26 
27 
28 def main():
29   func("python", "golang")
30   function(a = "python", b = "golang")
31 
32 if __name__ == '__main__':
33   main()

结果: 

1 <class 'tuple'>
2 0:python
3 1:golang
4 <class 'dict'>
5 a:python
6 b:golang
7 [Finished in 0.5s]
8 ​

对比总结： 我们来看看这两个关键词， args是arguments（参数）的缩写，kwargs是key word arguments的缩写，从字面意思就能看出来，kwargs对应的就是字典中的key和值，因此也可以便于记忆。 另外，我们需要第三个实验，就是即有*args，又有kwargs，还有普通的参数，需要明白这三者之间的顺序。以及对应的打印展示：

1. 单独使用*args

    1 def foo(*args):
    2     print(args)
    3 
    4 foo("fruit", "animal", "human")
    5 ('fruit', 'animal', 'human')
    6 
    7 foo(1, 2, 3, 4, 5)
    8 (1, 2, 3, 4, 5)
    9 
   10 arr = [1, 2, 3, 4, 5]  # 如果我们希望将一个数组形成元组，需要在传入参数的前面 加上一个\*
   11 foo(arr)
   12 ([1, 2, 3, 4, 5],)
   13 
   14 foo(*arr)
   15 (1, 2, 3, 4, 5)

2. 单独使用*kwargs*

1 def foo(**kwargs):
2         for key, value in kwargs.items():
3             print("%s=%s" % (key, value))
4 
5 foo(a=1,b=2,c=3)
6 a=1
7 b=2
8 c=3

3. 混合使用+普通参数+默认参数

 1 def foo(name, *args, middle=None, **kwargs):
 2     print("name:", name)
 3     print("args:", args)
 4     print("middle:", middle)
 5     print("kwargs:", kwargs)
 6 
 7 # 第一个hello没有指定形参，直接被name捕获
 8 # 剩下的才会被*args捕获，但是由于没有指定middle的值，因此采用了默认值
 9 # 剩下的都被**kwargs捕获了。
10 foo("hello", 1, 2, 3, a=1, b=2, c=3)
11 name: hello
12 args: (1, 2, 3)
13 middle: None
14 kwargs: {'a': 1, 'b': 2, 'c': 3}
15     
16 # 这里的第二个实验，才是精髓；
17 # 先创建一个字典，里面有五个键值对，将这字典传入函数中。
18 # 函数会先寻找name这个键的值，为hello；
19 # 接下来因为没有元组，因此args为()
20 # 再来寻找middle这个键值，找到了值为world
21 # 剩下没人要的都被存到了kwargs里面了。
22 my_foo = {"name": "hello", "middle": "world", "a": "1", "b": "2", "c": "3"}  #若不加**，变量名就是一个变量，无法匹配到各个值
23 foo(**my_foo)
24 name: hello
25 args: ()
26 middle: world
27 kwargs: {'a': '1', 'b': '2', 'c': '3'}

文章来源：https://www.cnblogs.com/cs-markdown10086/p/14766111.html