用f（x）无损替换矩阵的列x的numpy / pythonic方法是什么？

Question

I have a matrix M :

import numpy

M = numpy.array([[1,2,3], [4,5,6]])

I want a function that returns an array with every entry x of the col th column of M replaced by f(x) , but doesn't modify the input matrix.

I'm doing this with:

def my_func(M, col, f=lambda x: x+1):
    copy = numpy.copy(M)
    copy.T[col] = [f(x[col]) for x in copy]
    return copy

which works out well:

>>> my_func([[1,2,3], [4,5,6]], 1)
array([[1, 3, 3],
       [4, 6, 6]])

But I'm seeing that this code is a huge bottleneck in my program, since my matrix M is large. Is there a faster way to do this?

I've also tried

numpy.fromiter(map(lambda x: f(x), M.T[col]), dtype=float)

but this doesn't seem to yield a whole lot of speed-up.

(In reality, my matrix M is actually a numpy.masked_array , and f is more complex than just adding 1, but I don't know if those details make any difference.)

Answer 1

The following should help the siuation. Using %timeit in ipython, I got 100000 loops, best of 3: 14.7 us per loop for your function and 100000 loops, best of 3: 9.83 us per loop for the one listed below.

import numpy

M = numpy.array([[1,2,3], [4,5,6]])

def my_func(M, col, f=lambda x: x+1):
    copy = numpy.copy(M)
    copy[:, col] = f(copy[:, col])
    return copy

print my_func(M, 1)

The one issue with my version is that f has to work on vector input. However, using vecor_func = numpy.vectorize(func) this can be done for any function, but it might efect the time boost of my method.

Another cool thing is that this can be done for more complicated indexing/slices.

def my_func2(M, index, f=lambda x: x+1):
    copy = numpy.copy(M)
    copy[index] = f(copy[index])
    return copy

# prints the same result as before
print my_func2(M, (slice(None), 1))

Answer 2

Can you just apply your function to the whole column at once?

def my_func(M, col, f=lambda x: x+1):
    copy = numpy.copy(M)
    copy[:,col] = f(M[:,col])
    return copy

Doing a matrix-scale operation is going to be faster than iterating through element by element.