小编per*_*iae的帖子

我可以从内联C代码调用python函数(使用weave)吗？

动机:我有一些我想优化的代码,并且我已经确定了一个函数的瓶颈.在我惯常的技巧之后,我通常会转向scipy.weave.inline进行优化.不幸的是,在这种情况下,我的函数在内部循环中调用另一个python函数.我已经确定内部函数没有引起速度问题,我真的不想在C中写它.

最小例子:

from weave import inline

def foo(x):
    return x*2

def bar():
    a = 0
    for i in xrange(10):
        a += foo(i)
    return a

def bar_weave():
    code = """
    int a = 0;
    for (int i=0;i<10;++i){
        a += foo(i);  //<<-- what I'd like to do, but doesn't work
    }
    return_val = a;"""
    return inline(code,['foo'])

print bar()
print bar_weave()

我正在开发一个业余的JVM实现,我正在努力确保我对规范中的所有操作码都有测试覆盖率.我已经得到它倒在过去的几年,但nop和swap已经躲避我.例如,这是一个可能使用的简单函数swap:

static int do_swap() {
  int a = 56;
  int b = 32;
  return b%a;
}

但是生成的字节码javac 1.6避免了交换代替本地存储:

static int do_swap();
  Code:
   0:   bipush  56
   2:   istore_0
   3:   bipush  32
   5:   istore_1
   6:   iload_1
   7:   iload_0
   8:   irem
   9:   ireturn

有任何想法吗？

在Ruby中,你可以调用Enumerable#any吗？在一个可枚举的对象上查看它的任何元素是否满足你在块中传递的谓词.像这样:

lst.any?{|e| pred(e) }

在Python中,有一个any函数可以执行类似的操作,但是在布尔列表中.

当然,对于一个合理大小的列表,我只是这样做:

any(map(pred,lst))

但是,如果我的列表很长,我不希望map首先完成整个操作.

所以,问题是:Python中是否存在通用的短路any功能？

是的,我知道自己写一个是非常简单的,但我想使用快速的内置函数(也不要重新发明任何轮子).

所以我在macbook pro上运行python 2.6并尝试在python中编写代码,以显示tkinter gui上标签中文件的图像.该图像称为image.png.使用此代码时,程序运行没有错误

i = Image.open("image.png")

但是当我执行此代码时(我添加一行):

i = Image.open("image.png")
photo = ImageTk.PhotoImage(i)

程序将崩溃,并在命令行中说"总线错误".我甚至都不知道这意味着什么.我认为PIL安装正确,因为Image工作,但ImageTk不起作用的事实让我困惑.任何人都可以告诉我可能导致此总线错误的原因是什么？

编辑:我做了一个新的程序来进一步测试错误.这是我运行的确切脚本:

import Image
import ImageTk

i = Image.open("image.png")
photo = ImageTk.PhotoImage(i)

现在不是得到"总线错误",而是我的回溯.

Traceback (most recent call last):
  File "imageTest.py", line 5, in <module>
    photo = ImageTk.PhotoImage(i)
  File "/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/site-packages/PIL/ImageTk.py", line 113, in __init__
    self.__photo = apply(Tkinter.PhotoImage, (), kw)
  File "/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/lib-tk/Tkinter.py", line 3285, in __init__
    Image.__init__(self, 'photo', name, cnf, master, **kw)
  File "/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/lib-tk/Tkinter.py", line 3226, in __init__
    raise RuntimeError, 'Too early to create image'
RuntimeError: Too early …

假设您有一些列表,L并且您希望根据某些布尔函数将其拆分为两个列表P.也就是说,你想要的所有元素的一个列表l,其中P(l)是真实的,另一个列表,P(l)是假的.

我可以在Python中实现这一点,如下所示:

def multifilter(pred,seq):
    trues,falses = [],[]
    for x in seq:
        if pred(x):
            trues.append(x)
        else:
            falses.append(x)
    return trues,falses

我的问题:是否有一个函数式编程习惯用来完成这个？

我有一个函数foo,它将NxM numpy数组作为参数并返回标量值.我有一个AxNxM numpy数组data,我想在其上映射foo给我一个长度为A的numpy数组.

当然,我这样做:

result = numpy.array([foo(x) for x in data])

它有效,但似乎我没有利用numpy魔法(和速度).有没有更好的办法？

我看过了numpy.vectorize,numpy.apply_along_axis但是,它们都不适用于2D数组的功能.

编辑:我正在对24x24图像补丁进行增强回归,因此我的AxNxM类似于1000x24x24.我foo上面所说的将一个类似Haar的特性应用于补丁(因此,计算密集程度不是很大).

我很难让node.js在正确的位置写入我的文件.这是我的问题的示范案例:

fs = require('fs');
foo = fs.openSync('foo.txt','r+');
fs.writeSync(foo, "hello", 0, 5, 5);
fs.close(foo);

foo.txt 有一行:

12345678901234567890

预期的输出是为了foo.txt包含12345hello1234567890,但我得到了hello678901234567890.我跑node v0.8.16.

这是一个错误,还是我做错了什么？

编辑:我一直在引用这些文档:fs.writeSync(fd,buffer,offset,length,position)

我有~8000个二维点数组,存储在内存中作为numpy数组的Python列表.每个阵列都有形状(x,2),其中x数字介于~600和~4000之间.基本上,我有一个锯齿状的3-d阵列.

我想以方便/快速的格式存储这些数据,以便从磁盘读取/写入.我宁愿不创建~8000个单独的文件,但(8000,4000,2)如果我可以避免它,我也不愿用零填充整个矩阵.

我应该如何将我的数据存储在磁盘上,以便最小化文件大小和解析/序列化？

我正在写一个广度深度优先树遍历功能,就是我想要做的是这样的:

def traverse(node):
    yield node
    for n in node.children:
        yield_all traverse(n) # << if Python had a yield_all statement

这个想法最终得到了树中的(平面)节点序列.

方法#1 :(传播产量)

def traverse(node):
    yield node
    for n in node.children:
        for m in traverse(n):
            yield m

方法#2 :(展平序列)

def traverse(node):
    return itertools.chain([node],*(traverse(n) for n in node.children))

第一种方法看起来更干净,但我觉得yield在每个级别的子树中明确指出每个节点都很奇怪.

第二种方法是简洁而略显肮脏,但它与我在Haskell中编写的内容相匹配:

traverse node = node : concatMap traverse (children node)

所以我的问题是:哪个更好？或者我错过了最好的第三选择？

我对能够推理其自身时间复杂度的编程语言感兴趣。为此，以某种方式以编程方式表示时间复杂度将非常有用，这将允许我执行以下操作：

f_time = O(n)
g_time = O(n^2)
h_time = O(sqrt(n))

fastest_asymptotically = min(f_time, g_time, h_time)  # = h_time
total_time = f_time.inside(g_time).followed_by(h_time)  # = O(n^3)

我目前正在使用 Python，但我并没有特别依赖于某种语言。我尝试过sympy，但我无法找到我需要的开箱即用的东西。

有没有提供这种功能的库？如果没有，是否有一种简单的方法可以使用符号数学库来执行上述操作？

编辑：我按照@Patrick87的建议编写了一个简单的库，它似乎有效。不过，我仍然对是否有其他解决方案感兴趣。