标签: iterable-unpacking

我使用 SO问题的答案"迭代元组"来编写一个重载方法<<.这个方法经过测试,似乎可以g++ 4.7在Debian squeeze上正常工作.

然而,这种方法有点迂回,因为它似乎<<无法明确实例化(我在这里发现了一篇关于它的帖子 ).因此,一个人被迫定义一个字符串方法,然后调用它.我有一个类似的矢量方法,更直接.有没有人建议如何消除创建字符串方法的额外步骤,使用相同的方法,或其他？提前致谢.

#include <tuple>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>

using std::ostream;
using std::cout;
using std::endl;
using std::vector;
using std::string;

// Print vector<T>.
template<typename T> ostream& operator <<(ostream& out, const vector<T> & vec)
{
  unsigned int i;
  out << "[";
  for(i=0; i<vec.size(); i++)
    {
      out << vec[i];
      if(i < vec.size() - 1)
    out << ", ";
    }
  out << "]";
  return out;
}

////////////////////////////////////////////////////////////////

// …

我有一个元组列表:

l=[(1,2,3),(4,5,6)]

列表可以是任意长度的,元组也是如此.我想按照它们出现的顺序将其转换为元素的列表或元组:

f=[1,2,3,4,5,6] # or (1,2,3,4,5,6)

如果我知道在开发时我会收到多少元组,我可以添加它们:

m = l[0] + l[1]  # (1,2,3,4,5,6)

但是因为直到运行时我才知道我会有多少元组,所以我不能这样做.我觉得有一种方法可以map用来做到这一点,但我无法弄明白.我可以遍历元组并将它们添加到累加器,但这将创建许多永远不会被使用的中间元组.我还可以遍历元组,然后迭代元组的元素,并将它们附加到列表中.这看起来非常低效.也许有一种更简单的方式让我完全屈服.有什么想法吗？

Octave(/ matlab)用于处理多个返回值的表示法

[a, b] = f(x)

表明f(x)返回的值是一种行向量,而Octave支持向量解包(如Python的元组解包).

然而,当我说

[a, b] = [1, 2]

我明白了

错误:常量表达式的输出参数数量无效

octave是否支持vector-unpacking？

如果是这样,那么正确的符号是什么？

我在文档中找不到任何内容

我想知道这是否可能:

def someFunction():
    return list(range(5))
first, rest = someFunction()

print(first) # 0
print(rest) # [1,2,3,4]

我知道可以通过以下3行完成:

result = someFunction()
first = result[0]
rest = result[1:]

有一次,在看了Mike Muller的性能优化教程(我认为这个)之后,一个想法开始存在于我的脑海中:如果性能很重要,最小化通过索引访问循环中的项目,例如,如果您需要x[1]在循环中多次访问for x in l-为变量赋值x[1]并在循环中重用它.

现在我有了这个合成的例子:

import timeit

SEQUENCE = zip(range(1000), range(1, 1001))

def no_unpacking():
    return [item[0] + item[1] for item in SEQUENCE]


def unpacking():    
    return [a + b for a, b in SEQUENCE]


print timeit.Timer('no_unpacking()', 'from __main__ import no_unpacking').timeit(10000)
print timeit.Timer('unpacking()', 'from __main__ import unpacking').timeit(10000)

unpacking()和no_unpacking()函数返回相同的结果.实现方式不同:unpacking()将项目解包到循环中a和b循环中; no_unpacking()通过索引获取值.

对于python27,它显示:

1.25280499458
0.946601867676

换言之,unpacking()表现优于no_unpacking()约25%.

问题是:

• 为什么通过索引访问会显着减慢事情(即使在这个简单的情况下)？

奖金问题:

• 我也试过这个pypy- …

我有一个几乎没有静态字段的类,并且可以从iterable初始化(比如输出csvreader).在__init__从字符串到数字对于他们中的一些进行类型转换:

class PerformanceTestResult(object):
    def __init__(self, csv_row):
        # csv_row[0] is just an ordinal number of the test - skip that
        self.name = csv_row[1]          # Name of the performance test
        self.samples = int(csv_row[2])  # Number of measurement samples taken
        self.min = int(csv_row[3])      # Minimum runtime (ms)
        self.max = int(csv_row[4])      # Maximum runtime (ms)
        self.mean = int(csv_row[5])     # Mean (average) runtime (ms)
        self.sd = float(csv_row[6])     # Standard deviation (ms)

我正在考虑将它转换为a namedtuple,因为它没有太多其他内容.但我想在初始化期间保持类型转换.有没有办法做到这一点namedtuple？(我没有注意到工厂方法__init__的详细输出中的namedtuple方法,这让我暂停了默认初始化程序的工作原理.)

是否可以将列表中的数字列表解压缩到列表索引中？例如,我在列表中有一个列表,其中包含如下数字:

a = [[25,26,1,2,23], [15,16,11,12,10]]

我需要把它们放在一个模式中,所以我做了这样的事情

newA = []

for lst in a:
    new_nums = [lst[4],lst[2],lst[3],lst[0],lst[1]]
    newA.append(new_nums)

print (newA) # prints -->[[23, 1, 2, 25, 26], [10, 11, 12, 15, 16]]

所以我没有写作new_nums = [lst[4],lst[2],lst[3],lst[0],lst[1]],而是想把一个模式定义为一个被调用的列表pattern = [4,2,3,0,1],然后将它们解压缩到那些lst创建新顺序的索引中lst.

有没有一个很好的方法来做到这一点.

当我尝试在列表理解中解压列表时：

[*parent.rules for parent in parents if hasattr(parent, "rules")]

我收到错误：

SyntaxError: iterable unpacking cannot be used in comprehension

虽然我知道还有其他方法可以做到这一点，但这似乎是最明显和 Pythonic 的方法。为什么 Python 不允许这种行为？

这与新的 Python 3.10 beta 和新语法有关match。有没有什么方法可以检查模式是否简单地包含在可迭代中？最明显的解决方案是简单地在两侧放置两个通配符，但这会SyntaxError由于来自可迭代解包的解包语法而引发。

有没有可能的方法来做到这一点？注意：在示例中使用包装类之类的东西numbers 就可以了，只要它可以使用匹配块并且至少具有一定的可读性，但我已经尝试过这一点，但没有取得太大成功

例子：

numbers = [1, 2, 3, 5, 7, 8, 9] #does not have to be a list, could be a class if needed

match numbers:
    # this just raises a SyntaxError, but I need a way to do something equivalent to this
    case [*_, (5 | 6), *_]:
        print("match!")

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

就我而言，我想使用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 指出的那样，在解包过程中，人们无法提前知道结果的长度，因此在实现方面，包罗万象的内容必须作为动态附加的列表开始。大多数情况下，将其转换为列表是浪费精力。

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