标签: iterable-unpacking

在Python中,假设定义了以下函数:

def function(a, b, c):
    ... do stuff with a, b, c ...

我可以使用Python的序列解包来使用该函数:

arguments = (1, 2, 3)
function(*arguments)

Common Lisp中是否存在类似的功能？如果我有一个功能:

(defun function (a b c)
    ... do stuff with a, b, c ...

如果我有3个元素的列表,我可以轻松地使用这3个元素作为函数的参数？

我目前实现它的方式如下:

(destructuring-bind (a b c) (1 2 3)
    (function a b c))

有没有更好的办法？

我想出的是:

keys, values = zip(*[(key, value) for (key, value) in my_dict.iteritems()])

但我不满意.蟒蛇说什么？

有时需要从小集合中创建元组(例如,烫伤框架).

def toTuple(list:List[Any]):scala.Product = ...

是否有一个javascript等同于在python中解压缩序列？

a, b = (1, 2)

我知道解包元组的规范方法是这样的

a, b, c = (1, 2, 3)
# or
(a,b,c) = (1, 2, 3)

但注意到你可以像这样解包一个元组

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

由于某种类型的演员表或列表构造，第二种方法是否会产生任何额外费用？有没有办法检查 python 解释器如何处理这个类似于从编译器查看程序集？

我试图发送方法调用的元组的结果,作为另一个方法的参数列表的一部分.

目标方法

def printResult(title: String, result: Int, startTime: Long, endTime: Long)

从方法,部分参数列表返回

def sendAndReceive(send: Array[Byte]): (Int, Long, Long)

换句话说,我试着打电话printResult(String, (Int, Long, Long)).如果方法返回签名与方法调用匹配,那么我可以使用

(printResult _).tupled(sendAndReceive(heartbeat))

这会导致语法错误

printresult("Hi", Function.tupled(sendAndReceive(heartbeat))

解决方法

我正在手动解压缩元组,然后在调用方法时使用它

val tuple = sendAndReceive(heartbeat)
printResult("Heartbeat only", tuple._1, tuple._2, tuple._3)

是否有一种更优雅的方式来解压缩并将元组作为参数列表的一部分发送？

参考

Scala:在函数参数中分解元组

使用元组作为参数列表调用方法

在Scala中的参数列表中是否会直接支持元组解包？

元组在地图操作中解包

我正在尝试编写一个函数,将表单的字符串'A=5, b=7'转换为字典{'A': 5, 'b': 7}.以下代码片段是主for循环内部发生的- 它们将字符串的单个部分转换为单个dict元素.

这可以:

s = 'A=5'
name, value = s.split('=')
d = {name: int(value)}

这不是:

s = 'A=5'
d = {name: int(value) for name, value in s.split('=')}
ValueError: need more than 1 value to unpack

为什么我不能在字典理解中解包元组？如果我得到这个工作,那么我可以轻松地将整个功能变成一个紧凑的字典理解.

我试图从一个序列解压缩一组电话号码,python shell反过来抛出一个无效的语法错误.我正在使用python 2.7.1.这是片段

 >>> record = ('Dave', 'dave@example.com', '773-555-1212', '847-555-1212')
 >>> name, email, *phone-numbers = record
 SyntaxError: invalid syntax
 >>>

请解释.有没有其他方法做同样的事情？

你如何重写拆包语法的结果*obj和**obj？

例如,你能以某种方式创建一个thing行为如下的对象:

>>> [*thing]
['a', 'b', 'c']
>>> [x for x in thing]
['d', 'e', 'f']
>>> {**thing}
{'hello world': 'I am a potato!!'}

注意:迭代通过__iter__("for x in thing")返回*splat unpack中的不同元素.

我一看operator.mul和operator.pow,但这些功能只关心用途有两个操作数,如a*b和a**b,而且似乎无关的图示操作.

我最近惊讶地发现“splat”（一元 *）运算符总是list在项目解包期间将切片捕获为 a ，即使被解包的序列具有另一种类型：

>>> x, *y, z = tuple(range(5))
>>> y
[1, 2, 3]  # list, was expecting tuple

与不拆包的情况下如何编写此作业进行比较：

>>> my_tuple = tuple(range(5))
>>> x = my_tuple[0]
>>> y = my_tuple[1:-1]
>>> z = my_tuple[-1]
>>> y
(1, 2, 3)

它也与 splat 运算符在函数参数中的行为方式不一致：

>>> def f(*args):
...     return args, type(args)
...
>>> f()
((), <class 'tuple'>)

为了y在解包后恢复为元组，我现在必须写：

>>> x, *y, z = tuple(range(5))
>>> y = tuple(y)

这仍然比基于切片的语法好得多，但仍然受到我认为非常不必要和意外的优雅损失的影响。有没有办法在y没有分配后处理的情况下恢复为元组而不是列表？

我试图y通过写入来强制 python …