# Print a list in reverse order with range()?

## Question:

How can you produce the following list with `range()` in Python?

``````[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
``````

Use the ‘range’ built-in function. The signature is `range(start, stop, step)`. This produces a sequence that yields numbers, starting with `start`, and ending if `stop` has been reached, excluding `stop`.

``````>>> range(9,-1,-1)
range(9, -1, -1)
>>> list(range(9,-1,-1))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> list(range(-2, 6, 2))
[-2, 0, 2, 4]
``````

The list constructor converts range (which is a python generator), into a list.

use `reversed()` function:

``````reversed(range(10))
``````

It’s much more meaningful.

Update:

If you want it to be a list (as btk pointed out):

``````list(reversed(range(10)))
``````

Update:

If you want to use only `range` to achieve the same result, you can use all its parameters. `range(start, stop, step)`

For example, to generate a list `[5,4,3,2,1,0]`, you can use the following:

``````range(5, -1, -1)
``````

It may be less intuitive but as the comments mention, this is more efficient and the right usage of range for reversed list.

``````range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
``````

You could use `range(10)[::-1]` which is the same thing as `range(9, -1, -1)` and arguably more readable (if you’re familiar with the common `sequence[::-1]` Python idiom).

``````range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
``````

Is the correct form. If you use

``````reversed(range(10))
``````

you wont get a 0 case. For instance, say your 10 isn’t a magic number and a variable you’re using to lookup start from reverse. If your n case is 0, reversed(range(0)) will not execute which is wrong if you by chance have a single object in the zero index.

The requirement in this question calls for a `list` of integers of size 10 in descending
order. So, let’s produce a list in python.

``````# This meets the requirement.
# But it is a bit harder to wrap one's head around this. right?
>>> range(10-1, -1, -1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# let's find something that is a bit more self-explanatory. Sounds good?
# ----------------------------------------------------

# This returns a list in ascending order.
# Opposite of what the requirement called for.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# This returns an iterator in descending order.
# Doesn't meet the requirement as it is not a list.
>>> reversed(range(10))
<listreverseiterator object at 0x10e14e090>

# This returns a list in descending order and meets the requirement
>>> list(reversed(range(10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
``````

Using without [::-1] or reversed –

``````def reverse(text):
result = []
for index in range(len(text)-1,-1,-1):
c = text[index]
result.append(c)
return ''.join(result)

print reverse("python!")
``````
``````[9-i for i in range(10)]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
``````

i believe this can help,

``````range(5)[::-1]
``````

below is Usage:

``````for i in range(5)[::-1]:
print i
``````

Readibility aside, `reversed(range(n))` seems to be faster than `range(n)[::-1]`.

``````\$ python -m timeit "reversed(range(1000000000))"
1000000 loops, best of 3: 0.598 usec per loop
\$ python -m timeit "range(1000000000)[::-1]"
1000000 loops, best of 3: 0.945 usec per loop
``````

Just if anyone was wondering 🙂

``````for i in range(8, 0, -1)
``````

will solve this problem. It will output 8 to 1, and -1 means a reversed list

## No sense to use `reverse` because the `range` function can return reversed list.

When you have iteration over n items and want to replace order of list returned by `range(start, stop, step)` you have to use third parameter of range which identifies `step` and set it to `-1`, other parameters shall be adjusted accordingly:

1. Provide `stop` parameter as `-1` (it’s previous value of `stop - 1`, `stop` was equal to `0`).
2. As start parameter use `n-1`.

So equivalent of `range(n)` in reverse order would be:

``````n = 10
print range(n-1,-1,-1)
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
``````

You don’t necessarily need to use the range function, you can simply do list[::-1] which should return the list in reversed order swiftly, without using any additions.

You can do printing of reverse numbers with range() BIF Like ,

``````for number in range ( 10 , 0 , -1 ) :
print ( number )
``````

Output will be
[10,9,8,7,6,5,4,3,2,1]

range() – range ( start , end , increment/decrement )
where start is inclusive , end is exclusive and increment can be any numbers and behaves like step

For those who are interested in the "efficiency" of the options collected so far…

Jaime RGP’s answer led me to restart my computer after timing the somewhat "challenging" solution of Jason literally following my own suggestion (via comment). To spare the curious of you the downtime, I present here my results (worst-first):[1]

Jason’s answer (maybe just an excursion into the power of list comprehension):

``````\$ python -m timeit "[9-i for i in range(10)]"
1000000 loops, best of 3: 1.54 usec per loop
``````

martineau’s answer (readable if you are familiar with the extended slices syntax):

``````\$ python -m timeit "range(10)[::-1]"
1000000 loops, best of 3: 0.743 usec per loop
``````

``````\$ python -m timeit "reversed(range(10))"
1000000 loops, best of 3: 0.538 usec per loop
``````

bene’s answer (the very first, but very sketchy at that time):

``````\$ python -m timeit "range(9,-1,-1)"
1000000 loops, best of 3: 0.401 usec per loop
``````

The last option is easy to remember using the `range(n-1,-1,-1)` notation by Val Neekman.

[1] As commented by Karl Knechtel, the results presented here are version-dependent and refer to the Python 3.x version that was stable at the time of answering this question.

Suppose you have a list call it
a={1,2,3,4,5}
Now if you want to print the list in reverse then simply use the following code.

``````a.reverse
for i in a:
print(i)
``````

Very often asked question is whether `range(9, -1, -1)` better than `reversed(range(10))` in Python 3? People who have worked in other languages with iterators immediately tend to think that reversed() must cache all values and then return in reverse order. Thing is that Python’s `reversed()` operator doesn’t work if the object is just an iterator. The object must have one of below two for reversed() to work:

1. Either support `len()` and integer indexes via `[]`
2. Or have `__reversed__()` method implemented.

If you try to use reversed() on object that has none of above then you will get:

``````>>> [reversed((x for x in range(10)))]
TypeError: 'generator' object is not reversible
``````

So in short, Python’s `reversed()` is only meant on array like objects and so it should have same performance as forward iteration.

But what about `range()`? Isn’t that a generator? In Python 3 it is generator but wrapped in a class that implements both of above. So `range(100000)` doesn’t take up lot of memory but it still supports efficient indexing and reversing.

So in summary, you can use `reversed(range(10))` without any hit on performance.

I thought that many (as myself) could be more interested in a common case of traversing an existing list in reversed order instead, as it’s stated in the title, rather than just generating indices for such traversal.

Even though, all the right answers are still perfectly fine for this case, I want to point out that the performance comparison done in Wolf’s answer is for generating indices only. So I’ve made similar benchmark for traversing an existing list in reversed order.

TL;DR `a[::-1]` is the fastest.

NB: If you want more detailed analysis of different reversal alternatives and their performance, check out this great answer.

Prerequisites:

``````a = list(range(10))
``````
``````%timeit [a[9-i] for i in range(10)]
1.27 µs ± 61.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
``````
``````%timeit a[::-1]
135 ns ± 4.07 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
``````
``````%timeit list(reversed(a))
374 ns ± 9.87 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
``````
``````%timeit [a[i] for i in range(9, -1, -1)]
1.09 µs ± 11.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
``````

As you see, in this case there’s no need to explicitly generate indices, so the fastest method is the one that makes less extra actions.

NB: I tested in JupyterLab which has handy "magic command" `%timeit`. It uses standard `timeit.timeit` under the hood. Tested for Python 3.7.3

because `range(n)` produces an iterable there are all sorts of nice things you can do which will produce the result you desire, such as:

``````range(n)[::-1]
``````

if loops are ok, we can make sort of a queue:

``````a = []
for i in range(n):
a.insert(0,a)
return a
``````

or maybe use the reverse() method on it:

``````reverse(range(n))
``````

Get the reverse output of reversing the given input integer.
example
input is:5

``````54321
1234
321
12
1
``````

``````def get_val(n):
d = ''.join(str(i) for i in range(n, 0, -1))
print(d)
print(d[::-1][:-1])
if n - 1>1:
return get_vale(n-1)

get_val(12)

``````
Categories: questions Tags: , , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.