标签: iterable-unpacking

我在想是否有某种方法可以解压缩对象属性。通常这样做涉及一系列：

self.x = x
self.y = y
... #etc.

但是，应该可以做得更好。

我正在考虑类似的事情：

def __init__(self,x,y,z):
  self.(x,y,z) = x,y,z

或者可能：

与 x,y,z 解包（自我）

甚至功能如下：

def __init__(self,x,y,z):
  unpack(self,x,y,z)

有任何想法吗？或者有没有更多的pythonic方法来做到这一点？

刚刚开始使用Haskell,我正在尝试找出基于单个条件分配多个变量的最佳方法.到目前为止,我一直在打包和打开元组.是否有更好/更惯用的方式？

(var1, var2, var3) = 
    if foo > 0
        then ("Foo", "Bar", 3)
        else ("Bar", "Baz", 1)

还对包装和打开元组包装的成本感到好奇.如果我正确地阅读这个,似乎这在函数中得到了优化,但不确定是否是赋值的情况.

我想知道是否可以使用自己的类进行星形解包,而不仅仅是使用list和tuple.

class Agent(object):
    def __init__(self, cards):
        self.cards = cards
    def __len__(self):
        return len(self.cards)
    def __iter__(self):
        return self.cards

并且能够写作

agent = Agent([1,2,3,4])
myfunc(*agent)

但我得到:

TypeError: visualize() argument after * must be a sequence, not Agent

为了使拆包成为可能,我必须实施哪些方法？

我有一些情况需要根据其中一个列表中的值进行过滤.有时我写这样的东西来过滤它们:

lista = [1, 2, 3]
listb = [7, 8, 9]
filtered_a, filtered_b = zip(*[(a, b) for (a, b) in zip(lista, listb) if a < 3])

这给了filtered_a == (1, 2)和filtered_b == (7, 8)

然而,从不断变化的最终状态a < 3,以a < 0导致异常待提高:

Traceback (most recent call last):
  ...
ValueError: need more than 0 values to unpack

我知道为什么会发生这种情况:列表理解是空的,所以就像调用zip(*[])一样zip(),它只返回一个空列表,该列表无法解压缩到单独的filtered_a和filtered_b iterables中.

是否有更好(更短,更简单,更pythonic)的过滤功能来处理空箱？在空的情况下,我希望filtered_a和filtered_b为空迭代,因此任何后续代码都可以保持不变.

在 Python 中，按照惯例，下划线 ( _) 通常用于丢弃解包元组的一部分，如下所示

>>> tup = (1,2,3)
>>> meaningfulVariableName,_,_ = tup
>>> meaningfulVariableName
1

我正在尝试对 lambda 的元组参数执行相同的操作。只能用 2 元组来完成这似乎不公平......

>>> map(lambda (meaningfulVariableName,_): meaningfulVariableName*2, [(1,10), (2,20), (3,30)]) # This is fine
[2, 4, 6]

>>> map(lambda (meaningfulVariableName,_,_): meaningfulVariableName*2, [(1,10,100), (2,20,200), (3,30,300)]) # But I need this!
SyntaxError: duplicate argument '_' in function definition (<pyshell#24>, line 1)

有什么想法吗？实现这一目标的最佳方法是什么？

代码在这里

return self.activator(reduce(lambda a, b: a+b, map(lambda x, w: x*w, zip(input_vec, self.weights)), 0.0) + self.bias)

python2.7-version代码就像 lambda (x, w)

但是现在删除了Tuple参数解压缩，所以我不知道如何找到它:(

在 Python 和 C# 中，如果您有一个元组/列表，您可以使用以下命令将其解压：

tup = (1, 3)
a, b = tup

然后a = 1和b = 3。

在我看来，Java 没有元组，但是如果我有一个已知大小的Vector原始[]数组，那么Java 中的数组/向量是否有类似的解包习惯用法？目前我正在使用以下解决方案。

a = arr[0]
b = arr[1]

其中 arr 是真实元组的替代品。

我愿意接受任何实现类似行为的答案，即使它涉及外部库/附加类/等

这对我来说真的很奇怪，因为默认情况下我认为解包会给出元组。

就我而言，我想使用prefix键进行缓存，因此首选元组。

# The r.h.s is a tuple, equivalent to (True, True, 100)
*prefix, seed = ml_logger.get_parameters("Args.attn", "Args.memory_gate", "Args.seed")
assert type(prefix) is list

但我认为解包会返回一个元组。

以下是相关的 PEP：https ://www.python.org/dev/peps/pep-3132/

- 更新 -

鉴于下面的评论和答案，特别是我期望解包给出一个元组，因为在函数参数中，展开参数始终是一个元组而不是一个列表。

正如 Jason 指出的那样，在解包过程中，人们无法提前知道结果的长度，因此在实现方面，包罗万象的内容必须作为动态附加的列表开始。大多数情况下，将其转换为列表是浪费精力。

从语义上讲，我更喜欢有一个元组以保持一致性。

免责声明:我正在寻找一个Python 2.6解决方案,如果有的话.

我正在寻找一个函数,当传递单个值时返回单个值,或者在传递多个值时返回一个序列:

>>> a = foo(1)
2
>>> b, c = foo(2, 5)
>>> b
3
>>> c
6

要清楚,这是为了使一些函数调用看起来比以下更好:

a, = foo(1)

要么

a = foo(1)[0]

现在,不优雅的解决方案是这样的:

def foo(*args):
    results = [a + 1 for a in args]
    return results if len(results) > 1 else results[0]

是否有任何语法糖(或功能)会让这感觉更清洁？以下任何事情？

def foo(*args):
    return *[a + 1 for a in args]

多年来,我注意到我遇到的各种各样的Python中的'通配符'变量.我认为它像Haskell一样工作:允许你在形式参数中放置一个变量,但不绑定它.

例如,当我不需要其中一个变量时,我已经将它用于元组解包赋值的左侧.

例如:

_, extension = os.path.splitext(filename)

所以当我今天写下类似的东西时:

(lambda (x,_,_): x)((1,2,3))

IE我尝试绑定下划线两次,我收到语法错误.我很惊讶地看到_确实是一个真正的变量:

(lambda (x,_,z): _)((1,2,3))
> 2

看起来就像_一个变量名称一样.

是否有一个真正的通配符变量,我可以按照我的意愿使用(即在一个元组解包分配中能够使用多个),如第一个例子？