我如何使用 Scala 进行地图理解？

Question

有了 Python，我可以做类似

的事情

listOfLists = [('a', -1), ('b', 0), ('c', 1)]
my_dict = {foo: bar for foo, bar in listOfLists}

my_dict == {'a': -1, 'b': 0, 'c': 1} => True

我知道这是字典理解。当我使用 Scala 查找此操作时，我发现 this incomprehensible document（双关语）。

在 Scala 中是否有一种惯用的方法来做到这一点？

额外问题：我可以像 my_dict = {foo: bar for foo, bar in listOfLists if bar > 0} 一样使用此操作进行过滤吗？

Answer 1

首先，让我们解析您的 Python 代码以弄清楚它在做什么。

my_dict = {
  foo: bar       <-- Key, value names
  for foo, bar   <-- Destructuring a list
  in listOfLists <-- This is where they came from
}

因此您可以看到，即使在这个非常短的示例中，实际上也存在相当大的冗余和如果 listOfLists 实际上不是它所说的那样，则有很多失败的可能性是。

如果 listOfLists 实际上是一个对 (key, value) 的列表，那么在 Scala 中它是微不足道的：

listOfPairs.toMap

另一方面，如果它确实是列表，并且您想提取第一个来制作键并将其余部分保存为值，则类似于

listOfLists.map(x => x.head -> x.tail).toMap

您可以 select 使用 collect 代替其中的一些。例如，也许你只想要长度为 2 的列表（你可以 if x.head > 0 得到你的例子），在这种情况下你

listOfLists.collect{
  case x if x.length == 2 => x.head -> x.last
}.toMap

或者如果字面意思是 List，你也可以

listOfLists.collect{
  case key :: value :: Nil => key -> value
}.toMap

Answer 2

这里有几个例子：

val listOfLists = Vector(Vector(1,2), Vector(3,4), Vector(5,6))

val m1 = listOfLists.map { case Seq(a,b) => (a,b) }.toMap
val m2 = listOfLists.collect { case Seq(a,b) if b>0 => (a,b) }.toMap
val m3 = (for (Seq(a,b) <- listOfLists) yield (a,b)).toMap
val m4 = (for (Seq(a,b) <- listOfLists if b>0) yield (a,b)).toMap

val m5 = Map(listOfLists.map { case Seq(a,b) => (a,b) }: _*)
val m6 = Map(listOfLists.collect { case Seq(a,b) => (a,b) }: _*)
val m7 = Map((for (Seq(a,b) <- listOfLists) yield (a,b)): _*)
val m8 = Map((for (Seq(a,b) <- listOfLists if b>0) yield (a,b)): _*)

您可以使用 .toMap 或 Map(xs: _*) 创建 Map。 collect 方法可让您像 map 一样进行过滤。理解使用的语法与您的示例最相似。

Answer 3

我将比较 Scala2.x 中的 list comprehension 和 Python 3.x

1.序列

在python中：

xs = [x*x for x in range(5)]
#xs = [0, 1, 4, 9, 16]

ys = list(map(lambda x: x*x, range(5)))
#ys = [0, 1, 4, 9, 16]

在 Scala 中：

scala> val xs = for(x <- 0 until 5) yield x*x
xs: scala.collection.immutable.IndexedSeq[Int] = Vector(0, 1, 4, 9, 16)

scala> val ys = (0 until 5) map (x => x*x)
ys: scala.collection.immutable.IndexedSeq[Int] = Vector(0, 1, 4, 9, 16)

或者你真的想要一个列表:

scala> import collection.breakOut

scala> val xs: List[Int] = (for(x <- 0 until 5) yield x*x)(breakOut)
xs: List[Int] = List(0, 1, 4, 9, 16)

scala> val ys: List[Int] = (0 until 5).map(x => x*x)(breakOut)
ys: List[Int] = List(0, 1, 4, 9, 16)

scala> val zs = (for(x <- 0 until 5) yield x*x).toList
zs: List[Int] = List(0, 1, 4, 9, 16)

2。集

在Python

s1 = { x//2 for x in range(10) }
#s1 = {0, 1, 2, 3, 4}
s2 = set(map(lambda x: x//2, range(10)))
#s2 = {0, 1, 2, 3, 4}

在 Scala 中

scala> val s1 = (for(x <- 0 until 10) yield x/2).toSet
s1: scala.collection.immutable.Set[Int] = Set(0, 1, 2, 3, 4)

scala> val s2: Set[Int] = (for(x <- 0 until 10) yield x/2)(breakOut)
s2: Set[Int] = Set(0, 1, 2, 3, 4)

scala> val s3: Set[Int] = (0 until 10).map(_/2)(breakOut)
s3: Set[Int] = Set(0, 1, 2, 3, 4)

scala> val s4 = (0 until 10).map(_/2).toSet
s4: scala.collection.immutable.Set[Int] = Set(0, 1, 2, 3, 4)

3。词典

在Python中：

pairs = [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
#d1 = {1: 'aa', 2: 'bb', 3: 'cc', 4: 'dd'}

d2 = dict([(k*2, v) for k, v in pairs])
#d2 = {2: 'a', 4: 'b', 6: 'c', 8: 'd'}

在 Scala 中

scala> val pairs = Seq(1->"a", 2->"b", 3->"c", 4->"d")
pairs: Seq[(Int, String)] = List((1,a), (2,b), (3,c), (4,d))

scala> val d1 = (for((k, v) <- pairs) yield (k, v*2)).toMap
d1: scala.collection.immutable.Map[Int,String] = Map(1 -> aa, 2 -> bb, 3 -> cc, 4 -> dd)

scala> val d2 = Map(pairs map { case(k, v) => (k*2, v) } :_*)
d2: scala.collection.immutable.Map[Int,String] = Map(2 -> a, 4 -> b, 6 -> c, 8 -> d)

scala> val d3 = pairs map { case(k, v) => (k*2, v) } toMap
d3: scala.collection.immutable.Map[Int,String] = Map(2 -> a, 4 -> b, 6 -> c, 8 -> d)

scala> val d4: Map[Int, String] = (for((k, v) <- pairs) yield (k, v*2))(breakOut)
d4: Map[Int,String] = Map(1 -> aa, 2 -> bb, 3 -> cc, 4 -> dd)

我如何使用 Scala 进行地图理解？

How do I do a Map comprehension with Scala?

scala

dictionary-comprehension