Python的解包知识

已于 2023-02-12 23:34:37 修改
阅读量920 收藏 12
点赞数 2
分类专栏： python基础 文章标签： 1024程序员节 python
于 2022-10-24 15:43:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38380338/article/details/127052085
版权

  在Python中的代码中经常会见到 *args 和 **kwargs。args 是 arguments 的缩写，*args表示位置参数；kwargs 是 keyword arguments 的缩写，**kwargs表示关键字参数。
  args 与 kwargs 只是变量名，可以自定义其他变量名，重点在于单星号（*）和双星号（**）的解包操作符。

目录

1. 什么是解包

  • 解包（Unpacking）就是把一个容器拆开、分解，在Python中的解包是自动完成的。
  • 解包操作可以应用于任何可迭代对象，如元组、字典、列表、集合、字符串、生成器等。
  • 在Python3中，解包操作符有 * 和 **，一般情况下：
    • *：用于列表、元组、集合
    • **：用于字典

2. 解包的使用

2.1 无星号解包操作

在Python2中的解包操作是无星号的自动解包，即没有解包操作符，要求 “变量数量 = 元素数量” 。

2.1.1 可迭代对象的解包

① 列表解包

>>> a, b, c = [1,2,3]
>>> a
1
>>> b
2
>>> c
3

② 元组解包

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


>>> a,b,c = enumerate(['a', 'b', 'c'])
>>> a
(0, 'a')

③ 字符串解包

>>> a,b,c = "abc"
>>> a
'a'
>>> b
'b'
>>> c
'c'

④ 字典解包

注意：解包后，只会把字典的 key 取出来，value 丢掉了。

>>> a,b,c = {"a":1, "b":2, "c":3}
>>> a
'a'
>>> b
'b'
>>> c
'c'

⑤ 生成器解包

>>> a,b,c = (x + 1 for x in range(3))
>>> a
1
>>> b
2
>>> c
3

2.1.2 多变量赋值

① 对多个变量同时赋值

>>> a, b = 1, 2
>>> a
1
>>> b
2

上述本质是自动解包的过程，等号右边其实是一个元组对象 (1, 2)

注意：对单个变量赋值数值时，若等号右边的代码不小心多了一个逗号 “,” 就变成了赋值元组对象，因此写代码的时候需要特别注意！

>>> a = 1,
>>> a
(1,)

② 交换两个变量

>>> a, b = 1, 2
>>> a, b = b, a
>>> a
2
>>> b
1

③ 接收函数返回的多个值

def test():
  return 1, 2, 3
  
a, b, c = test()
print(a, b, c)   # 1 2 3

  函数的返回值是一个元组，左侧是三个变量，这样就会发生解包，a, b, c 依次等于元组里的元素，函数的返回值有3个，被封包成了元组。

Python3中，开始支持更高级的解包操作——星号解包操作（ * 和 **），实现了 “变量数量 < 元素数量” 的解包。这个特性可以在 PEP 3132 中看到。

2.2 * 解包操作

2.2.1 可迭代对象的解包

  • 收集元素

  “变量数量 < 元素数量” 情况下，在 任意一个变量面前加一个星号，分配元素时，每个不带星号的变量优先分配一个元素后，剩下的元素都分配给带星号变量。星号变量收集的元素将放入一个列表list内。

>>> a, b, *c = (1,2,3,4)
>>> a
1
>>> b
2
>>> c
[3, 4]

相较于下例切片操作赋值，* 解包使得代码更简洁。

>>> n = [1,2,3,4]
# 使用切片操作
>>> a, b, c = n[0], n[1:-1], n[-1]
>>> a
1
>>> b
[2, 3]
>>> c
4
  • 取出元素
>>>> *range(4), 4
(0, 1, 2, 3, 4)
>>> [*range(4), 4]
[0, 1, 2, 3, 4]
>>> {*range(4), 4}
{0, 1, 2, 3, 4}

注：单星号 * 对字典解包时，只能读取到字典中的键（key）。如下所示：

d = {'x': 1, 'y': 2}
print(*d)  # 输出 x y
  • 拼接元素（取出元素的应用）
>>> list1 = [1,2,3]
>>> list2 = range(3,6)
>>> [*list1, *list3]
[1, 2, 3, 3, 4, 5]

*相较于 +
  虽然列表之间可以用 + 进行拼接，但是 list 类型无法与 range 对象直接通过+ 拼接，必须先将 list2 强制转换为 list 对象才能做 + 拼接。* 使得我们的代码更加优雅！

2.2.2 函数调用时的解包操作

函数调用时，一个星号可作用于所有的可迭代对象，称为迭代器解包操作，作为位置参数传递给函数。

  • 一个单星号的使用

定义如下 func 函数，函数中有三个位置参数 a，b，c，调用该函数必须传入三个参数。

def func(a,b,c):
	print(a,b,c)

>>> func(1,2,3)
1 2 3

也可运用 * 解包含有3个元素的可迭代对象，作为参数传递

>>> func(*[1,2,3])   # 可迭代对象：列表
1 2 3
>>> func(*(1,2,3))   # 可迭代对象：元组
1 2 3
>>> func(*"abc")     # 可迭代对象：字符串
a b c
>>> func(*{"a":1,"b":2,"c":3})    # 可迭代对象：字典
a b c
  • 多个单星号的使用

在Python 3.5 之前的版本，函数调用时一个函数中解包操作只允许一个 * 和 一个 **，而从 3.5 开始，PEP 448 对解包操作做了进一步的扩展，在函数调用中，可以有任意多个解包操作。

如Python 3.4 中，print 函数 不允许多个 * 操作

>>> print(*[1,2,3], *[3,4])
  File "<stdin>", line 1
    print(*[1,2,3], *[3,4])
                    ^
SyntaxError: invalid syntax

Python 3.5 以上版本以使用任意多个解包操作

>>> print(*[1], *[2], 3)
1 2 3

2.3 ** 解包操作

2.3.1 可迭代对象的解包

  • 取出元素
>>> {'x': 1, **{'y': 2}}
{'x': 1, 'y': 2}

注意：在 解包多个字典放入新的字典 时，对相同的键，后者对应的值会覆盖（override）前者对应的值。

>>> {'x': 1, **{'x': 2}}
{'x': 2}

>>> {**{'x': 2}, 'x': 1}
{'x': 1}

注意：调用函数过程中，通过解包多个字典传参时，解包后不允许存在相同关键字，如 f(**{‘x’: 2}, **{‘x’: 3})

  • 拼接元素（取出元素的应用）
>>> a = {"a":1, "b":2}
>>> b = {"c":3, "d":4}
>>> {**a, **b}
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

2.3.2 函数调用时的解包操作

函数调用时，两个星号的解包操作只能作用于字典对象，称之为字典解包操作。解包时会自动解包字典对象成关键字参数 key=value 的格式，传递给函数。

def func(a,b,c):
	print(a,b,c)

>>> func(**{"a":1,"b":2,"c":3})
1 2 3

相较于以下方式，** 解包的好处是节省代码量，使代码看起来更优雅。

>>> d = {"a":1, "b":2, "c":3}
>>> func(a = d['a'], b=d['b'], c=d['c'])
1 2 3

注意：** 解包字典后是 key = value的键值格式。上例字典的 key 值正好 是 func 函数的形参值。但是 print 函数是不能直接打印 ** 解包字典的结果的，如下所示：

c = {"name": 'zhang', "age": 2}
print(**c)

TypeError: 'name' is an invalid keyword argument for print()

  由于 ** 解包出来的数据是这样的 ：**c = name=‘zhang’,age=2。且 print 函数的源码如下：

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
只支持 *args，不支持 **kwargs。因此尝试写成如下形式进行打印输出。 
>>> print("Name:{name}, Age:{age}".format(**c))
Name:zhang, Age:2

2.4 函数定义中 * 和 ** 的混合使用

  • *args 与 **kwargs 是 Python 中 可变参数 的两种形式。
  • 在函数定义中位置参数必须在关键字参数的前面（即*args,**kwargs的顺序）。
  • 在函数定义中，形参的 *args 是接受位置参数的 args，args 是一个元组，把传入的数据放进其中；形参的 **kwargs 是接受关键字参数的 kwargs，kwargs 是一个字典，把传入关键字键值放进其中。
  • 函数调用传入实参时，可变参数(*)之后的参数必须指定参数名传参，否则将被归到可变参数(*)之中。

  如下所示，*args 收集位置参数后传递一个可变参数元组 给函数实参，**para 收集关键字参数后传递一个可变的关键字参数的字典 给函数实参（这些参数的数目未知，甚至长度可以为0）。

def test_kwargs(first, *args, **kwargs):
   print('Required argument: ', first)
   print(type(args))
   print(type(kwargs))
   for v in args:
      print ('Optional argument (args): ', v)
   for k, v in kwargs.items():
      print ('Optional argument %s (kwargs): %s' % (k, v))

test_kwargs(1, 2, 3, 4, k1=5, k2=6)

  正如前面所说的，args 变量的类型是一个 tuple，而 kwargs 变量则是一个字典dict，并且args只能位于kwargs的前面。
  test_kwargs 函数中，第一个参数 first 是形参，是必须要传入的参数，不带关键字的参数则作为可变参数列表传入函数实参，带关键字的参数则作为可变参数字典传入函数实参。所以test_kwargs(1, 2, 3, 4, k1=5, k2=6)中，1作为实参传入了 first；紧接着 2, 3, 4 三个数则作为可变参数列表传入实参，最后的 k1=5, k2=6 中的5,6作为可变参数字典传入实参。

运行结果如下：

Required argument:  1
<class 'tuple'>
<class 'dict'>
Optional argument (args):  2
Optional argument (args):  3
Optional argument (args):  4
Optional argument k2 (kwargs): 5
Optional argument k1 (kwargs): 6

3. 解包的应用

3.1 * 的应用

3.1.1 列表转元组巧妙方法

stars = ["黎明", "华仔", "郭富城", "张学友"]
# 方法一
print("四大天王：%s, %s, %s, %s" % (stars[0], stars[1], stars[2], stars[3]))
# 方法二
print("四大天王：%s, %s, %s, %s" % tuple(stars))
# 方法三
print("四大天王：%s, %s, %s, %s" % (*stars,))

  这三种方式输出结果一致，(*stars,)解包列表并转换了一个元组。

3.1.2 实现类似矩阵转置的操作

a = [[1, 2, 3], [4, 5, 6]]
for x, y in zip(*a):
    print(x, y)

# 1 4
# 2 5
# 3 6

3.1.2 切分嵌套可迭代对象数据

>>> l = [('Bob', '1990-1-1', 60),
...     ('Mary', '1996-1-4', 50),
...     ('Nancy', '1993-3-1', 55)]
>>> for name, *args in l:
...     print(name, args)
...
Bob ['1990-1-1', 60]
Mary ['1996-1-4', 50]
Nancy ['1993-3-1', 55]

3.2 * 和 ** 的应用之装饰器

>>> def mydecorator(func):
...     def wrapper(*args, **kw):
...         print('I am using a decorator.')
...         return func(*args, **kw)
...     return wrapper
...
>>> @mydecorator
... def myfun(a, b):
...     print(a)
...     print(b)
...
>>> myfun(1, b = 2)
I am using a decorator.
1
2

  使用@定义myfun相当于myfun = mydecorator(myfun)，定义出来的myfun其实是返回结果wrapper函数。
  wrapper函数使用*args, **kw作为参数，则被修饰的myfun函数需要的参数无论是什么样的，传入wrapper都不会报错，这保证了装饰器可以修饰各种各样函数的灵活性（毕竟我们一般在函数中传入参数时，要么所有参数名都写，要么前面几个不写，后面的会写，这样使用*args, **kw完全没有问题）。

4. 一些补充

4.1 函数传参时，可变参数(*)前不能指定参数名传参

def myfun(a, *b):
    print(a)
    print(b)
myfun(a=1,2,3,4)

报错如下：

    myfun(a=1,2,3,4)
             ^
SyntaxError: positional argument follows keyword argument

正确的调用方法为：

>>> myfun(1,2,3,4)
1
(2, 3, 4)

4.2 设计调用函数时必须使用参数名传参

  一个函数想要使用时必须明确指定参数名进行传参，可以将这些参数放在可变参数之后。

def myfun(*, a, b):
    print(a)
    print(b)
myfun(a=1, b=2)

4.3 函数定义时，关键字参数只能作为最后一个参数

def myfun(a, *b, c, **d):
    print(a)
    print(b)
    print(c)
    print(d)
myfun(1, 2, w=6, c=3, d=4, e=5)     # 记住可变参数(*)之前不能指定参数名

运行结果如下：

1
(2,)
3
{'w': 6, 'd': 4, 'e': 5}

4.4 _ 与 * 赋值的区别

  • 一些元素不用时，采取分配临时名称“_”存着，可以让读代码的人知道这个元素是不要的，这种写法要求赋值时等号两侧的元素个数必须相等，即“_”相当于一个匿名变量，与普通变量一样只存储一个元素。
  • * 解包使得“变量数量 < 元素数量” 的赋值情况得以实现。

观察下例，“_” 与 “ * ” 的混合使用：

例①

>>> person = ('Bob', 20, 50, (11, 20, 2000))
>>> name, *_, (*_, year) = person
>>> name
'Bob'
>>> year
2000

例②

>>> l = [1,2,3,4,5,6,7,8,9,10,11,12]
>>> a,b,*_,c = l
>>> print(a,b,_,c)
1 2 [3, 4, 5, 6, 7, 8, 9, 10, 11] 12

参考
Python中的*args和**kwargs
Python中星号（*）的使用
Python的解包
python基础语法之拆包(解包)
python中的装包与解包*，**
python有趣的解包用法

揪。
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python - 包的使用详解
demon_or_angle的博客
05-30 730
微信公众号搜索【程序媛小庄】，关注半路出家的程序媛如何靠python开发养家糊口~ 前言 随着模块数目的增多，把所有模块不加区分地放到一起就显得非常不合理了，于是Python为我们提供了一种把模块组织到一起的方法，即创建一个包。 学习包要从两个角度来看，包的设计者和包的使用者。因为包是模块，所以包的使用和普通模块的使用方式是一样的。 什么是包 包就是一个包含__init__.py文件的文件夹，文件夹内可以包含子包或者模块，比如创建如下结构的包结构： package # 包文件夹 |—— __init_.
Python 打包说明
u014291956的专栏
08-05 242
cxfreeze打包过程中最好通过setup.py来进行打包，打包的python程序需由模块+单个文件方式进行组织，否则会出现导入错误(ImportError)，打包的setup.py配置如下： # coding=utf-8 from cx_Freeze import setup, Executable # python setup.py build includefiles = ['RE...
Python中的解包用法
cnds123的专栏
04-04 4865
Python中的解包用法
Python * ** 打包解包 详解
我是菜鸡
11-18 3424
里边出现的英文都来自于python官网的开发者指南1 本文主要就是介绍*和**对此展开详细介绍。 *和**可以用于任意位置的解包。 Specifically, in function calls, in comprehensions and generator expressions, and in displays. 可以用于函数调用、推导式、生成器、显示。 首先先回顾一下range，以及用range生成元组、列表和集合。 li = list(range(7)) print(li) tu = tuple
学会这两个符号*和**，你的 Python 编程水平会飞跃！
最新发布
pythondh1的博客
05-31 260
在Python中，星号（*）和双星号（**）是非常强大的工具，它们可以用来解包、传递可变数量的参数以及更多复杂的操作。理解和掌握它们的用法可以让你的代码更加简洁和高效。
【python语法--解包*运算符】
Z__Danny的博客
12-04 2408
python语法--解包*运算符--你不知道的解包
掌握Python的解包技巧：*和**的最全用法
涛哥聊Python
11-11 444
和**是Python中非常有用的符号，它们用于解包和打包参数，扩展序列和字典，以及在函数参数中接受不定数量的参数。这些功能使Python的函数更加灵活，并有助于编写更通用的代码。
【python基础】两种解包运算符：* 和 **
weixin_44286126的博客
11-29 608
python 有两种解包运算符，分别是 `*` 和 `**`。
关于Python解包知识点总结
12-20
Python 中的解包是自动完成的，例如： student = ['xiaoqiang','man','22'] name,sex,age = student print(name,sex,age) 结果：xiaoqiang man 22 如果列表中有3个元素，那么刚好可以分配给3个变量。除了列表对象...
关于Python形参打包与解包小技巧分享
09-18
总结一下Python形参打包与解包的主要知识点： 1. 散态传递参数：使用`*`来解包元组或列表，如`func(*arg)`。 2. 打包传递参数：使用`()`来创建元组，将参数放入元组中，然后在函数调用时用`*`解包，如`func_exec(*...
学学Python_18语句_赋值语句1（序列解包）
10-11
综上所述，本主题不仅涉及基本的赋值语句，还深入探讨了序列解包这一高级特性，并可能拓展至字符串和字典的操作及方法，这些都是Python编程中不可或缺的知识点。通过学习这些内容，开发者可以更加熟练地处理数据，...
详解Python3序列赋值、序列解包
09-19
主要介绍了Python3序列赋值、序列解包的相关知识，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
python中拆包解包用法详解
IT之一小佬的博客
03-06 2287
python中拆包解包用法详解
解包操作符 python_用解包操作符 * 解包列表
weixin_39662721的博客
12-18 367
文档中常提到的用法是接受不定数量的参数, 最近发现除此之外, * 用来解包list或dict或set真是好用>>> list(range(3, 6)) # normal call with separate arguments[3, 4, 5]>>> args = [3, 6]>>> list(range(*args)) ...
（小甲鱼python）函数笔记合集三 函数(III)总结 函数的收集参数*args **args 解包参数详解
qq_44985415的博客
01-16 752
（小甲鱼python）函数笔记合集三 函数(III)总结 函数的收集参数*args **args 解包参数详解
重要： *args, **kwargs的打包和解包用法
weixin_44162814的博客
11-07 166
当**input当成实参时，表示解包成字典。同理，*input表示解包成元组或列表当是实参时。当**input当成形参定义函数时，表示接收任意个参数打包成字典。同理，*input表示打包成元组或列表。
Python里的*和**操作符详细说明
2301_77778490的博客
09-12 341
是两种特殊的操作符，被称为解包（unpacking）操作符。它们在处理序列（如列表、元组）和字典时非常有用。接下来我会详细解释这两种操作符的用法。操作符在 Python 中的用法非常灵活，上述示例只是其中的一部分。这两个操作符在处理序列和字典时非常有用，可以简化代码并提高可读性。在 Python 中，
【Python】*args，**kwargs 及打包、解包
m0_53127772的博客
01-10 464
*把传入的一系列键值变量打包成一个字典，存入变量 kwargs。然后将 "aaa", a, *b 打包作为 args，x=111, y="bbb", **d 打包作为 kwargs，args 和 kwargs 分别为元组和字典；函数调用时，*和**表示解包。*args表示可以传入任意数量的“值变量”，**kwargs表示可以传入任意数量的键值变量。print可以传入*args参数，但无法传入**kwargs，需要使用.format()首先 *b 和 **d 对 b 和 d 解包，打散成元素和键值；
编程Python习题练习.pdf
11-13
非法的是 `x,y = y,x`，因为这种交换变量的方式需要在Python中使用元组解包 `(x, y) = (y, x)`。正确答案是B．x=(y=z+1)。 5. 高级语言是相对于汇编语言和机器语言而言的，它们更接近人类语言，易于理解和编写。第5...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值