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

使用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

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

我知道这是一本字典。当我使用Scala查找此操作时，我发现（双关语）

使用Scala有没有一种惯用的方法

---

额外的问题：我可以像

my_dict={foo:bar for foo，bar in list if bar>0}

一样使用这个操作进行过滤吗？

首先，让我们分析一下Python代码，看看它在做什么

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

另一方面，如果它真的是列表，并且您希望提取第一个列表来生成键，并将其余的保存为值，那么

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

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

您可以使用

collect

来选择其中一些。例如，可能您只需要长度为2的列表（如果x.head>0，您可以

获取示例），在这种情况下，您可以

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

或者，如果它实际上是一个
列表
，您也可以

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

以下是几个例子：

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)): _*)

val列表=向量（向量（1,2）、向量（3,4）、向量（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=（对于（序列（a，b）（a，b）}：）
val m6=Map（listOfLists.collect{case Seq（a，b）=>（a，b）}:*）
val m7=Map（（对于（Seq（a，b）我将在Scala2.x和Python3.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> 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)

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> 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)

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>val pairs=Seq（1->“a”，2->“b”，3->“c”，4->“d”）
成对：Seq[（Int，String）]=列表（（1，a）、（2，b）、（3，c）、（4，d））
scala>vald1=（对于（（k，v）aa，2->bb，3->cc，4->dd）
scala>vald2=Map（成对映射{case（k，v）=>（k*2，v）}:*）
d2:scala.collection.immutable.Map[Int，String]=Map（2->a，4->b，6->c，8->d）
scala>vald3=pairs映射{case（k，v）=>（k*2，v）}toMap
d3:scala.collection.immutable.Map[Int，String]=Map（2->a，4->b，6->c，8->d）
scala>vald4:Map[Int，String]=（对于（（k，v）aa，2->bb，3->cc，4->dd）
列表的类型是什么？
包含预期的输入和输出会很有帮助，您发布的代码片段对我来说非常神秘。@sjrd说它是一个列表[列表[对象]]