首页 / PYTHON / python – 解包,扩展解包和嵌套扩展解包

python – 解包,扩展解包和嵌套扩展解包

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了python – 解包,扩展解包和嵌套扩展解包，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8344字，纯文字阅读大概需要12分钟。

内容图文

考虑一下这些表达方式……请耐心等待…这是一个很长的清单……

(注意：重复一些表达式 – 这只是为了呈现“上下文”)

a, b = 1, 2                          # simple sequence assignment
a, b = ['green', 'blue']             # list asqignment
a, b = 'XY'                          # string assignment
a, b = range(1,5,2)                  # any iterable will do


                                     # nested sequence assignment

(a,b), c = "XY", "Z"                 # a = 'X', b = 'Y', c = 'Z' 

(a,b), c = "XYZ"                     # ERROR -- too many values to unpack
(a,b), c = "XY"                      # ERROR -- need more than 1 value to unpack

(a,b), c, = [1,2],'this'             # a = '1', b = '2', c = 'this'
(a,b), (c,) = [1,2],'this'           # ERROR -- too many values to unpack


                                     # extended sequence unpacking

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

a, *b = 'X'                          # a = 'X', b = []
*a, b = 'X'                          # a = [], b = 'X'
a, *b, c = "XY"                      # a = 'X', b = [], c = 'Y'
a, *b, c = "X...Y"                   # a = 'X', b = ['.','.','.'], c = 'Y'

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

a, *b, c, *d = 1,2,3,4,5             # ERROR -- two starred expressions in assignment

(a,b), c = [1,2],'this'              # a = '1', b = '2', c = 'this'
(a,b), *c = [1,2],'this'             # a = '1', b = '2', c = ['this']

(a,b), c, *d = [1,2],'this'          # a = '1', b = '2', c = 'this', d = []
(a,b), *c, d = [1,2],'this'          # a = '1', b = '2', c = [], d = 'this'

(a,b), (c, *d) = [1,2],'this'        # a = '1', b = '2', c = 't', d = ['h', 'i', 's']

*a = 1                               # ERROR -- target must be in a list or tuple
*a = (1,2)                           # ERROR -- target must be in a list or tuple
*a, = (1,2)                          # a = [1,2]
*a, = 1                              # ERROR -- 'int' object is not iterable
*a, = [1]                            # a = [1]
*a = [1]                             # ERROR -- target must be in a list or tuple
*a, = (1,)                           # a = [1]
*a, = (1)                            # ERROR -- 'int' object is not iterable

*a, b = [1]                          # a = [], b = 1
*a, b = (1,)                         # a = [], b = 1

(a,b),c = 1,2,3                      # ERROR -- too many values to unpack
(a,b), *c = 1,2,3                    # ERROR - 'int' object is not iterable
(a,b), *c = 'XY', 2, 3               # a = 'X', b = 'Y', c = [2,3]


                                     # extended sequence unpacking -- NESTED

(a,b),c = 1,2,3                      # ERROR -- too many values to unpack
*(a,b), c = 1,2,3                    # a = 1, b = 2, c = 3

*(a,b) = 1,2                         # ERROR -- target must be in a list or tuple
*(a,b), = 1,2                        # a = 1, b = 2

*(a,b) = 'XY'                        # ERROR -- target must be in a list or tuple
*(a,b), = 'XY'                       # a = 'X', b = 'Y'

*(a, b) = 'this'                     # ERROR -- target must be in a list or tuple
*(a, b), = 'this'                    # ERROR -- too many values to unpack
*(a, *b), = 'this'                   # a = 't', b = ['h', 'i', 's']

*(a, *b), c = 'this'                 # a = 't', b = ['h', 'i'], c = 's'

*(a,*b), = 1,2,3,3,4,5,6,7           # a = 1, b = [2, 3, 3, 4, 5, 6, 7]

*(a,*b), *c = 1,2,3,3,4,5,6,7        # ERROR -- two starred expressions in assignment
*(a,*b), (*c,) = 1,2,3,3,4,5,6,7     # ERROR -- 'int' object is not iterable
*(a,*b), c = 1,2,3,3,4,5,6,7         # a = 1, b = [2, 3, 3, 4, 5, 6], c = 7
*(a,*b), (*c,) = 1,2,3,4,5,'XY'      # a = 1, b = [2, 3, 4, 5], c = ['X', 'Y']

*(a,*b), c, d = 1,2,3,3,4,5,6,7      # a = 1, b = [2, 3, 3, 4, 5], c = 6, d = 7
*(a,*b), (c, d) = 1,2,3,3,4,5,6,7    # ERROR -- 'int' object is not iterable
*(a,*b), (*c, d) = 1,2,3,3,4,5,6,7   # ERROR -- 'int' object is not iterable
*(a,*b), *(c, d) = 1,2,3,3,4,5,6,7   # ERROR -- two starred expressions in assignment


*(a,b), c = 'XY', 3                  # ERROR -- need more than 1 value to unpack
*(*a,b), c = 'XY', 3                 # a = [], b = 'XY', c = 3
(a,b), c = 'XY', 3                   # a = 'X', b = 'Y', c = 3

*(a,b), c = 'XY', 3, 4               # a = 'XY', b = 3, c = 4
*(*a,b), c = 'XY', 3, 4              # a = ['XY'], b = 3, c = 4
(a,b), c = 'XY', 3, 4                # ERROR -- too many values to unpack

你如何理解这种复杂性和混乱.在手动计算这些表达式的结果时,如何总是正确的.或者,在阅读别人的代码时,我应该忽略它们,而不是试图理解表达式实际上在做什么吗？

解决方法:

我对这篇文章的篇幅感到抱歉,但我决定选择完整性.

一旦你了解了一些基本规则,就不难概括它们.我会尽力用一些例子来解释.既然你正在谈论“手动”评估这些,我会建议一些简单的替换规则.基本上,如果所有迭代都以相同的方式格式化,您可能会发现理解表达式更容易.

仅出于解包的目的,以下替换在=的右侧有效(即对于rvalues)：

'XY' -> ('X', 'Y')
['X', 'Y'] -> ('X', 'Y')

如果您发现某个值未解压缩,那么您将撤消替换. (有关详细说明,请参见下文.)

此外,当你看到“裸”逗号时,假装有一个顶级元组.在左侧和右侧执行此操作(即对于左值和右值)：

'X', 'Y' -> ('X', 'Y')
a, b -> (a, b)

考虑到这些简单的规则,这里有一些例子：

(a,b), c = "XY", "Z"                 # a = 'X', b = 'Y', c = 'Z'

应用上述规则,我们将“XY”转换为(‘X’,’Y’),并覆盖parens中的裸逗号：

((a, b), c) = (('X', 'Y'), 'Z')

这里的视觉对应使得任务的工作方式非常明显.

这是一个错误的例子：

(a,b), c = "XYZ"

按照上述替换规则,我们得到以下内容：

((a, b), c) = ('X', 'Y', 'Z')

这显然是错误的;嵌套结构不匹配.现在让我们看看它如何适用于一个稍微复杂的例子：

(a,b), c, = [1,2],'this'             # a = '1', b = '2', c = 'this'

应用上述规则,我们得到

((a, b), c) = ((1, 2), ('t', 'h', 'i', 's'))

但现在从结构中可以清楚地看出,’this’不会被解压缩,而是直接分配给c.所以我们撤消替换.

((a, b), c) = ((1, 2), 'this')

现在让我们看看当我们将c包装在一个元组中时会发生什么：

(a,b), (c,) = [1,2],'this'           # ERROR -- too many values to unpack

变

((a, b), (c,)) = ((1, 2), ('t', 'h', 'i', 's'))

同样,错误是显而易见的. c不再是裸变量,而是序列内的变量,因此右侧的相应序列被解压缩到(c,)中.但序列的长度不同,因此存在错误.

现在使用*运算符进行扩展解包.这有点复杂,但它仍然相当简单.以*开头的变量将成为一个列表,其中包含未分配给变量名的相应序列中的任何项.从一个相当简单的例子开始：

a, *b, c = "X...Y"                   # a = 'X', b = ['.','.','.'], c = 'Y'

这变成了

(a, *b, c) = ('X', '.', '.', '.', 'Y')

分析这个的最简单方法是从最终开始工作. ‘X’分配给a,’Y’分配给c.序列中的其余值放在列表中并分配给b.

像(* a,b)和(a,* b)这样的左值只是上述的特例.在一个左值序列中不能有两个*运算符,因为它不明确.在b或c中,值会在何处(a,* b,* c,d)出现？我马上就会考虑嵌套的情况.

*a = 1                               # ERROR -- target must be in a list or tuple

这里的错误是相当不言自明的.目标(* a)必须是元组.

*a, = (1,2)                          # a = [1,2]

这是有效的,因为有一个裸露的逗号.应用规则……

(*a,) = (1, 2)

由于除了* a之外没有其他变量,* a会覆盖rvalue序列中的所有值.如果用单个值替换(1,2)怎么办？

*a, = 1                              # ERROR -- 'int' object is not iterable

变

(*a,) = 1

同样,这里的错误是不言自明的.你不能解压缩不是序列的东西,而*需要解压缩的东西.所以我们把它按顺序排列

*a, = [1]                            # a = [1]

哪个是等价的

(*a,) = (1,)

最后,这是一个常见的混淆点：(1)与1相同 – 你需要一个逗号来区分元组和算术语句.

*a, = (1)                            # ERROR -- 'int' object is not

现在进行嵌套.实际上这个例子不在你的“NESTED”部分;也许你没有意识到它是嵌套的？

(a,b), *c = 'XY', 2, 3               # a = 'X', b = 'Y', c = [2,3]

变

((a, b), *c) = (('X', 'Y'), 2, 3)

顶级元组中的第一个值被分配,顶级元组(2和3)中的剩余值被分配给c – 正如我们所期望的那样.

(a,b),c = 1,2,3                      # ERROR -- too many values to unpack
*(a,b), c = 1,2,3                    # a = 1, b = 2, c = 3

我已经解释了为什么第一行会抛出错误.第二行是愚蠢的,但这就是为什么它的工作原理：

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

如前所述,我们从最终开始工作.将3分配给c,然后将剩余的值分配给变量前面的*,在本例中为(a,b).所以这相当于(a,b)=(1,2),这恰好有效,因为有适当数量的元素.我想不出有任何理由会出现在工作代码中.同样的,

*(a, *b), c = 'this'                 # a = 't', b = ['h', 'i'], c = 's'

变

(*(a, *b), c) = ('t', 'h', 'i', 's')

从末尾开始,’s’被分配给c,(‘t’,’h’,’i’)被分配给(a,* b).从末尾再次工作,’t’被分配给a,而(‘h’,’i’)被分配给b作为列表.这是另一个不应该出现在工作代码中的愚蠢示例.

内容总结

以上是互联网集市为您收集整理的python – 解包,扩展解包和嵌套扩展解包全部内容，希望文章能够帮你解决python – 解包,扩展解包和嵌套扩展解包所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/715406.html

来源：【匿名】

【上一篇】python – 如何排序字符串列表？【下一篇】浅谈PHP运行Python脚本的方法

更多 ►

【python – 解包,扩展解包和嵌套扩展解包】教程文章相关的互联网学习教程文章

python——for循环嵌套，写成一个列表生成式(列表生成式中列表嵌套字典)【代码】

[{‘name1‘:‘Jack‘},{‘name2‘:‘Lara‘}]------>得到[name1, name2]for循环嵌套，列表生成式写法：alist=[{‘name1‘:‘Jack‘},{‘name2‘:‘Lara‘}] b = [j for one in alist for j in one] print(b) for循环嵌套，普通写法：alist=[{‘name1‘:‘Jack‘},{‘name2‘:‘Lara‘}] blist=[] for one in alist:for k,v in one.items():blist.append(k) print(blist)[{‘a‘:‘1‘,‘b‘:‘11‘},{‘a‘:‘2‘,‘b‘:‘21‘}...

python 实现l list嵌套dict转tree【代码】【图】

1。算法实现：待被处理的数据结构： 2.目标效果：设计思路：dict.setdefault(k,v),如果存在k,返回dict的k的v，否则添加{k:v}并返回他的v，def list_to_tree(data):i = 0res = {}for v in data:v["parent_id"] = v["parent_id"] if v["parent_id"] else 0res.setdefault(v["id"], v).update(v)res.setdefault(v["parent_id"], {}).setdefault("children", []).append(res.get(v["id"], v))return res[0]["children"] 实现逻辑...

python 更改嵌套作用域中的变量【代码】

‘‘‘def outer(): num = 10 def inner(): #修改num nonlocal num num = 20 print("在inner里打印num =", num) inner() print("在outer里打印num =", num)outer()‘‘‘def outer(): num = 10 def inner(): nonlocal num num = 20 def little(): nonlocal num num = 30 print("在little里打印Num =", num) little()...

如何在Python中安全地创建嵌套目录【代码】

检查文件目录是否存在的最优雅方法是什么，如果不存在，如何使用Python创建目录？这是我以前使用过的方法： import osfile_path = "/my/directory/filename.txt" directory = os.path.dirname(file_path)try:os.stat(directory) except:os.mkdir(directory) f = file(filename) 不知何故，我错过了os.path.exists。现在推荐使用这个方法： def ensure_dir(file_path):directory = os.path.dirname(file_path)if not os.pat...

python 嵌套字典赋值出现相同值问题【代码】

错误代码：import copy lists={} test=[‘s1‘,‘s2‘,‘s3‘] data = {‘value‘: ‘‘,} for i in range(2):lists[i] = datafor j in range(2):lists[j][‘value‘]=test[j]print(lists)结果：Connected to pydev debugger (build 182.5107.22) {0: {‘value‘: ‘s2‘}, 1: {‘value‘: ‘s2‘}} 改正后代码import copy lists={} test=[‘s1‘,‘s2‘,‘s3‘] data = {‘value‘: ‘‘,} for i in range(2):lists[i] = copy.dee...

48 Python - 装饰器函数嵌套及跨域访问【图】

02函数嵌套及跨域访问001函数嵌套要点：返回的函数名有括号返回的是结果，没有括号返回的是对象地址 002函数作用域原文：https://www.cnblogs.com/yijiexi/p/11165813.html

python学习（五）for循环嵌套-九九乘法表【图】

一、 for和while写99乘法表二、break 循环控制原文：https://www.cnblogs.com/jiliangceshi/p/12933551.html

也说性能测试，顺便说python的多进程嵌套多线程【代码】

最近需要一个web系统进行接口性能测试，这里顺便说一下性能测试的步骤吧，大概如下　　一、分析接口频率　　根据系统的复杂程度，接口的数量有多有少，应该优先对那些频率高，数据库操作频繁的接口进行性能测试，所以先和开发根据业务情况，找到频率最高的几个接口。　　二、找到合适的测试工具　　性能测试工具简直数不胜数，最著名莫过于loadrunner，因为它支持windows，呵呵呵，这也是我刚毕业时用的工具（当然是盗版了。。。）...

21：python 循环嵌套【图】

Python 语言允许在一个循环体里面嵌入另一个循环。Python for循环嵌套语法：foriterating_varinsequence: foriterating_varinsequence: statements(s)statements(s)Pythonwhile 循环嵌套语法：whileexpression: whileexpression: statement(s)statement(s)你可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环，反之，你可以在for循环中嵌入while循环。21.1 for循环嵌套问题描述：我们需要在屏幕上打印一个...

python基础之函数(动态参数，注释，名称空间，第一类对象及使用和函数嵌套)【代码】

函数的动态参数1.函数的动态参数位置参数，默认参数动态参数的作用 *args? 1.能够接受不固定长度参数? 2.位置参数过多时可以使用动态参数动态参数的用法：def func(*c): #形参位置上的 * 是聚会print(*c) #函数体中的 * 就是打散 #func(1,2,3,4,5,6,7,8,9,0)**def eat(a,b,*args): #位置参数，动态位置参数** print(a,b,args) #结果：面条包子 ('饺子', '馅饼', '馒头') print(a,b,*args) #带上*是打散面条包子饺子馅...

PYTHON压平嵌套列表【代码】【图】

list 是 Python 中使用最频繁的数据类型, 标准库里面有丰富的函数可以使用。不过，如果把多维列表转换成一维列表(不知道这种需求多不多),还真不容易找到好用的函数，要知道Ruby、Mathematica、Groovy中可是有flatten的啊。如果列表是维度少的、规则的，还算好办例如:li=[[1,2],[3,4],[5,6]] print [j for i in li for j in i] #or from itertools import chain print list(chain(*li)) #or a=[[1,2],[3,4],[5,6]] t=[] [t.extend(i...

Python中函数的嵌套及闭包【代码】

函数的嵌套调用：在函数中调用函数定义：在函数中定义函数地址：函数名有内存地址，内存地址可赋值示例a = 1 def outer():a = 1def inner():a = 2def inner2():nonlocal aa += 1inner2()print(‘##a## : ‘, a)inner()print(‘**a** : ‘,a)OUTER = outerOUTER() print(‘全局：‘,a)nonlocal:声明了一个上层局部变量（寻找上层最近的局部变量）用于局部变量中不可变数据类型的修改；仅在python3中有用函数的闭包闭包一定是嵌套...

python库--flask--创建嵌套蓝图【代码】

这里没有对内容进行py文件分割, 可以自己根据框架自己放入对应位置以下代码生成一个 /v1/myapp/test 的路由from flask import Flask app = Flask(__name__)from flask import Blueprint # 二级蓝图 myapp = Blueprint('v1/myapp', __name__) @myapp.route("/test", methods=["GET"]) def test():passfrom flask import Blueprint class NestableBlueprint(Blueprint):def register_blueprint(self, blueprint, **options):def defe...

python------函数嵌套及作用域链【代码】【图】

python------函数嵌套及作用域链1.三元运算if条件成立的结果 if 条件 else 条件不成立的结果例如：　　a=20　　b=10　　c=a if a>b else b　　print(c)2.命名空间全局命名空间：创建的存储“变量名与值的关系”的空间叫做全局命名空间　局部命名空间：在函数的运行中开辟的临时的空间叫做局部命名空间　内置命名空间：内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿...

python基础(3) 运算符优先级、位运算符、条件判断语句、while循环、循环嵌套【代码】

一、运算符优先级以下表格列出了从最高到最低优先级的所有运算符：运算符描述**指数运算（优先级最高）~ + -按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)* / % //乘，除，取模和取整除+ -加法减法>> <<右移，左移运算符&位 ‘AND‘^ |位运算符<= < > >=比较运算符<> == !=等于运算符= %= /= //= -= += *= **=赋值运算符is is not身份运算符in not in成员运算符not>and>or逻辑运算符可以用（）来控制优先级，（）内的优...

首页 / PYTHON / python – 解包,扩展解包和嵌套扩展解包

python – 解包,扩展解包和嵌套扩展解包

内容导读

内容图文

内容总结

内容备注

内容手机端

【python – 解包,扩展解包和嵌套扩展解包】教程文章相关的互联网学习教程文章

python——for循环嵌套，写成一个列表生成式(列表生成式中列表嵌套字典)【代码】

python 实现l list嵌套dict转tree【代码】【图】

python 更改嵌套作用域中的变量【代码】

如何在Python中安全地创建嵌套目录【代码】

python 嵌套字典赋值出现相同值问题【代码】

48 Python - 装饰器函数嵌套及跨域访问【图】

python学习（五）for循环嵌套-九九乘法表【图】

也说性能测试，顺便说python的多进程嵌套多线程【代码】

21：python 循环嵌套【图】

python基础之函数(动态参数，注释，名称空间，第一类对象及使用和函数嵌套)【代码】

PYTHON压平嵌套列表【代码】【图】

Python中函数的嵌套及闭包【代码】

python库--flask--创建嵌套蓝图【代码】

python------函数嵌套及作用域链【代码】【图】

python基础(3) 运算符优先级、位运算符、条件判断语句、while循环、循环嵌套【代码】

PYTHON - 相关标签

嵌套 - 相关标签

PYTHON - 技术教程分类

PYTHON - 最新教程

PYTHON - 最热教程