1 星号的作用
除了重复的作用：
print('-' * 50) # 打印50个横杠
print([1, 2] * 3) # [1, 2, 1, 2, 1, 2]
还有将列表、元组、字典解压的作用：
arr = [1, 2, 3, 4]
a, b, c = *arr # a = 1, b = 2, c = 3; 4没有对象接收args = {'1': 'a', '2': 'b'}
print(*args) # 1 2
针对上述没有对象接收的情况，可以在最后一个变量前面加上一个星号，用于接收剩下所有的值：
a, *b = 1, 2, 3, 4
print(a, b) # 1 [2, 3, 4]
除此之外，当一个对象接收多个值时，会将这些值打包成一个元组。本质上用逗号,分隔开的变量是一个元组。
a = 1, 2
# a = (1, 2)
*用于解压元组和列表，**用于解压字典。
既然如此，上面的代码只展示了一颗星解压字典的代码，两颗星解压字典呢？实际上报错了：'1' is an invalid keyword argument for print()。这是因为 print() 函数只接受特定的关键字参数，如sep、end和file。那么我将字典中的key换成print函数的特定关键字参数：
args = {'sep': 'a', 'end': 'b'}
print(**args)
# 输出b
在实践过程中，当然不会直接打印字典解压的，更多的时候是作为一个形参来传递的。
函数传参
基于上面的分析，我们知道了星号的工作原理。当函数参数列表出现星号的时候，传递参数的方式又是怎样的？
- 一颗星收集剩下所有的参数
# 收集参数
def func1(x=0, *args):print(type(args)) # tupleprint(args)
func1(1, 2, 3, 4) # (2, 3, 4)
- 如果
*args后面多了一个对象d收集参数，那么在调用函数的时候，必须指明d的值单独传入。
# 命名关键字参数
def func2(a, b, c=3, *args, d):print(a, b, c, args, d) # 1 2 4 (5, 6) pass
func2(1, 2, 4, 5, 6, d="pass")
- 此外，如果根据参数列表中的变量名指定传入，那么顺序可以随意，这就要求所有的参数都必须写上，除非在参数列表中就已经完成了初始化
def func3(a, b, c):pass
func3(c=1, a=3, b=5)
- 这两个顺序不能搞反了，必须是先收集列表，再完成关键字参数的收集。通过运行代码可以发现，
**kwargs必须放在参数列表的末尾，否则报错。
def func4(*args, **kwargs):print(args)print(kwargs) # 收集多余的关键字参数func4(1, 2, 3, a=1) # a=1会被放在kwargs里面
# (1, 2, 3)
# {'a': 1}
2 zip函数
zip函数的参数是可迭代对象（iterable object），处理一个列表的结果：
a = [1, 2, 3]
print(zip(a))
# <zip object at 0x00000280B594A7C0>
返回的是一个zip对象的地址，这是一个可迭代对象。由于是一个可迭代对象的地址，因此通常需要转换为列表类型再进行打印查看操作。
for x in zip(a):print(x)
# (1,)
# (2,)
# (3,)
总结：zip将一个可迭代对象中的所有元素打包成一个元组。这样看zip似乎没啥用。实际上它可以传入多个可迭代对象，而且可迭代对象不要求类型相同。
a = [1, 2, 3]
b = [4, 5, 6, 7]
c = (7, 8, 9)zipped_list = list(zip(a, b, c))
print(zipped_list)
# [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
可以发现，zip将相同位置上的元素打包为一个元组，以最短的那个可迭代对象为准。接着解包后再用zip打包,发现列表在第一个维度和第二个维度上完成了一次转置。
print(list(zip(*zipped_list)))
# [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
将维度扩大，列表中的每一个元素不再是数字，而是一个列表对象。将其看成一个整体，那么list(zip(*zipped_list))有3个维度，zip只是最外面的两个维度进行操作。搞清楚zip对张量的处理结果有利于理解深度学习中的一些代码操作。
基于上面的分析，在这里解释一下NLP中对Batch中每个序列填充的操作，原文在我的博客《Transformer全解全析》中：
from torch.nn.utils.rnn import pad_sequencedef collate_fn(batch):src_batch, tgt_batch = zip(*batch)# 0是BERT tokenizer默认的pad_token_idpad_idx = 0 # 填充序列 (Padding)src_padded = pad_sequence(src_batch, batch_first=True, padding_value=pad_idx)tgt_padded = pad_sequence(tgt_batch, batch_first=True, padding_value=pad_idx)return src_padded, tgt_padded
一个batch中包含batch_size个序列对象，一个序列对象包含源序列和目标序列，每一个序列对象都是一张大小为\(S\times d_{model}\)（每个对象的长度不一定相同，即\(S\)不一定一样）的矩阵：
batch = [(src_seq, tgt_seq), (src_seq, tgt_seq), ..., (src_seq, tgt_seq)]
将序列对象这个矩阵看作是一个整体，那么上面代码的操作就是先将列表解包，然后每个元组的第一个位置（存放的是源序列对象）打包成一个长度为batch_size大小的元组，第二个位置是同样的道理：
src_batch = (src_seq, src_seq, ..., src_seq)
tgt_batch = (tgt_seq, tgt_seq, ..., tgt_seq)