小编blu*_*fer的帖子

我直接从网上找到的一个例子中得到了这个装饰器:

class TimedOutExc(Exception):
    pass


def timeout(timeout):
    def decorate(f):
        def handler(signum, frame):
            raise TimedOutExc()

        def new_f(*args, **kwargs):

            old = signal.signal(signal.SIGALRM, handler)
            signal.alarm(timeout)

            try:
                result = f(*args, **kwargs)
            except TimedOutExc:
                return None
            finally:
                signal.signal(signal.SIGALRM, old)
            signal.alarm(0)
            return result

        new_f.func_name = f.func_name
        return new_f

    return decorate

如果f函数超时,它会抛出异常.

好吧,它可以工作但是当我在多处理函数上使用这个装饰器并且由于超时而停止时,它不会终止计算中涉及的过程.我怎样才能做到这一点？

我不想启动异常并停止程序.基本上我想要的是当f超时时,让它返回None然后终止所涉及的过程.

我需要这个Matlab 函数的精确 Python 等效函数才能插值矩阵。

在Matlab中我有：

interp2(X, Y, Z, XI, YI) 

在 Scipy 中我有：

interp2d(X, Y, Z). 

在 Scipy 中，XI 和 YI 缺失。我该如何解决这个问题？我在 Matlab 中使用所有参数。

我正在尝试将彩色图像转换为黑白图像.

原始图像如下:

我有一些问题.第一:

import pylab as pl
import Image

im = Image.open('joconde.png')

pl.imshow(im)
pl.axis('off')
pl.show()

我明白了:

它为什么旋转？这不是重点,但我想知道原因.

im_gray = im.convert('1')

pl.imshow(im_gray)
pl.show() 

这是处理过的黑白图像:

现在一切看起来都有效 但我需要将该图像用作numpy数组,以便进行一些图像处理.我所要做的就是:

import numpy as np

im_arr = np.array(im_gray)

pl.imshow(im_arr)
pl.axis('off')
pl.show()

但我明白了:

为什么会这样？我也尝试过:

im_arr = np.array(im_gray, dtype='float')

要么:

im_arr = np.asarray(im_gray)

但似乎没有任何效果.也许问题在于show方法,但我不知道.

我在我的项目中使用多处理.我有一个工作函数,它将结果放入队列中.一切正常.但随着x的大小增加(在我的情况下,x是一个数组)出了问题.这是我的代码的简化版本:

def do_work(queue, x):
    result = heavy_computation_function(x)
    queue.put(result)   # PROBLEM HERE

def parallel_something():
    queue = Queue()
    procs = [Process(target=do_work, args=i) for i in xrange(20)]
    for p in procs: p.start()
    for p in procs: p.join()

    results = []
    while not queue.empty():
        results.append(queue.get)

    return results

我在系统监视器中看到python进程正常工作,但随后发生了一些事情并且所有进程都在运行但什么也没做.这是我输入ctrl-D时得到的.

    pid, sts = os.waitpid(self.pid, flag)
KeyboardInterrupt

我做了一些测试.问题似乎是将结果放入队列实际上如果我不把结果一切都运行但是那样就没有目的了.

我有一个初始化一些全局变量的Python模块; 这样的事情:

#!/usr/bin/env python
import re

"""My awesome python library."""

# A word list from the standard UNIX dictionary.
with open('/usr/share/dict/words', 'rt') as f:
     WORDS_LIST = f.read().split('\n') + ['http'] + ['fubob']

# Some compiled regular expressions.
COMPILED_REG1 = re.compile("a") 
COMPILED_REG2 = re.compile("b")

# Some constants.
A = 10
B = 20

def say_hello(): print('hello')
def do_something(): return 'something'

当然它可以工作,但我觉得这不是正确的方法:每次我导入这个模块时,Python都会执行它.在此示例中,它将读取文件并编译正则表达式.

我读到有些人创建了一个config.py文件并用它做了一些事情,但我不确切知道它是如何工作的.

所以,我想知道如果你必须制作一个标准的Python库,你将如何处理这个问题.

我正在使用python进行对象检测的图像处理.我需要将我的图像分成所有可能的块.例如给出这个玩具图像:

x = np.arange(25)
x = x.reshape((5, 5))

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]

我想检索给定大小的所有可能块,例如2x2块是:

[[0 1]
 [5 6]]
[[1 2]
 [6 7]]

.. 等等.我怎样才能做到这一点？

假设我有一个随机的numpy数组:

X = np.arange(1000)

和一个门槛:

thresh = 50

我想要分割X在两个分区X_l和X_r以这样的方式,在每一个元件X_l是小于或等于thresh而在X_r每个元素是大于thresh.之后,这两个分区被赋予递归函数.

使用numpy我创建一个布尔数组,我用它来分区X:

Z = X <= thresh
X_l, X_r = X[Z == 0], X[Z == 1]
recursive_call(X_l, X_r)

这样做了几次,有没有办法让事情变得更快？是否可以避免在每次调用时创建分区的副本？

我有这个简单的代码:

M = dict.fromkeys([0, 1, 2, 3, 4], [0, 0])
M[0][1] += 2
print(M)

为什么这是输出？

{0: [0, 2], 1: [0, 2], 2: [0, 2], 3: [0, 2], 4: [0, 2]}

它会增加字典中列表的所有元素!我想用键0增加列表的第二个元素,如下所示:

{0: [0, 2], 1: [0, 0], 2: [0, 0], 3: [0, 0], 4: [0, 0]}

我正在尝试在数据库中查询在输入搜索字符串中具有字符串字段的记录。

像这样：

User.query.filter(User.name in search_string)

当然，这不是有效的，因为它不是有效的SQLAlchemy语句。这似乎是一个简单的问题，但我确实找不到合适的列运算符。

我尝试了in_运算符：

User.query.filter(User.name.in_(search_string)

但这当然是行不通的。我需要的是is_substring操作员。

我有一个用Python编写的项目,它可以处理大量数据.我想加快执行时间.

简单来说,假设我有这个示例完全优化的代码:

def foo(x):
   doSomething

main():
   for i in range(1,10000000):
      foo(i)

有没有办法加快这个？例如,通过使用多处理或其他东西？最重要的是,它值得吗？

谢谢你的回复.我想我会尝试多处理的路线.有人可以建议我一个指导或一些帮助我的例子吗？

我已经实现了一个递归函数,它将参数作为一个numpy数组.这里是简化版:

 def rec(arr):

     rec(arr[indices])

在每次递归调用中,我都使用一些索引索引的数组的一部分.

我的问题是关于内存负载:python如何处理这个？它是否在每次通话时复制数组？