python中星号*的使用

在C中*表示指针，那么在python中有哪些使用规则？

---

函数参数分类

位置参数

• 在函数定义阶段，按照从左到右的顺序直接定义的"变量名
• 必须被传值，多一个不行少一个也不行
• 在函数调用阶段， 按照从左到有的顺序依次传入的值
• 按照顺序与形参一一对应

关键字参数

• 在函数调用阶段，按照key=value的形式传入的值
• 指名道姓给某个形参传值，可以完全不参照顺序
• 位置实参必须放在关键字实参前
• 不能为同一个形参重复传值

默认参数

• 在定义函数阶段，就已经被赋值的形参，称之为默认参数
• 在定义阶段就已经被赋值，意味着在调用阶段可以不用为其赋值

---

*和位置参数有关

函数参数中的*都只涉及函数的位置参数。

形参中*的作用是变长度参数

用来接收溢出的位置实参，溢出的位置实参会被 * 保存成元组的格式,然后赋值紧跟其后的形参名，*后跟的可以是任意名字，但是约定俗成应该是args。就是说定义为def func(a, *z):也完全是正确的。

def func(a, *args):			
     print(a)
     print(args)
     
func(1,2,3,4)          
#把1传给a，把2，3，4传给*args

注意是以元组的形式传入的，tuple元素数据不可变。

def func(a, *args):
    print(a)
    print(type(a))
    print(args)
    print(type(args))
    print(type(args[1]))
    print(args[1])
 
func(1,2,3,4)

结果：

1
<class 'int'>
(2, 3, 4)
<class 'tuple'>
<class 'int'>
3

改为

def func(a, *args):
    print(type(args[1]))
    args[1] = args[1] + 1;
    print(args[1])
 
func(1,2,3,4)

报错。tuple元素数据不可变。

• 默认参数和可变参数混合使用，默认参数在可变参数的右侧 ，需要用关键字指定参数。

def func(*args, a):
    print(args)
    print(a)
func(1,2,3,a = 10)

---

实参中*的作用是打散成位置实参(将多个值依次解压为位置实参)

实参是字典时的*号会获取可迭代对象的 key（索引/键值）

理解：因为key指定的是位置。

def func(n1, n2, n3, n4, n5):
    return n1, n2, n3, n4, n5
    
d = {'n1': 5, 'n2': 6, 'n3': 7, 'n4': 8, 'n5': 9}
print(func(*d))

输出：

('n1', 'n2', 'n3', 'n4', 'n5')

实参是其他类型的，带*，先将*后的值打散成位置实参(将多个值依次解压为位置实参)

def func(x,y,z):
    print(x,y,z)
func(*[11,22,33]) # 相当于func(11，22，33)
l=[11,22,33]
func(*l)

输出：

11 22 33
11 22 33

形参与实参中都带有 *

def func(x,y,*args): # args=(3,4,5,6)
    print(x,y,args)
func(1,2,[3,4,5,6])
func(1,2,*[3,4,5,6]) # 相当于func(1,2,3,4,5,6)
func(*'hello') #相当于 func('h','e','l','l','o')

输出：

1 2 ([3, 4, 5, 6],)
1 2 (3, 4, 5, 6)
h e ('l', 'l', 'o')

**和关键字参数有关

可变关键字参数长度

def func(x,y,**kwargs):
    print(x,y,kwargs)

func(y=222,x=111,a=333,b=444)
#222 111 {'a':333,'b':444}
func(**{'y':222,'x':111,'a':333,'b':4444})
#111 222 {'a': 333, 'b': 4444}    

输出：

111 222 {'a': 333, 'b': 444}
111 222 {'a': 333, 'b': 4444}

**+形参名：​

用来接收溢出的关键字实参，** 会将溢出的关键字实参保存成字典格式，然后赋值给紧跟其后的形参名, **后跟的可以是任意名字，但是约定俗成应该是kwargs

def func(x,y,**kwargs):
    print(x,y,kwargs)
func(1,y=2,a=1,b=2,c=3)

输出：

1 2 {'a': 1, 'b': 2, 'c': 3}

**+实参(只能跟字典)

def func(n1, n2, n3, n4, n5):
    return n1, n2, n3, n4, n5
    
d = {'n1': 5, 'n2': 6, 'n3': 7, 'n4': 8, 'n5': 9}
# 这里的字典key值必须和函数的形参一致，否则就不认识
print(func(**d))
# 相当于 print(func(n1 = 5, n2 = 6, n3 = 7, n4 = 8, n5 = 9))
print(func(n1 = 5, n2 = 6, n3 = 7, n4 = 8, n5 = 9))

输出：

(5, 6, 7, 8, 9)
(5, 6, 7, 8, 9)

混用*与**：*args必须在**kwargs之前

def index(x,y,z):
    print(type(x))
    print('index=>>> ',x,y,z)
 
def wrapper(*args,**kwargs):
    #args=(1,) kwargs={'z':3,'y':2}
    #print(**kwargs) #会报错，不存在**kwargs
    print(kwargs)
    print(args)
    print(type(args)) #是tuple,进入函数后被*解压了就成了int
    index(*args,**kwargs)
    # index(*(1,),**{'z':3,'y':2})
    # index(1,z=3,y=2)

wrapper(1,z=3,y=2) # 为wrapper传递的参数是给index用的

输出：

{'z': 3, 'y': 2}
(1,)
<class 'tuple'>
<class 'int'>
index=>>>  1 2 3

---

完美，let’s enjoy it~

---

参考链接来源

感谢原作者们的工作。
https://www.cnblogs.com/Henry121/p/12519639.html 相当棒~
https://blog.csdn.net/Candance_star/article/details/90758635