注意， 本文的打包和解包的概念有点类似与java 的装箱和解箱
但是还是有点区别
java 中的装箱指的是 把一系列的值让放入1个对象的属性中
而python的打包概念 包括
- 把一组元素打包成1个list or tuple
- 把一系列 key value pair 打包成1个dict
Python * 的基本功能， 乘法
* 首先是1个人乘法符号 例如
python">from loguru import loggerdef process():logger.info(3 * 12) # 36logger.info("hello" * 3) # hellohellohellologger.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.configprocess()
直接的注意的是， * 的乘法不单止 数字乘数字
还包括字符串 乘 整数， 数组乘整数
但是不support string * string , string * float ， string * 数组， 数组 * 数组等
* 的打包功能
第1个例子
python">def sample1():list_num = [1, 2, 3]first, second, rest = list_numlogger.info("first is {}".format(first)) # 1logger.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个元素的数组
是会报错的
python">def sample2():list_num = [1, 2, 3, 4, 5, 6, 7]first, second, rest = list_numlogger.info("first is {}".format(first)) # 1logger.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 sample1first, second, rest = list_num^^^^^^^^^^^^^^^^^^^
ValueError: too many values to unpack (expected 3)
第3个例子
这时我们可以用*rest 去接受剩下的元素， 这时的rest 就是1个数组， 完成了打包的功能
python">def sample3():list_num = [1, 2, 3, 4, 5, 6, 7]first, second, *rest = list_numlogger.info("first is {}".format(first)) # 1logger.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]
还有， 尝试打包两个变量是不允许的
python">first, second, *rest, *rest2 = list_num # Only one unpack operation allowed in listPylance
第4个例子
*打包功能最常用的场景 *args （类似于java 的可变参数 String… strings)
python">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.configsample4()
输出
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 到字典
python">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.configsample5()
这个例子中， print_value的参数 是 *args, **kwargs
意思是除了用*args 接受所有的值类型参数（注意上面的例子是string 和 int 参数混合传入的）， 还可以用**kwargs来接受剩余的 key value pair 参数， 方便！
输出：
python">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
C
现在讲到解包了
第一个例子：
python">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.configsample1()
上面定义了1个普通 print_value() 里面有两个参数
如果直接把数组 person_list 传入肯定是报错的
但是这时可以用 person_list 解包成多个 元素， 所以用person_list 传入是ok的
同样地， **person_dict ， 双星可以为dict 对象解包， 但是对象的属性必须等于参数定义的参数名字！
第2个例子
解包同样常见于list/tuple/dict 合并
python">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.configsample2()
是不是很方便？
注意的是 list 和 tuple 可以互相合并
但是list 和 tuple 都不能和dict 合并
Python 打包和 解包的常用使用情景
打包：
1. 获取从动态多个参数称list/tuple or dict
解包：
2. 把list/tuple or dict 传入 接受普通值参数的函数
3. 合并容器
