标签: iterable-unpacking

我怎么能解压一个未知的元组,比如一个列表呢？

我有许多数据列,它们通过某些函数分成一个元组.我想将这个元组解压缩到变量,但我不知道我会有多少列.有没有办法动态解压缩到我需要的变量？

谢谢你的帮助 :)

在Haskell中你可以写:

x :: (Int,Int) -> Int
x (p,s) = p

在Scala中你会写:

def x(a: (Int, Int)) = a._1

要么:

def x(a: (Int, Int)) = a match {
    case (p, s) => p
}

为什么不喜欢这样的东西

def x(_: (p: Int, s: Int)) = p

要么

def x(foo: (p @ Int, s @ Int)) = p

？

在Python中，我可以写这样的东西：

some_list = [(1, 2, 3), (3, 2, 1)]

for i, *args in some_list:
   print(args)

我将得到下一个输出：

[2, 3]
[2, 1]

当我们用作*args函数参数时，它会被解压缩到tuple.

为什么我们会list在这种情况下收到 a ？

请考虑以下字符串构建语句:

s="svn cp %s/%s/ %s/%s/" % (root_dir, trunk, root_dir, tag)

使用四个%s可能会令人困惑,所以我更喜欢使用变量名:

s="svn cp {root_dir}/{trunk}/ {root_dir}/{tag}/".format(**SOME_DICTIONARY)

何时root_dir,tag并且trunk在一个类的范围内定义,使用self.__dict__效果很好:

s="svn cp {root_dir}/{trunk}/ {root_dir}/{tag}/".format(**self.__dict__)

但是当变量是本地的时,它们没有在字典中定义,所以我使用字符串连接代替:

s="svn cp "+root_dir+"/"+trunk+"/ "+root_dir+"/"+tag+"/"

我发现这个方法很混乱,但我不知道使用内联局部变量构造字符串的任何方法.

当变量是本地变量时,如何使用变量名构造字符串？

更新:使用该locals()功能完成了诀窍.

请注意,允许混合局部变量和对象变量!例如,

s="svn cp {self.root_dir}/{trunk}/ {self.root_dir}/{tag}/".format(**locals())

我遇到过这样的代码：

from random import randint

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

points = [Point(randint(1, 10), randint(1, 10)) for _ in range(10)]
xs = [point.x for point in points]
ys = [point.y for point in points]

而且我认为这段代码不是Pythonic，因为它会重复。如果将另一个维度添加到Point类中，则需要编写一个全新的循环，如下所示：

zs = [point.z for point in points]

所以我试图通过写这样的东西来使它更像 Pythonic：

xs, ys = zip(*[(point.x, point.y) for point in p])

如果添加了新的维度，没问题：

xs, ys, zs = zip(*[(point.x, point.y, point.z) for point in p])

但是当有数百万个点时，这几乎比其他解决方案慢10 倍，尽管它只有一个循环。我认为这是因为 …

假设我在这样的列表中有一个元组:

>>> t = [("asdf", )]

我知道列表总是包含一个1元组.目前我这样做:

>>> dummy, = t
>>> value, = dummy
>>> value
'asdf'

是否有更短更优雅的方式来做到这一点？

使用以下两个R向量,我想提取valMe使用布尔值的子集boolMe.此外,我想有两个可能的输出,一个在那里在FALSE值boolMe是从中省略valMe,和一个其中该FALSE值由NA替换.进一步说明我想在代码中做什么:

输入

boolMe<-c(FALSE, TRUE, TRUE, TRUE, FALSE, TRUE)
valMe<-1:6

预期输出

NA 2 3 4 NA 6

要么

2 3 4 6

问题:编写一个__init__直接将集合作为参数而不是解压缩其内容的优缺点是 什么？

上下文:我正在编写一个类来处理数据库表中几个字段的数据.我遍历一些大的(约1亿行)查询结果,一次将一行传递给执行处理的类.每行作为元组从数据库中检索(或者可选地,作为字典).

讨论:假设我对三个字段感兴趣,但传递给我的类的内容取决于查询,查询由用户编写.最基本的方法可能是以下之一:

class Direct:
    def __init__(self, names):
        self.names = names

class Simple:
    def __init__(self, names):
        self.name1 = names[0]
        self.name2 = names[1]
        self.name3 = names[2]

class Unpack:
    def __init__(self, names):
        self.name1, self.name2, self.name3 = names

以下是可能传递给新实例的行的一些示例:

good = ('Simon', 'Marie', 'Kent')                 # Exactly what we want
bad1 = ('Simon', 'Marie', 'Kent', '10 Main St')   # Extra field(s) behind
bad2 = ('15', 'Simon', 'Marie', 'Kent')           # Extra field(s) in front
bad3 = ('Simon', 'Marie')                         # …

我现在正在使用Python 3.5解释器,发现了非常有趣的行为:

>>> (1,2,3,"a",*("oi", "oi")*3)
(1, 2, 3, 'a', 'oi', 'oi', 'oi', 'oi', 'oi', 'oi')
>>> [1,2,3,"a",*range(10)]
[1, 2, 3, 'a', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ('aw','aw',*range(10),*(x**2 for x in range(10)))
('aw', 'aw', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
>>> {"trali":"vali", **dict(q=1,p=2)}
{'q': 1, 'p': 2, 'trali': 'vali'}
>>> {"a",1,11,*range(5)}
{0, 1, 2, 3, 4, 11, 'a'}

尽管我有多年的Python经验,但我从未在文档和示例中以及任何源代码中看到过这种情况.我发现它非常有用. …

我试图在 R（例如，a, *b, c = [1,2,3], "C"）中使 Python 3 样式的赋值解包成为可能，尽管我非常接近（您可以在此处查看我的代码），但我最终还是遇到了一些（奇怪的）问题。

我的代码是这样工作的：

a %,*% b %,% c <- c(1,2,3,4,5)

并将分配a= 1、b=c(2,3,4)和c= 5（我的代码实际上确实做到了这一点，但有一个小问题我稍后会讲到）。

为了让它做任何事情，我必须定义：

`%,%` <- function(lhs, rhs) {
   ...
}

和

`%,%<-` <- function(lhs, rhs, value) {
   ...
}

（以及%,*%和%,*%<-，它们是先前函数的轻微变体）。

第一个问题：为什么[R替代*tmp*的lhs参数

据我所知，R 首先从左到右评估这段代码（即，从a到c，直到它到达最后一个%,%，然后，它从右到左返回，沿途分配值。但是第一个我注意到的奇怪的事情是，当我做match.call()或substitute(lhs)在类似的事情中x %infix% …