概述

  • 1、乘法运算符；
  • 2、打包：函数形参表示可变参数；
  • 3、解包：函数实参代表tuple；
  • 4、序列解包为tuple；
  • 5、zip解包运算。

如果在其他地方看见了没见过的*作为函数的参数，也不用惊慌，一般而言，要么是作为不定长参数，要么就是对原功能的结构。

具体示例

乘法运算符

在Python中，*表示乘法，**表示次方，这个不必多说。

打包：形参中出现*

  • " * " 在python中做函数形参，可以表示一个可变长度的序列，不过是tuple类型;
  • 而 ** 也可以做形参，而且是dict类型;
  • 他俩可以同时作为函数形参（也可以只有一个），不过若含有他俩的话得把 * 放在前面，而 ** 在后。
def f(*a, **b):
	pass

# a = (1,2,3) , b = {'Name': xx, 'age': yy}
f(1, 2, 3, Name='x', age='yy')
(1) 定义函数时，*运算符将不定长位置参数打包为元组传给args参数。
def fun1(*args):
    for i in args:
        print(i,end=' ')

fun1(1,2,3,4,'a','b')
#输出：1 2 3 4 a b 

(2) **运算符将不定长关键字参数打包为字典传给**kwargs
print(type(args))
#<class 'tuple'>
type(args)显示args为元组类型。

def fun2(**kwargs):
    print(type(kwargs))
    for k,v in kwargs.items():
        print(k,":",v ,end=', ')

fun2(a=1,b=2,c=3)

解包：实参中出现*

作为实参的话， * 相当于对tuple的解构，同样的 ** 则是对dict的解构

def f(a, b, c):
	pass

d = [1, 2, 3]
f(*d) # a = 1, b = 2, c = 3
(1) *将列表[1,2,3,4]解包为1,2,3,4分别传参给a,b,c,d。
def fun3(a,b,c,d):
    print(a,b,c,d,end=' ')

fun3(*[1,2,3,4])
#输出1,2,3,4

(2) **解包字典并传参
def fun4(a,b,c,d):
    print(a,b,c,d,end=' ')

fun4(**{'a':1,'b':2,'c':3,'d':4})
**将字典{'a':1,'b':2,'c':3,'d':4}解包为a=1,b=2,c=3,d=4这4个关键字参数传递给fun4调用

fun4(**{'b':1,'a':2,'c':3,'d':4})
因为是位置参数，解包的字典的元素的key值与参数的key相同。

序列解包运算：

也就是把一段不定长数据转换成list，注意这里不是tuple了，而是List

a, b, *c = 1, 2, 3, 4 # a = 1, b = 2, c = [3, 4]

zip解包运算

a = [1, 2, 3]
b = [4, 5, 6]
c = zip(a, b)
list(c) # [(1, 4), (2, 5), (3, 6)]
d, e = zip(*c)
print(d) # (1, 2, 3)
print(e) # (4, 5, 6)
生成如下的特殊矩阵
0 0 0 0
1 1 1 1
2 2 2 2
3 3 3 3

list(zip(*[range(4)]*4))
--------------------------------------------------------------------
让我们一起来拆解下创建过程

[rang(4)] # 生成一个列表[0,1,2,3]

[range(4)]*4 # 重复4次，生成一个新的列表，列表有4个元素，每个元素为列表[0,1,2,3]内容如下：
			#[
			#   [0,1,2,3],
			#   [0,1,2,3],
			#   [0,1,2,3],
			#   [0,1,2,3]
			#]
			
zip(*[range(4)]*4)
# *[ [0,1,2,3], [0,1,2,3], [0,1,2,3], [0,1,2,3] ]把列表解包为4个列表，传递给zip函数。zip函数可多个可迭代对象组合起来，依次生成n干个元组，第i个元组的每个元素，由对应可迭代对象的第i个值组成。
# 注意：python3的zip返回的是可迭代对象，需要用list()转为列表或其他对象

0->(0,0,0,0),
1->(1,1,1,1),
2->(2,2,2,2),
3->(3,3,3,3)