Try range(100,-1,-1), the 3rd argument being the increment to use (documented here).

("range" options, start, stop, step are documented here)

range() and xrange() take a third parameter that specifies a step. So you can do the following.

range(10, 0, -1)

Which gives

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

But for iteration, you should really be using xrange instead. So,

xrange(10, 0, -1)

Note for Python 3 users: There are no separate range and xrange functions in Python 3, there is just range, which follows the design of Python 2's xrange.

for loops in Python always go forward. If you want to be able to move backwards, you must use a different mechanism, such as while:

i = 0
while i < 5:
    print(i)
    if condition:
        i=i-1
    i += 1

Or even better:

i = 0
while i < 5:
    print(i)
    if condition:
        do_something()
        # don't increment here, so we stay on the same value for i
    else:
        # only increment in the case where we're not "moving backwards"
        i += 1

for loops don't go back or forth. They simply take the iterator object for a given iterable object, then repeatedly call the __next__() object until that method raises StopIteration.

For sequence objects, the iterator simply keeps an internal index that's incremented each time __next__ is called to get the next value in the sequence. That internal index is usually not accessible.

So if your specific use case is made easier by 'going back', you'd have to create an iterator object that exposes the index, or otherwise lets you alter what value is going to be produced for the next __next__ call:

class PositionableSequenceIterator:
    def __init__(self, sequence):
        self.seq = sequence
        self._nextpos = None

    @property
    def pos(self):
        pos = self._nextpos
        return 0 if pos is None else pos - 1

    @pos.setter
    def pos(self, newpos):
        if not 0 <= newpos < len(self.seq):
            raise IndexError(newpos)
        self._nextpos = newpos

    def __iter__(self):
        return self

    def __next__(self):
        try:
            return self.seq[self.nextpos or 0]
        except IndexError:
            raise StopIteration
        finally:
            self.nextpos += 1

so now you can do

iterator = PositionableSequenceIterator(some_list)
for elem in iterator:
    if somecondition:
        iterator.pos -= 2
    # ...

to skip back two steps.

I'd not expect this to be faster than a while loop, however. while loops are not specifically faster, testing the while condition each iteration is not much different from calling iterator.__next__(), really. In your timed test, the while condition is slower because it executes Python bytecode each iteration (both for the condition and to increment n in the loop body), but the range() iterator is implemented entirely in C. The iterator class above implements __next__ in Python code again, so will be just as slow.

To demonstrate, I can show you that the timing differences are entirely due to the condition and loop body being slower:

>>> import timeit
>>> count, total = timeit.Timer("n = 0\nwhile n < 10 ** 6:\n    n += 1").autorange()
>>> whileloop = total / count
>>> count, total = timeit.Timer("for i in range(10 ** 6):\n    pass").autorange()
>>> forloop = total / count
>>> count, total = timeit.Timer("n < 10 ** 6", "n = 10 ** 5 * 5").autorange()
>>> testbelow = total / count
>>> count, total = timeit.Timer("n += 1", "n = 0").autorange()
>>> increment = total / count
>>> count, total = timeit.Timer("nxt()", "nxt = iter(range(1 << 23)).__next__").autorange()  # enough room to find a good test range
>>> rangeitnext = total / count
>>> whileloop - forloop  # the for loop "speed advantage", per million iterations
0.03363728789991001
>>> (testbelow + increment) - rangeitnext  # relative difference per iteration
-9.191804809961469e-08
>>> ((testbelow + increment) - rangeitnext) * 10 ** 9  # microseconds
-91.9180480996147

So in these tests I can at best prove that there's only 92 microseconds between each loop iteration step, with while faster, if that makes any sense. That's because if I repeat this often enough, it'll about hit the (whileloop - forloop) / 10 ** 6 difference, because these numbers are just way too small to really care about.

Note that an iterator like the above is usually overkill. The vast majority of problems where someone might wish to "rewind" an iterator really just want to keep track of previously seen items. You can trivially do that with other options too, like a queue:

from collections import deque

preceding = deque(maxlen=2)
for item in iterable:
    if condition:
        # process items in preceding

    preceding.append(item)

The above keeps the last two items seen around in case you need to process those.

Or you could use zip() and independent iterators:

from itertools import islice

twoforward = islice(iterable, 2, None)
for twoback, current in zip(iterable, twoforward):
    # twoback and current are paired up at indices i - 2 and i.

As for your euler_differentiate_mod() function, the following achieves the same work, without the need to advance a while counter. Your function basically calculates deltas up to 3 times per iteration, and moves to the next iteration when you either have a maximum change within toleration bounds or you tried 3 times:

def euler_differentiate_mod(
    w, bounds=None, delta=1e-3, itern=1000, tols=(10, 0.1), step_mults=(0.1, 10)
):
    if bounds is None:
        bounds = [0] * len(w)

    for _ in range(itern):
        for _ in range(3):
            deltas = [f(delta, *bounds) for f in w]
            maxchange = max(map(abs, deltas[1:]))  # ignore the first delta
            bounds[:] = [b + d for b, d in zip(bounds, deltas)]

            if delta > 1:
                delta *= step_mults[0] / maxchange

            if tols[1] <= maxchange <= tols[0]:
                break

            if delta > 1:
                if tols[0] < maxchange:
                    delta *= step_mults[0] / maxchange
                elif maxchange < tols[1]:
                    delta *= step_mults[1] / maxchange

Use the built-in reversed() function:

>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
...     print(i)
... 
baz
bar
foo

To also access the original index, use enumerate() on your list before passing it to reversed():

>>> for i, e in reversed(list(enumerate(a))):
...     print(i, e)
... 
2 baz
1 bar
0 foo

Since enumerate() returns a generator and generators can't be reversed, you need to convert it to a list first.