理解 python 中的* 打包和解包

注意， 本文的打包和解包的概念有点类似与java 的装箱和解箱

但是还是有点区别
java 中的装箱指的是 把一系列的值让放入1个对象的属性中

而python的打包概念 包括

1. 把一组元素打包成1个list or tuple
2. 把一系列 key value pair 打包成1个dict

Python * 的基本功能， 乘法

* 首先是1个人乘法符号 例如

from loguru import logger

def process():
    logger.info(3 * 12) # 36
    logger.info("hello" * 3) # hellohellohello
    logger.info([1, 2, 3] * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
    logger.info(["a", "b", "c"] * 3) # ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
    logger.info("hello" * "world") # TypeError: can't multiply sequence by non-int of type 'str'


if __name__ == "__main__":
    import src.configs.config
    process()

直接的注意的是， * 的乘法不单止 数字乘数字
还包括字符串 乘 整数， 数组乘整数
但是不support string * string , string * float ， string * 数组， 数组 * 数组等

* 的打包功能

第1个例子

def sample1():
    list_num = [1, 2, 3]
    first, second, rest = list_num
    logger.info("first is {}".format(first)) # 1
    logger.info("second is {}".format(second)) # 2    
    logger.info("rest is {}".format(rest)) # 3

上面的例子就是一个简单的解包例子
我们用3个变量去接受1个3个元素的数组是可以正常给3个变量赋值的

2024-05-05 23:53:25.407 | INFO     | __main__:sample1:6 - first is 1
2024-05-05 23:53:25.407 | INFO     | __main__:sample1:7 - second is 2
2024-05-05 23:53:25.407 | INFO     | __main__:sample1:8 - rest is 3

第2个例子

这时如果我改写成让3个变量去接受6个元素的数组
是会报错的

def sample2():
    list_num = [1, 2, 3, 4, 5, 6, 7]
    first, second, rest = list_num
    logger.info("first is {}".format(first)) # 1
    logger.info("second is {}".format(second)) # 2    
    logger.info("rest is {}".format(rest)) # too many values to unpack (expected 3)

错误

  File "/home/gateman/Projects/python/python_common_import/src/pack_unpack/star_pack.py", line 5, in sample1
    first, second, rest = list_num
    ^^^^^^^^^^^^^^^^^^^
ValueError: too many values to unpack (expected 3)

第3个例子

这时我们可以用*rest 去接受剩下的元素， 这时的rest 就是1个数组， 完成了打包的功能

def sample3():
    list_num = [1, 2, 3, 4, 5, 6, 7]
    first, second, *rest = list_num
    logger.info("first is {}".format(first)) # 1
    logger.info("second is {}".format(second)) # 2    
    logger.info("rest is {}".format(rest)) # [3, 4, 5, 6, 7]

输出

2024-05-06 00:01:58.114 | INFO     | __main__:sample3:13 - first is 1
2024-05-06 00:01:58.114 | INFO     | __main__:sample3:14 - second is 2
2024-05-06 00:01:58.114 | INFO     | __main__:sample3:15 - rest is [3, 4, 5, 6, 7]

还有， 尝试打包两个变量是不允许的

first, second, *rest, *rest2 = list_num # Only one unpack operation allowed in listPylance  

第4个例子

*打包功能最常用的场景 *args （类似于java 的可变参数 String… strings)

def sample4():
    print_list([1, 2, 3])
    print_list2(1, 2, 3)


def print_list(list_num):
    for i in list_num:
        logger.info(i)

def print_list2(*list_num):
    for i in list_num:
        logger.info(i)

if __name__ == "__main__":
    import src.configs.config
    sample4()

输出

2024-05-06 00:18:04.939 | INFO     | __main__:print_list:31 - 1
2024-05-06 00:18:04.939 | INFO     | __main__:print_list:31 - 2
2024-05-06 00:18:04.939 | INFO     | __main__:print_list:31 - 3
2024-05-06 00:18:04.939 | INFO     | __main__:print_list2:35 - 1
2024-05-06 00:18:04.939 | INFO     | __main__:print_list2:35 - 2
2024-05-06 00:18:04.940 | INFO     | __main__:print_list2:35 - 3

上面定义了两个输出数组的函数
其中print_list1 接受的1个是普通的数组对象

而print_list2 接受的是多个元素， 而且是可以动态打包到 args 变量的
这就是我们常见到的
def func(*args) *args的意思， 自动把传入的动态多个元素参数 打包称1个数组参数

** 的打包功能 - 打包key value pair 到字典

def sample5():
    print_value("abc", 2, 3, a=4,b=5)


def print_value(*args, **kwargs):
    for i in range(len(args)):
        logger.info("args[{}] is {}".format(i, args[i]))
    for key in kwargs:
        logger.info("kwargs[{}] is {}".format(key, kwargs[key]))

if __name__ == "__main__":
    import src.configs.config
    sample5()

这个例子中， print_value的参数 是 *args, **kwargs

意思是除了用*args 接受所有的值类型参数（注意上面的例子是string 和 int 参数混合传入的）， 还可以用**kwargs来接受剩余的 key value pair 参数， 方便！

输出：

2024-05-06 00:31:33.215 | INFO     | __main__:print_value:44 - args[0] is abc
2024-05-06 00:31:33.216 | INFO     | __main__:print_value:44 - args[1] is 2
2024-05-06 00:31:33.216 | INFO     | __main__:print_value:44 - args[2] is 3
2024-05-06 00:31:33.216 | INFO     | __main__:print_value:46 - kwargs[a] is 4
2024-05-06 00:31:33.216 | INFO     | __main__:print_value:46 - kwargs[b] is 5

* 和 ** 的解包功能

现在讲到解包了

第一个例子：

def sample1():
    person_list = ["Jay", 2]
    # print_value(person_list) # error print_value() missing 1 required positional argument: 'age'
    print_value(*person_list)
    person_dict = {"name": "Jade", "age": 3}
    # person_dict = {"firstname": "Jade", "age": 3} # error print_value() got an unexpected keyword argument 'firstname'
    print_value(**person_dict)
    

def print_value(name, age):
    logger.info("name is {}".format(name))
    logger.info("age is {}".format(age))

if __name__ == "__main__":
    import src.configs.config
    sample1()

上面定义了1个普通 print_value() 里面有两个参数
如果直接把数组 person_list 传入肯定是报错的
但是这时可以用 person_list 解包成多个 元素， 所以用person_list 传入是ok的

同样地， **person_dict ， 双星可以为dict 对象解包， 但是对象的属性必须等于参数定义的参数名字！

第2个例子

解包同样常见于list/tuple/dict 合并

def sample2():
    list = [1, 2, 3]
    tuple = (4, 5, 6)
    tuple2 = (*list, *tuple)
    logger.info(tuple2) # (1, 2, 3, 4, 5, 6)

    dict1 = {"name": "Jay", "age": 2}
    dict2 = {"weight": 20, "height": 85}
    dict3 = {**dict1, **dict2}
    logger.info(dict3) # {'name': 'Jay', 'age': 2, 'weight': 20, 'height': 85}



if __name__ == "__main__":
    import src.configs.config
    sample2()

是不是很方便？
注意的是 list 和 tuple 可以互相合并

但是list 和 tuple 都不能和dict 合并

Python 打包和 解包的常用使用情景

打包：
1. 获取从动态多个参数称list/tuple or dict

解包：
2. 把list/tuple or dict 传入 接受普通值参数的函数
3. 合并容器