Loop backwards using indices

for i in range(100, -1, -1)

and some slightly longer (and slower) solution:

for i in reversed(range(101))

for i in range(101)[::-1]

In my opinion, this is the most readable:

for i in reversed(range(101)):
    print(i)

Generally in Python, you can use negative indices to start from the back:

numbers = [10, 20, 30, 40, 50]
for i in xrange(len(numbers)):
    print numbers[-i - 1]

Result:

50
40
30
20
10

Another solution:

z = 10
for x in range (z):
   y = z-x
   print y

Result:

10
9
8
7
6
5
4
3
2
1

Tip:
If you are using this method to count back indices in a list, you will want to -1 from the ‘y’ value, as your list indices will begin at 0.

for var in range(10,-1,-1) works

I tried this in one of the codeacademy exercises (reversing chars in a string without using reversed nor :: -1)

def reverse(text):
    chars= []
    l = len(text)
    last = l-1
    for i in range (l):
        chars.append(text[last])
        last-=1

    result= ""   
    for c in chars:
        result += c
    return result
print reverse('hola')

Short and sweet. This was my solution when doing codeAcademy course. Prints a string in rev order.

def reverse(text):
    string = ""
    for i in range(len(text)-1,-1,-1):
        string += text[i]
    return string    

a = 10
for i in sorted(range(a), reverse=True):
    print i

Why your code didn’t work

You code for i in range (100, 0) is fine, except

the third parameter (step) is by default +1. So you have to specify 3rd parameter to range() as -1 to step backwards.

for i in range(100, -1, -1):
    print(i)

NOTE: This includes 100 & 0 in the output.

There are multiple ways.

Better Way

For pythonic way, check PEP 0322.

This is Python3 pythonic example to print from 100 to 0 (including 100 & 0).

for i in reversed(range(101)):
    print(i)

You can always do increasing range and subtract from a variable in your case 100 - i where i in range( 0, 101 ).

for i in range( 0, 101 ):
    print 100 - i

The simple answer to solve your problem could be like this:

for i in range(100):
    k = 100 - i
    print(k)

I wanted to loop through a two lists backwards at the same time so I needed the negative index. This is my solution:

a= [1,3,4,5,2]
for i in range(-1, -len(a), -1):
    print(i, a[i])

Result:

-1 2
-2 5
-3 4
-4 3
-5 1

Oh okay read the question wrong, I guess it’s about going backward in an array? if so, I have this:

array = ["ty", "rogers", "smith", "davis", "tony", "jack", "john", "jill", "harry", "tom", "jane", "hilary", "jackson", "andrew", "george", "rachel"]


counter = 0   

for loop in range(len(array)):
    if loop <= len(array):
        counter = -1
        reverseEngineering = loop + counter
        print(array[reverseEngineering])

You can also create a custom reverse mechanism in python. Which can be use anywhere for looping an iterable backwards

class Reverse:
    """Iterator for looping over a sequence backwards"""
    def __init__(self, seq):
        self.seq = seq
        self.index = len(seq)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index -= 1
        return self.seq[self.index]


>>> d = [1,2,3,4,5]
>>> for i in Reverse(d):
...   print(i)
... 
5
4
3
2
1

You might want to use the reversed function in python.
Before we jump in to the code we must remember that the range
function always returns a list (or a tuple I don’t know) so range(5) will return [0, 1, 2, 3, 4]. The reversed function reverses a list or a tuple so reversed(range(5)) will be [4, 3, 2, 1, 0] so your solution might be:

for i in reversed(range(100)):
    print(i)

It works well with me

for i in range(5)[::-1]:
    print(i,end=' ')

output : 4 3 2 1 0

Generally reversed() and [::-1] are the simplest options for existing lists. I did found this:

For a comparatively large list, under time constraints, it seems that the reversed() function performs faster than the slicing method. This is because reversed() just returns an iterator that iterates the original list in reverse order, without copying anything whereas slicing creates an entirely new list, copying every element from the original list. For a list with 10^6 Values, the reversed() performs almost 20,000 better than the slicing method. If there is a need to store the reverse copy of data then slicing can be used but if one only wants to iterate the list in reverse manner, reversed() is definitely the better option.

source: https://www.geeksforgeeks.org/python-reversed-vs-1-which-one-is-faster/

But my experiments do not confirm this:

For 10^5

$ python3 -m timeit -n 1000 -v "[x for x in range(100_000)[::-1]]"
raw times: 2.63 sec, 2.52 sec, 2.53 sec, 2.53 sec, 2.52 sec

1000 loops, best of 5: 2.52 msec per loop

$ python3 -m timeit -n 1000 -v "[x for x in reversed(range(100_000))]"
raw times: 2.64 sec, 2.52 sec, 2.52 sec, 2.52 sec, 2.51 sec

1000 loops, best of 5: 2.51 msec per loop

For 10^6

$ python3 -m timeit -n 1000 -v "[x for x in range(1_000_000)[::-1]]"
raw times: 31.9 sec, 31.8 sec, 31.9 sec, 32 sec, 32 sec

1000 loops, best of 5: 31.8 msec per loop

$ python3 -m timeit -n 1000 -v "[x for x in reversed(range(1_000_000))]"
raw times: 32.5 sec, 32 sec, 32.3 sec, 32 sec, 31.6 sec

1000 loops, best of 5: 31.6 msec per loop

Did I miss something?

But if you just wanna generate reversed list, there is no difference between reversed(range()) and range(n, -1, -1).

Me, megamind:

i = 100
for j in range(0, 100):
   {do stuff}
   i -= 1