标签: iterable-unpacking

*运算符在Python 中的含义是什么,例如在代码中zip(*x)或f(**k)？

1. 如何在解释器内部处理？
2. 它会影响性能吗？是快还是慢？
3. 什么时候有用,什么时候不用？
4. 它应该用于功能声明还是通话中？

我正在尝试存储std::tuple不同数量的值,这些值稍后将用作调用与存储类型匹配的函数指针的参数.

我创建了一个简化的示例,显示了我正在努力解决的问题:

#include <iostream>
#include <tuple>

void f(int a, double b, void* c) {
  std::cout << a << ":" << b << ":" << c << std::endl;
}

template <typename ...Args>
struct save_it_for_later {
  std::tuple<Args...> params;
  void (*func)(Args...);

  void delayed_dispatch() {
     // How can I "unpack" params to call func?
     func(std::get<0>(params), std::get<1>(params), std::get<2>(params));
     // But I *really* don't want to write 20 versions of dispatch so I'd rather 
     // write something like:
     func(params...); // Not legal
  }
}; …

如果我有一个字典,如:

{ 'a': 1, 'b': 2, 'c': 3 }

我怎样才能将它转换成这个？

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

我怎么能把它转换成这个？

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

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

(注意:重复一些表达式 - 这只是为了呈现"上下文")

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 …

我经常发现自己与元组的列表,序列和迭代器一起工作,并希望做类似以下的事情,

val arrayOfTuples = List((1, "Two"), (3, "Four"))
arrayOfTuples.map { (e1: Int, e2: String) => e1.toString + e2 }

但是,编译器似乎从不同意这种语法.相反,我最终写作,

arrayOfTuples.map { 
    t => 
    val e1 = t._1
    val e2 = t._2
    e1.toString + e2 
}

这真是太傻了.我怎么能绕过这个？

在数学和计算机科学中,元组是元素的有序列表.在集合论中,(有序的)n元组是n个元素的序列(或有序列表),其中n是正整数.

因此,例如,在Python中,元组的第二项将通过访问t[1].

在Scala中,只能通过奇怪的名称进行访问t._2.

所以问题是,为什么我不能按照定义访问元组中的数据作为序列或列表？有什么想法或者还没有检查过吗？

我正在阅读一些旧代码,试图理解它的作用,我偶然发现了这个奇怪的声明:

*x ,= p

p是这个上下文中的列表.我一直试图弄清楚这句话的作用.据我所知,它只是设置x为的值p.例如:

p = [1,2]
*x ,= p    
print(x)

只是给

[1, 2]

这有什么不同x = p吗？知道这个语法在做什么吗？

Python语言(尤其是3.x)允许对迭代的非常一般的解包,其中一个简单的例子就是

a, *rest = 1, 2, 3

多年来,这种拆包已经逐渐推广(参见例如PEP 3132和PEP 448),允许它在越来越多的情况下使用.因此,我惊讶地发现以下是Python 3.6中的无效语法(并且在Python 3.7中仍然如此):

def f():
    rest = [2, 3]
    return 1, *rest  # Invalid

我可以通过将返回的元组封装在括号中来使其工作,如下所示:

def f():
    rest = [2, 3]
    return (1, *rest)  # Valid

我在return声明中使用它的事实似乎很重要,因为

t = 1, *rest

确实是合法的,无论有没有括号都会产生相同的结果.

Python开发人员是否忘记了这种情况,或者有没有理由说明这种情况是无效的语法？

为什么我在乎

这破坏了我认为我使用Python语言的重要合同.考虑以下(也是有效的)解决方案:

def f():
    rest = [2, 3]
    t = 1, *rest
    return t

通常,当我有这样的代码时,我认为t是一个临时名称,我应该能够摆脱简单地t用它的定义替换底线.但在这种情况下,这会导致无效代码

def f():
    rest = [2, 3]
    return 1, *rest

当然,在返回值周围放置括号当然没什么大不了的,但通常需要额外的括号来区分几种可能的结果(分组).这不是这种情况,因为省略括号不会产生一些其他不需要的行为,而是根本没有行为.

今天,我看到一个没有例外的声明.任何人都可以解释它背后的理论吗？

>>> x, y = {'a': 2, 'b': 5}
>>> x
'a'
>>> y
'b'

当已知Python列表始终包含单个项目时,是否可以访问它而不是:

mylist[0]

你可能会问,'你为什么要这样？'.仅好奇心.似乎有另一种方法可以在Python中完成所有工作.