标签: iterable-unpacking

假设我们有以下内容:

args = (4,7,5)
def foo(a,b,c): return a*b%c

Python方便地允许元组解包:

foo(4,7,5)             # returns 3
foo(*args)             # returns foo(4,7,5), i.e. 3

所以我们不必这样做:

foo(t[0], t[1], t[2])  # a repulsive, verbose, and error-prone synonym

现在假设我们有一个类似的3元组列表,并希望列出foo(t)每个元组的列表t.有"一种明显的方法":

list(map(lambda t: foo(*t), listoftuples))

但现在假设foo只是一个扔掉的功能.我们不希望垃圾污染我们的命名空间.让我们在匿名的地毯下扫一扫!:

list(map(lambda t: (lambda a, b, c: a*b%c)(*t), listoftuples))

好吧,我们现在有嵌套的lambda.当然,我们可以解析它.但是我们冒着被误认为是一个阴谋家的风险,这个阴谋家喜欢构造神秘的法术,其唯一目的就是为那些冒昧的人重新审视我们的代码.

此外,对于这样一个简单的想法,这有点冗长.这似乎不是pythonic.(在scala中,相当于内部lambda (_*_%_),假设上下文允许类型推断.如果这是 pythonic,它不会同样简洁吗？).

我们可以这样删除内部lambda:

list(map((lambda t: t[0] * t[1] % t[2]), listoftuples))

那更短,但令人厌恶.我发现使用幻数(而不是名称)来引用参数往往会导致错误.

如果它看起来更像这样会很棒:

list(map((lambda a, b, c: a*b%c), listoftuples))

当然,它不可能.这就像打电话一样foo(args).我们需要一个星号,可以这么说.这是一个可能的星号:

def unpackInto(func): return lambda …

Scipy 的ttest_1samp返回一个元组，其中包含 t 统计量和双尾 p 值。

例子：

ttest_1samp([0,1,2], 0) = (array(1.7320508075688774), 0.22540333075851657)

但我只对 t 检验（t 统计量）的浮动感兴趣，我只能通过使用来获得[0].ravel()[0]

例子：

ttest_1samp([0,1,2], 0)[0].ravel()[0] = 1.732

然而，我很确定一定有一种更Pythonic的方法来做到这一点。从该输出中获取浮点数的最佳方法是什么？

我对Python语法不太熟悉,并且想知道是否有人可以向我解释变量match是如何for对此函数中的表达式中找到的字符串进行的:

def find_project(project_name):    
    projects = get_projects()    
    try:
        match, = (proj for proj in projects if proj["name"].strip() == project_name)
        return match
    except ValueError:
        return None

我偶然发现了一个我无法解释的解包问题.

这有效:

tuples = [('Jhon', 1), ('Jane', 2)]

for name, score in tuples:
    ...

这也有效

for id, entry in enumerate(tuples):
    name, score = entry
    ...

但这不起作用:

for id, name, score in enumerate(tuples):
    ...

抛出一个ValueError: need more than 2 values to unpack例子.

假设有以下列表： foo = [(1, 2, 3, 4), (5, 6, 7, 8)]

有没有办法遍历列表并仅解包内部元组的前两个元素？

这是一个常见的模式：{a: b for a, b, _, _ in foo}，但是如果foo被修改（程序更改）并且元组现在包含 5 个元素而不是 4 个元素（列表理解需要相应地修改），则会中断。我真的很喜欢命名元素而不是调用{f[0]: f[1] for f in foo}，所以理想情况下，会有某种“吸收所有未解压的变量”，因此可以调用{a: b for a, b, absorb_rest in foo}. 如果可能的话，元组中包含多少个元素并不重要（只要至少有 2 个）。

我试图找出在列表中解包迭代器的pythonic方法是什么。

例如：

my_iterator = zip([1, 2, 3, 4], [1, 2, 3, 4])

我提供了以下几种在列表中解压缩迭代器的方法：

1）

my_list = [*my_iterator]

2）

my_list = [e for e in my_iterator]

3）

my_list = list(my_iterator)

No 1）是我最喜欢的方法，因为它减少了代码，但是我想知道这是否也是pythonic方法。或者，也许除了Python 3之外，还有另一种方法可以实现这一目标？

我正在编写一些代码并犯了一个错字，但没有错误。回溯起来，我发现这些工作有效：

>>> [] = []
>>> () = ()
>>> 

这是可迭代的解包，但没有真正的分配目标。为什么 Python 允许这样做？在某些情况下这很有用吗？

这是在语法中定义的地方。我本以为你至少需要一个identifier、attributeref、subscription或slicing，但显然不需要；target_list在圆括号或中括号内是可选的。

target ::=  identifier
            | "(" [target_list] ")"
            | "[" [target_list] "]"
            | attributeref
            | subscription
            | slicing
            | "*" target

查看文档历史，这在最近的Python 3.4和2.6中是不可能的，但分配到是在Python 3.5和2.7以及Python 3.6中[]添加的。()

有关的：

• 为什么分配给空列表有效但分配给空元组无效？（答案最终是一个bug）
• 为什么分配给空列表（例如 [] = ""）不会出错？（答案更多地谈论如何而不是为什么）

注意：由于我询问的是设计选择，因此答案应包括对官方文档或核心开发等权威来源的引用。

SyntaxError在列表或生成器理解中使用时，带星号的表达式会引发。

我很好奇这背后的原因；它是一种实现选择还是存在阻止此操作的技术限制？

我发现了很多关于不允许解包迭代的上下文，但没有说明原因。

例子：

lis = [1, 2, 3, 4, 5]
listcomp = [*lis for i in range(3)]

我想也许我可以用它来获得[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]结果，但它提高了

SyntaxError("Iterable unpacking 不能用于理解中")

我几周前开始学习python(之前没有编程知识),并且遇到了与解包序列相关的以下问题,这让我很困惑.

出于某种原因,当我尝试这个:

for b, c in [1,2]:
    print b,c

我收到一条错误消息:

TypeError:'int'对象不可迭代

当我尝试用元组替换列表时会发生同样的情况(1,2)

但是当我尝试同样的事情时,只需要列表中的元组:

for b, c in [(1,2)]:
    print b,c

它有效 - 我得到:

1 2

这是为什么？

谢谢.

顺便说一下我使用的是Python 2.7

假设我有一个两元素元组列表和一个(非元组)文字列表,例如整数:

a = [('x', 'a'), ('y', 'b'), ('z', 'c')]
b = [1, 2 ,3]

我想列出三元素元组,所以我编码如下:

zipped = zip((t[0] for t in a), (t[1] for t in a), b)
assert zipped == [('x', 'a', 1), ('y', 'b', 2), ('z', 'c', 3)]

我当前的代码工作得很好,但我想知道有更高效和优雅的配方,但我的代码必须迭代并解压缩每个元组两次.任何人都可以建议吗？