小编Her*_*nan的帖子

我有一个分析代码,使用numpy进行一些繁重的数值运算.只是为了好奇,尝试用cython编译它几乎没有变化,然后我用循环为numpy部分重写它.

令我惊讶的是,基于循环的代码要快得多(8x).我不能发布完整的代码,但我把一个非常简单的无关计算放在一起,显示出类似的行为(虽然时间差异不是很大):

版本1(没有cython)

import numpy as np

def _process(array):

    rows = array.shape[0]
    cols = array.shape[1]

    out = np.zeros((rows, cols))

    for row in range(0, rows):
        out[row, :] = np.sum(array - array[row, :], axis=0)

    return out

def main():
    data = np.load('data.npy')
    out = _process(data)
    np.save('vianumpy.npy', out)

版本2(使用cython构建模块)

import cython
cimport cython

import numpy as np
cimport numpy as np

DTYPE = np.float64
ctypedef np.float64_t DTYPE_t

@cython.boundscheck(False)
@cython.wraparound(False)
@cython.nonecheck(False)
cdef _process(np.ndarray[DTYPE_t, ndim=2] array):

    cdef unsigned int rows = array.shape[0]
    cdef unsigned int cols …

有没有办法在读取和使用Python Pandas写入时保留csv文件中列的顺序？例如,在此代码中

import pandas as pd

data = pd.read_csv(filename)
data.to_csv(filename)

输出文件可能不同,因为不保留列.

对于这个问题:

为什么描述符不能成为实例属性？

有人回答说:

描述符对象需要存在于类中,而不是实例中

因为这是实施的方式__getattribute__.

一个简单的例子.考虑描述符:

class Prop(object):

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj._value * obj._multiplier

    def __set__(self, obj, value):
        if obj is None:
            return self
        obj._value = value

class Obj(object):

    val = Prop()

    def __init__(self):
        self._value = 1
        self._multiplier = 0

考虑每个obj都有多个Prop的情况:我需要使用唯一的名称来标识值和乘数(比如这里.拥有一个每个实例描述符对象将允许将_multiplier(和_value)存储在描述符本身中,简化了一些事情.

要实现每个实例描述符属性,您需要:

1. 创建每个实例类请参见此处
2. 覆盖__getattribute__ 见这里

我知道之前已经提出过类似的问题,但我还没有找到真正的解释:

1. 为什么Python是这样设计的？
2. 存储描述符所需信息但是每个实例的建议方法是什么？

我想更多地了解作为类与闭包实现的"with memory"函数.

考虑(非常)简单的例子:

def constant(value):
    def _inner():
        return value
    return _inner
x = constant(5)
print(x())

与

class Constant():
    def __init__(self, value):
        self._value = value

    def __call__(self):
        return self._value
y = Constant(5)
print(y()) 

这些中的任何一个的性能和内存消耗都更好吗？使用插槽会让课程表现更好吗？

谢谢,

埃尔南

Ps.-我知道在这个极其简单的例子中,可能没关系.但是我对更复杂的函数感兴趣,这些函数将被多次调用或者将被多次实例化.

有没有人试图为python3安装opencv？如此处所述http://opencv.willowgarage.com/wiki/InstallGuide其支持状态未知.所以我想尝试一下:

我已经下载了OpenCV-2.3.1的源代码.但是cmake报道.

- Python解释器:/ Library/Frameworks/Python.framework/Versions/3.2/bin/python3 -B(版本3.2)

- Python numpy:NO(不会生成Python包装器)

我确实在python3中安装了numpy(版本1.6.0),但是cmake找不到它.我正在使用Mac OSX 10.6任何想法？

更新

我刚刚看到cmake输出中的另一个可能有用的东西

- 找到PythonInterp:/Library/Frameworks/Python.framework/Versions/3.2/bin/python3(找到版本"3.2")

- 找到PythonLibs:/usr/lib/libpython2.6.dylib文件"",第1行

from distutils.sysconfig import *; print get_python_lib()

                                                      ^

Run Code Online (Sandbox Code Playgroud)

SyntaxError:无效语法文件"",第1行

import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print

Run Code Online (Sandbox Code Playgroud)

numpy.distutils.misc_util.get_numpy_include_dirs()[0]

                                                                    ^ 

Run Code Online (Sandbox Code Playgroud)

SyntaxError:无效语法文件"",第1行

import sphinx; print sphinx.__version__

                          ^ SyntaxError: invalid syntax

Run Code Online (Sandbox Code Playgroud)

请注意,它发现3.2然后libpython2.6？

有任何想法吗？

我有一个调用DLL的python 2.7程序.我试图将脚本移植到python 3.2.DLL调用似乎工作(即调用时没有错误)但返回的数据没有意义.

以防它可能有用: - 调用有三个参数:两个int(输入)和一个指向ushort数组(输出)的指针.

我尝试过使用python和numpy数组都没有成功.

任何人都可以枚举Python 2.7和3.2之间的差异吗？

提前致谢

编辑

这是一些示例代码.DLL是propietary所以我没有代码.但我确实有C头:

void example (int width, int height, unsigned short* pointer)

python代码是:

width, height = 40, 100
imagearray = np.zeros((width,height), dtype=np.dtype(np.ushort))
image = np.ascontiguousarray(imagearray)
ptrimage = image.ctypes.data_as(ct.POINTER(ct.c_ushort))
DLL.example(width, height, ptrimage)

这适用于python 2.7但不适用于3.2.

编辑2

如果ctypes中的更改只是Cedric指出的那些,那么python 3.2不起作用是没有意义的.所以再看一下代码,我发现在我提到的函数之前有一个调用的准备函数.签名是:

void prepare(char *table)

在python中,我通过以下方式调用:

table = str(aNumber)
DLL.prepare(table)

该问题是否可能是由于Python字符串处理的变化引起的？

我正在寻找一个numpy函数来查找在向量(xs)中找到某些值的索引.值以另一个数组(ys)给出.返回的索引必须遵循ys的顺序.

在代码中,我想用numpy函数替换下面的列表推导.

>> import numpy as np
>> xs = np.asarray([45, 67, 32, 52, 94, 64, 21])
>> ys = np.asarray([67, 94])
>> ndx = np.asarray([np.nonzero(xs == y)[0][0] for y in ys]) # <---- This line
>> print(ndx)
[1 4]

有快速的方法吗？

谢谢

我找到了约书亚布洛赫的一个非常好的演讲:

http://www.youtube.com/watch?v=aAb7hSCtvGw

http://lcsd05.cs.tamu.edu/slides/keynote.pdf

虽然它相当普遍,但一些注释仅对静态类型语言有效.我正在寻找与Python相当的东西.(这个谈话看起来很有希望,但还没有给出)

通过例如引导锈示出了下面的代码在这里为一个斐波纳契数列与迭代:

fn next(&mut self) -> Option<u32> {
    let new_next = self.curr + self.next;
    let new_curr = mem::replace(&mut self.next, new_next);

    // 'Some' is always returned, this is an infinite value generator
    Some(mem::replace(&mut self.curr, new_curr))
}

我想了解这是什么优势,而不是最直观的(如果你来自其他语言):

fn next(&mut self) -> Option<u32> {
    let tmp = self.next;
    self.next = self.curr + self.next;
    self.curr = tmp;
    Some(self.curr)
}

我最近一直在研究一个脚本,它接收文件,分块并分析每一块.因为分块位置取决于内容,所以我需要一次读取一个字节.我不需要随机访问,只需从头到尾线性阅读,随意选择某些位置,并将块的内容从前一个选定位置生成到当前位置.

使用由a包装的内存映射文件非常方便bytearray.我没有产生块,而是产生块的偏移量和大小,留下外部函数来对其进行切片.

它也比在a中累积当前块bytearray更快(并且比累积更快bytes!).但我有一些担忧,我想谈谈:

1. 是否使用bytearray复制数据？
2. 我打开文件rb和mmap用access=mmap.ACCESS_READ.但bytearray原则上,它是一个可变容器.这是性能问题吗？我应该使用只读容器吗？
3. 因为我没有在缓冲区中累积,所以我随机访问bytearray(因此底层文件).即使它可能是缓冲的,我担心会出现问题,具体取决于文件大小和系统内存.这真的是个问题吗？