## 8 Answers

Reset to default

# Trending sort

**Trending** sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

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

gives a reversed view into the original array `arr`

. Any changes made to the original array `arr`

will also be immediately visible in `reversed_arr`

. The underlying data buffers for `arr`

and `reversed_arr`

are *shared*, so creating this view is always instantaneous, and does not require any additional memory allocation or copying for the array contents.

See also, this discussion on NumPy views: How do I create a view onto a NumPy array?

##### Possible solutions to performance problems regarding views

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.

4

```
a[::-1]
```

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 `flipud`

/`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(25)],
xlabel="len(a)",
)
```

1

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

```
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.

`np.fliplr()`

flips the array left to right.

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

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

2

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]
```

1

The slice notation based analog to np.flip would be [::-1,::-1]

```
a = np.array([[1., 2.], [3., 4.], [5, 6]])
print(a)
out: [[1. 2.]
[3. 4.]
[5. 6.]]
b=a[::-1,::-1]
print(b)
out: [[1. 2.]
[3. 4.]
[5. 6.]]
```

Expanding on what others have said I will give a short example.

If you have a 1D array …

```
>>> import numpy as np
>>> x = np.arange(4) # array([0, 1, 2, 3])
>>> x[::-1] # returns a view
Out[1]:
array([3, 2, 1, 0])
```

But if you are working with a 2D array …

```
>>> x = np.arange(10).reshape(2, 5)
>>> x
Out[2]:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> x[::-1] # returns a view:
Out[3]: array([[5, 6, 7, 8, 9],
[0, 1, 2, 3, 4]])
```

This does not actually reverse the Matrix.

Should use np.flip to actually reverse the elements

```
>>> np.flip(x)
Out[4]: array([[9, 8, 7, 6, 5],
[4, 3, 2, 1, 0]])
```

If you want to print the elements of a matrix one-by-one use flat along with flip

```
>>> for el in np.flip(x).flat:
>>> print(el, end = ' ')
9 8 7 6 5 4 3 2 1 0
```

1

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

344