### 最有效的方法来反转一个numpy数组。

#### [英]Most efficient way to reverse a numpy array

Believe it or not, after profiling my current code, the repetitive operation of numpy array reversion ate a giant chunk of the running time. What I have right now is the common view-based method:

``````reversed_arr = arr[::-1]
``````

Is there any other way to do it more efficiently, or is it just an illusion from my obsession with unrealistic numpy performance?

## 6 个解决方案

### #1

157

When you create `reversed_arr` you are creating a view into the original array. You can then change the original array, and the view will update to reflect the changes.

Are you re-creating the view more often than you need to? You should be able to do something like this:

``````arr = np.array(some_sequence)
reversed_arr = arr[::-1]

do_something(arr)
look_at(reversed_arr)
do_something_else(arr)
look_at(reversed_arr)
``````

I'm not a numpy expert, but this seems like it would be the fastest way to do things in numpy. If this is what you are already doing, I don't think you can improve on it.

P.S. Great discussion of numpy views here:

p .关于numpy视图的大讨论:

View onto a numpy array?

### #2

31

`np.fliplr()` flips the array left to right.

fliplr()将数组从左到右翻转。

Note that for 1d arrays, you need to trick it a bit:

``````arr1d = np.array(some_sequence)
reversed_arr = np.fliplr([arr1d])[0]
``````

### #3

27

Because this seems to not be marked as answered yet... The Answer of Thomas Arildsen should be the proper one: just use

``````np.flipud(your_array)
``````

if it is a 1d array (column array).

With matrizes do

matrizes做

``````fliplr(matrix)
``````

if you want to reverse rows and `flipud(matrix)` if you want to flip columns. No need for making your 1d column array a 2dimensional row array (matrix with one None layer) and then flipping it.

### #4

15

As mentioned above, `a[::-1]` really only creates a view, so it's a constant-time operation (and as such doesn't take longer as the array grows). If you need the array to be contiguous (for example because you're performing many vector operations with it), `ascontiguousarray` is about as fast as `flipup`/`fliplr`:

Code to generate the plot:

``````import numpy
import perfplot

perfplot.show(
setup=lambda n: numpy.random.randint(0, 1000, n),
kernels=[
lambda a: a[::-1],
lambda a: numpy.ascontiguousarray(a[::-1]),
lambda a: numpy.fliplr([a])[0]
],
labels=['a[::-1]', 'ascontiguousarray(a[::-1])', 'fliplr'],
n_range=[2**k for k in range(20)],
xlabel='len(a)',
logx=True,
logy=True,
)
``````

### #5

3

I will expand on the earlier answer about `np.fliplr()`. Here is some code that demonstrates constructing a 1d array, transforming it into a 2d array, flipping it, then converting back into a 1d array. `time.clock()` will be used to keep time, which is presented in terms of seconds.

``````import time
import numpy as np

start = time.clock()
x = np.array(range(3))
#transform to 2d
x = np.atleast_2d(x)
#flip array
x = np.fliplr(x)
#take first (and only) element
x = x[0]
#print x
end = time.clock()
print end-start
``````

With print statement uncommented:

``````[2 1 0]
0.00203907123594
``````

With print statement commented out:

``````5.59799927506e-05
``````

So, in terms of efficiency, I think that's decent. For those of you that love to do it in one line, here is that form.

``````np.fliplr(np.atleast_2d(np.array(range(3))))[0]
``````

### #6

0

In order to have it working with negative numbers and a long list you can do the following:

``````b = numpy.flipud(numpy.array(a.split(),float))
``````

Where flipud is for 1d arra