我正在编写一个Makefile,我想使用带有通配符的通用规则,比如
%: bkp/%
cp $< $@
但我希望此规则仅对少数特定文件有效.例如,我想用列表定义变量
file_list = foo.c bar.c zzz.c
并配置规则,使其仅对此变量中列出的文件有效.我怎么做？
我有一个我想要规范化的向量列表(在Python中),同时删除最初具有小规范的向量.
输入列表例如是
a = [(1,1),(1,2),(2,2),(3,4)]
我需要输出为(x*n,y*n),其中n =(x*2 + y*2)** - 0.5
例如,如果我只需要规范,那么列表理解就很容易:
an = [ (x**2+y**2)**0.5 for x,y in a ]
例如,也可以很容易地存储一个标准化的x,但我想要的是将这个临时变量"n"用于两次计算,然后抛弃它.
我也不能只使用lambda函数,因为我还需要n来过滤列表.那么最好的方法是什么？
现在我在这里使用这个嵌套列表理解(在内部列表中有一个表达式):
a = [(1,1),(1,2),(2,2),(3,4)]
[(x*n,y*n) for (n,x,y) in (( (x**2.+y**2.)**-0.5 ,x,y) for x,y in a) if n < 0.4]
# Out[14]:
# [(0.70710678118654757, 0.70710678118654757),
# (0.60000000000000009, 0.80000000000000004)]
内部列表生成带有额外值(n)的元组,然后我将这些值用于计算和过滤.这真的是最好的方式吗？我应该注意哪些可怕的低效率？
我想创建一个像NumPy一样工作的Python模块。这些方法不仅是模块源中树的叶子中的子模块。有一个包含许多我可以直接调用的方法的根模块，还有一些子模块。问题是根方法必须在某处定义。我当时想拥有一个目录结构：
module/
__init__.py
core.py
stuff1.py
submodule/
__init__.py
stuff2.py
stuff3.py
现在，我希望将“ core”内部的所有内容导入“ module”命名空间，就好像它是一个module.py文件，而core.py的内容都在此module.py内部。问题在于模块是目录而不是文件，那么如何定义应该位于模块根目录中的这些方法？
我尝试将“ from core import *”放在init .py中，但这没有用。（编辑：实际上是。）
我是否应该在“ module.py”文件以及模块目录中包含核心方法？我不知道这是否可行，但是看起来很尴尬。
我正在创建一个map-reduce框架，现在我正在尝试创建一个builder类来实例化处理管道。该构建器需要保存用户指定的功能列表，以便稍后可以使用这些功能作为实例化Worker对象的参数来构造管道。
我正在使用案例类创建函数“所有者”，也为“工人”创建函数。我的问题是，当我继续分析持有人时，如果我对它们进行模式匹配，由于类型擦除，该函数的类型信息似乎会丢失。这是一些最少的代码，似乎可以重现我遇到的问题。
trait Holders
case class MapHolder[A, B](f: A => B) extends Holders
trait Worker
case class MapWrk[A, B](f: A => B) extends Worker
object MyTypeErasureProblem extends App {
val myFunc = MapHolder((x: Int) => x + 10)
def buildWorker(hh: Holders) =
hh match {
case MapHolder(f) => MapWrk(f)
}
println(buildWorker(myFunc).f(10))
}
编译器错误是
Error:(22, 35) type mismatch;
found : Nothing => Any
required: A => Any
case MapHolder(f) => MapWrk(f)
^
Error:(26, 33) type mismatch;
found : Int(10)
required: Nothing …我喜欢我的代码有一个"自上而下"的结构,这意味着我想要与Clojure中的自然完全相反:函数在使用之前被定义.这应该不是问题,因为理论上declare我理论上我的所有功能都是第一个,然后继续享受生活.但它似乎在实践declare中无法解决每一个问题,我想了解以下代码无法正常工作的原因.
我有两个函数,我想通过组合这两个函数来定义第三个函数.以下三段代码实现了这一点:
1
(defn f [x] (* x 3))
(defn g [x] (+ x 5))
(defn mycomp [x] (f (g x)))
(println (mycomp 10))
2
(defn f [x] (* x 3))
(defn g [x] (+ x 5))
(def mycomp (comp f g))
3
(declare f g)
(defn mycomp [x] (f (g x)))
(defn f [x] (* x 3))
(defn g [x] (+ x 5))
但我真正想写的是
(declare f g)
(def mycomp (comp f g))
(defn f [x] …要在Python(scipy/numpy)中的两个向量之间执行外部产品,您可以使用外部函数,或者您可以简单地使用这样的点:
In [76]: dot(rand(2,1), rand(1,2))
Out[76]:
array([[ 0.43427387, 0.5700558 ],
[ 0.19121408, 0.2509999 ]])
现在的问题是,假设我有一个向量列表(或两个列表......),我想计算所有外部产品,创建一个方形矩阵列表.我怎么这么容易？我相信蒂莫多能够做到这一点,但是怎么样？
以下Scala代码有效:
object ReducerTestMain extends App {
type MapOutput = KeyVal[String, Int]
def mapFun(s:String): MapOutput = KeyVal(s, 1)
val red = new ReducerComponent[String, Int]((a: Int, b: Int) => a + b)
val data = List[String]("a", "b", "c", "b", "c", "b")
data foreach {s => red(mapFun(s))}
println(red.mem)
// OUTPUT: Map(a -> 1, b -> 3, c -> 2)
}
class ReducerComponent[K, V](f: (V, V) => V) {
var mem = Map[K, V]()
def apply(kv: KeyVal[K, V]) = {
val KeyVal(k, v) = …