小编Jas*_*ond的帖子

我正试图从并行集合转换回常规地图.根据api,如果我在任何适当定义的并行集合上调用map,它应该返回一个标准的Map,但是它会在一个扁平的iterables集合上返回ParMap.

我有一个

val task: Stream[Future[Iterable[Tuple2[String, String]]]]

从中得到:

val res: ParSeq[Iterable[Tuple2[String, String]]] = tasks.par.map(f => f.apply())

最后:

val finalresult = res.flatten.toMap

不幸的是,类型finalresult是ParMap[String, String].

另一方面,如果我称之为:

tasks.par.map(f => f.apply()).reduce(_++_).toMap

那么返回类型是Map[String, String].

谁能告诉我为什么会这样？和(出于好奇),我怎么可以强制转换ParMap到Map时斯卡拉不会放过我？

我最近对Django整体感到有点沮丧.似乎我无法完全控制任何事情.我喜欢Python死,但我希望能够(并且免费)做一些简单的事情,就像在自动生成的表单中添加css类一样简单.

我真正喜欢使用的一个MVC框架是Grails(groovy).它有一个FANTASTIC模板系统,它可以让你真正完全控制你想要的.

但是,我对Python过于痴迷.因此,我希望在Web应用程序开发中找到体面而强大的东西.

有什么建议？

可能是挂架？

在创建数据框时(或者在使用cbind的类似情况下)R中是否有一种方法可以将变量计算为列名？

例如

a <- "mycol";
d <- data.frame(a=1:10)

这将创建一个数据框,其中一列命名a而不是mycol.

这比帮助我从代码中删除相当多行的情况要重要得多:

a <- "mycol";
d <- cbind(some.dataframe, a=some.sequence)

我目前的代码遭受了折磨:

names(d)[dim(d)[2]] <- a;

这是美学上的barftastic.

有没有办法在python"持久"中进行子进程调用？我正在调用一个需要一段时间来加载多次的程序.因此,如果我可以让该程序保持打开并与之通信而不会将其删除,那将会很棒.

我的python脚本的卡通版本如下所示:

for text in textcollection:
    myprocess = subprocess.Popen(["myexecutable"],
                stdin = subprocess.PIPE, stdout = subprocess.PIPE,
                stderr = None)
    myoutputtext, err = myprocess.communicate(input=text)

我需要单独处理每个文本,因此将它们全部加入一个大文本文件并处理一次不是一个选项.

最好是,如果有这样的选项

myprocess = subprocess.Popen(["myexecutable"],
            stdin = subprocess.PIPE, stdout = subprocess.PIPE,
            stderr = None)    for text in textcollection:
for text in textcollection:
    myoutputtext, err = myprocess.communicate(input=text)

我可以把这个过程打开,我真的很感激.

在scala中,如何定义两个Option参数的加法？具体来说,让我们说它们是Int类型的包装器(我实际上使用的是双打映射,但这个例子更简单).

我尝试了以下但它只是给了我一个错误:

  def addOpt(a:Option[Int], b:Option[Int]) = {
    a match {
      case Some(x) => x.get
      case None => 0
    } + b match {
      case Some(y) => y.get
      case None => 0
    }
  }

编辑添加:

在我的实际问题中,我添加了两个映射,这些映射是稀疏矢量的替换.因此,无案例返回Map [Int,Double],而+实际上是++(在stackoverflow.com/a/7080321/614684处调整)

我收到一条错误消息"错误:类型参数[Any]不符合trait Cloneable的类型参数bounds [+ A <:AnyRef],"我无法做出正面或反面.

特别,

var M = mutable.Map[Int, mutable.Set[Int]]()
for(i <- 1 to 100; j <- 1 to 100) {
    if(!M.contains(i)) {M += i -> mutable.Set[Int](j)}
    else {M(i) += j} 
}

(我实际上正在尝试更复杂的东西,但这是生成代码的错误,并将其简化为最小化)

并且上面代码的最后一行生成错误消息.如果我进一步剥离它

for(i <- 1 to 100; j <- 1 to 100) {
    if(!M.contains(i)) {M += i -> mutable.Set[Int](j)}
}

有用!

如何使上述代码有效？

我在python中有一个自定义节点类,它构建在一个图形(这是一个字典)中.由于这些需要花费一些时间来创建,我想要腌制它们,这样我每次运行代码时都不必重新构建它们.

不幸的是,因为这个图有周期,所以cPickle会达到最大递归深度:

RuntimeError:在对对象进行pickle时超出了最大递归深度

这是我的节点对象:

class Node:
    def __init__(self, name):
        self.name = name
        self.uid = 0
        self.parents = set()
        self.children = set()

    def __hash__(self):
        return hash(self.name)

    def __eq__(self, that):
        return self.name == that.name

    def __str__(self):
        return "\n".join(["Name: " + self.name,
                          "\tChildren:" + ", ".join([c.name for c in self.children]),
                          "\tParents:" + ", ".join([p.name for p in self.parents])
                          ]
                         )

这是我构建图表的方式:

def buildGraph(input):
    graph = {}
    idToNode = {}

    for line in input:
        ## Input from text line by line looks like
        ## …

我有一些变量lm在R中自动包含反引号/后引号,例如名称中有冒号的变量.

经过一些处理后,我试图写出线性模型的变量和系数write.table.不幸的是,反写也被写出来了.

如何防止这些反复写入？

举一个简单但不切实际的例子:

d <- data.frame(`1`=runif(10), y=runif(10), check.names=F)
l <- lm(y ~ `1`, d)
write.table(data.frame(l$coefficients), file="lm.coeffs", quote=F, sep="\t", col.names=F)

该文件lm.coeffs- 很明显 - `1`在输出的第一列而不是1.在其他一些脚本的后处理之外,如何从输出中删除反引号？

或者valscala对象默认是懒惰的？

无论如何,如果有必要val通过使用声明一个懒惰的对象lazy,是否可以做类似的事情

lazy object SomeObject

或者(就像你在c ++中所做的那样)

object A {
lazy:
    val a
    val b
    ...
}

因为我想要懒惰而不必重新贴上我val的所有lazy val

可能重复:
强制类型差异

由于存在一个在scala中强制执行相等的通用类型约束=:=,是否有一个对类型强制执行"不等于"？基本上!=但对于类型？

编辑

下面的评论指出现有的问答,答案似乎是(1)不,它不在标准库中(2)是的,可以定义一个.

所以我会修改我的问题,因为在看到答案之后我想到了一个想法.

鉴于现有解决方案:

sealed class =!=[A,B]

trait LowerPriorityImplicits {
  implicit def equal[A]: =!=[A, A] = sys.error("should not be called")
}
object =!= extends LowerPriorityImplicits {
  implicit def nequal[A,B](implicit same: A =:= B = null): =!=[A,B] = 
    if (same != null) sys.error("should not be called explicitly with same type")
    else new =!=[A,B]
}     

case class Foo[A,B](a: A, b: B)(implicit e: A =!= B)

如果A <: B或者A >: B …

我在Scala中有以下地图:

var m = Map[Int,Set[Int]]()
m += 1 -> Set(1)
m(1) += 2

我发现最后一行不起作用.我得到"错误:重新分配到val".

所以我试过了

var s = m(1)
s += 2

然后当我m(1)与之相比s之后我加了2,它们的内容是不同的.那么如何将一个元素添加到一个集合中,这是一个映射的值？

我来自Java/C++背景,所以我尝试的对我来说似乎很自然,但显然它不在Scala中.

我正在尝试http://www.scala-lang.org/node/112上的代码,我得到一个匹配错误,看起来不应该抛出一个.

这是原始代码:

object Twice {                              
  def apply(x: Int): Int = x * 2
  def unapply(z: Int): Option[Int] = if (z%2 == 0) Some(z/2) else None
}

object TwiceTest extends Application {
  val x = Twice(21)
  x match { case Twice(n) => Console.println(n) } // prints 21
}

我刚刚添加了几行来测试当我传递奇数时会发生什么:

object TwiceTest extends Application {
  val x = Twice(21)
  x match { case Twice(n) => Console.println(n) } // prints 21
  val y = 21
  y match { case Twice(n) => …