map 在某些情况下(当你不是为了这个目的而制作lambda,而是在map和listcomp中使用相同的函数时)可能会在显微镜下更快。在其他情况下,列表理解可能更快,大多数(并非所有)蟒蛇认为它们更直接、更清晰。

使用完全相同的功能时,MAP的微小速度优势示例:

$ python -mtimeit -s'xs=range(10)' 'map(hex, xs)'
100000 loops, best of 3: 4.86 usec per loop
$ python -mtimeit -s'xs=range(10)' '[hex(x) for x in xs]'
100000 loops, best of 3: 5.58 usec per loop

当map需要lambda时,如何完全反转性能比较的示例:

$ python -mtimeit -s'xs=range(10)' 'map(lambda x: x+2, xs)'
100000 loops, best of 3: 4.24 usec per loop
$ python -mtimeit -s'xs=range(10)' '[x+2 for x in xs]'
100000 loops, best of 3: 2.32 usec per loop

Stefano Taschini的“间隔算法:Python实现和应用程序”在Scipy 2008上介绍(参见 here )这是非常宝贵的,因为它可以显示计算中数值不确定性的范围(因此,您可以避免基于过于脆弱的输入数据或方程做出决定)。

由于Stefano在苏黎世的Altis Investment Management AG工作,我很肯定他开发并使用了他的 pyinterval 在金融环境中打包,当然它只是一个通用工具,在其他领域也完全可用。

我想是这样的,因为 创建属性test1时, 绑定到的F1函数 基类A

完全正确。

有什么可能的选择 实现我想要的?

另一个间接级别:

class A(object):
    def f1(self): return []
    def _f1(self): return self.f1()
    test1 = property(_f1)

class B(A):
    def f1(self): return [1, 2]

我知道这听起来很奇怪,但你可以复制到你自己的列表中

request.user.message_set.all()

在实例化requestContext之前,稍后将它们放回..

blip.tv's pycon channel Pycon 2009年和(最近结束)2010年的所有会谈-- 认真地 好东西!从中选择您的谈话 "episodes archive" 页。

在我的(slow ish;-)第一天MacBook Air,1.6GHz Core 2 Duo,MacOSX 10.5上的System python 2.5上,将代码保存在 op.py 我看到以下时间安排:

$ python -mtimeit -s'import op' 'op.f1()'
10 loops, best of 3: 5.58 sec per loop
$ python -mtimeit -s'import op' 'op.f2()'
10 loops, best of 3: 3.15 sec per loop

所以,我的机器比你的慢了1.9倍。

我对这项任务最快的代码是:

def f3(x=x,y=y,n=n,z=z):
    rows = [[0]*y for i in range(x)]
    rr = random.randrange
    inc = (1).__add__
    sat = (0xff).__and__

    for i in range(n):
        inputX, inputY = rr(x), rr(y)
        b = max(0, inputX - z)
        t = min(inputX + z, x)
        l = max(0, inputY - z)
        r = min(inputY + z, y)
        for i in range(b, t):
            rows[i][l:r] = map(inc, rows[i][l:r])
    for i in range(x):
      rows[i] = map(sat, rows[i])

什么时候:

$ python -mtimeit -s'import op' 'op.f3()'
10 loops, best of 3: 3 sec per loop

所以,一个非常温和的加速,在你的机器上投射到超过1.5秒-远高于你的目标1.0:-(。

使用简单的C代码扩展, exte.c ……

#include "Python.h"

static PyObject*
dopoint(PyObject* self, PyObject* args)
{
    int x, y, z, px, py;
    int b, t, l, r;
    int i, j;
    PyObject* rows;

    if(!PyArg_ParseTuple(args, "iiiiiO",
                         &x, &y, &z, &px, &py, &rows
        ))
        return 0;

    b = px - z;
    if (b < 0) b = 0;
    t = px + z;
    if (t > x) t = x;
    l = py - z;
    if (l < 0) l = 0;
    r = py + z;
    if (r > y) r = y;

    for(i = b; i < t; ++i) {
        PyObject* row = PyList_GetItem(rows, i);
        for(j = l; j < r; ++j) {
            PyObject* pyitem = PyList_GetItem(row, j);
            long item = PyInt_AsLong(pyitem);
            if (item < 255) {
                PyObject* newitem = PyInt_FromLong(item + 1);
                PyList_SetItem(row, j, newitem);
            }
        }
    }

    Py_RETURN_NONE;
}

static PyMethodDef exteMethods[] = {
    {"dopoint", dopoint, METH_VARARGS, "process a point"},
    {0}
};

void
initexte()
{
    Py_InitModule("exte", exteMethods);
}

(注:我没有仔细检查过——我认为它不会因为引用窃取和借用的正确相互作用而泄漏内存,但在投入生产之前应该仔细检查代码;—),我们可以这样做。

import exte
def f4(x=x,y=y,n=n,z=z):
    rows = [[0]*y for i in range(x)]
    rr = random.randrange

    for i in range(n):
        inputX, inputY = rr(x), rr(y)
        exte.dopoint(x, y, z, inputX, inputY, rows)

时机

$ python -mtimeit -s'import op' 'op.f4()'
10 loops, best of 3: 345 msec per loop

显示了8-9倍的加速度,这将使你进入你想要的球场。我看到一条评论说你不想要任何第三方扩展,但是,好吧,这个小小的扩展你可以完全自己做;-)。(不确定什么许可条件适用于堆栈溢出时的代码,但如果您需要,我很高兴在Apache2许可证或类似许可证下重新发布它;-)。