使用reversed()函数。

reversed(range(10))

这就更有意义了。

更新：

如果你想让它成为一个列表（正如btk指出的）。

list(reversed(range(10)))

更新。

如果你想只用range来达到同样的效果，你可以使用它的所有参数。`range(start, stop, step)'(范围)。

例如，要生成一个列表[5,4,3,2,1,0]，你可以使用下面的方法。

range(5, -1, -1)

这可能不太直观，但正如评论中提到的，这更有效率，也是反向列表范围的正确用法。

使用'range'内置函数。其签名是range(start, stop, step)。 这将产生一个产生数字的序列，从start开始，如果达到stop则结束，不包括stop。

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

在Python 3中，这产生了一个非列表的`range'对象，它的功能与只读列表相似 (但使用的内存更少，特别是对于大范围来说) 。

你可以使用range(10)[::-1]这和range(9, -1, -1)是一样的，而且可以说更易读（如果你熟悉常见的sequence[::-1]Python习语）。

对于那些对"效率&quot。 的选项收集到目前为止...

Jaime RGP'的回答](https://stackoverflow.com/a/33174726/2932052)导致我在**重启电脑**后，按照我自己的建议(通过评论)，**了有点"挑战性"的解决方案。 Jason](https://stackoverflow.com/a/31956052/2932052)的解决方法后，我**重启了我的电脑**，并按照我自己的建议(通过评论)。 为了让好奇的你们不至于停机，我在这里介绍一下我的结果（最差的先）。

Jason'的答案（也许只是对列表理解的力量的一次游览）。

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

martineau's answer(如果你熟悉extended slices syntax，就可以读懂)。

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

Michał Šrajer'的答案(公认的答案，可读性很强)。

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

bene'的回答](https://stackoverflow.com/a/7286366/2932052)(最早的，但很粗略[当时](https://stackoverflow.com/revisions/7286366/1))。

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

最后一个选项使用Val Neekman的 "range(n-1,-1,-1) "记法很容易记住。

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

将解决这个问题。 它将输出8到1，而-1表示一个反向的列表。

**使用 "reverse "没有意义，因为range方法可以返回相反的列表。

当你对n个项目进行迭代时，想要替换由range(start, stop, step)`返回的列表顺序时，你必须使用range的第三个参数来标识 "step"，并将其设置为"-1"，其他参数应作相应调整。

1. 提供stop参数为-1(它之前的值为stop - 1，stop等于0)。

2. 作为起始参数使用n-1。

所以，相当于range(n)的倒序是：{{{10121006}}。

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

撇开可读性不谈，"reversed(range(n)) "似乎比 "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

如果有人想知道：)

本题中的要求是要求一个大小为10的整数的 "列表"，按降序排列。 顺序。 所以，让我们用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))


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

非常经常被问到的问题是，在Python 3中，range(9, -1, -1)是否比reversed(range(10))更好？ 在其他语言中使用过迭代器的人，马上会倾向于认为reversed()必须缓存所有的值，然后按相反的顺序返回。 问题是，Python'的reversed()操作符并不工作，如果对象只是一个迭代器。 对象必须具备以下两个条件之一，reversed()才能工作。

1. 要么支持len()和通过[]的整数索引。

2. 或者实施__reversed__()方法。

如果你试图在没有上述任何条件的对象上使用reversed()，那么你将得到。

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

所以简而言之，Python的reversed()只是针对像数组这样的对象，所以它的性能应该和前向迭代一样。

但是range()呢？ 那不是一个生成器吗？ 在Python 3中，它是生成器，但被封装在一个实现上述两个功能的类中。 所以range(100000)并不占用很多内存，但它仍然支持高效的索引和反转。

所以总的来说，你可以使用reversed(range(10))而不影响性能。

你可以用range()BIF做反向数字的打印，就像,

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

产出将是 [10,9,8,7,6,5,4,3,2,1]

range() - range ( start , end , increment/decrease ) 其中start是包含性的，end是排他性的，increment可以是任何数字，并且行为像step一样

我相信这可以帮助。

range(5)[::-1]

下面是用法。

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

使用不带[::-1]或反转的 - 。

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!")

假设你有一个列表，叫它 a={1,2,3,4,5} 现在如果你想反过来打印列表，那么只需使用以下代码。

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

我知道你问的是使用范围，但它已经回答了。

你不一定需要使用range函数，你可以简单地做list[::-1]，它应该会迅速地以反向顺序返回列表，而不需要使用任何加法。

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

是正确的形式。 如果你使用

reversed(range(10))

你不会得到一个0的情况。 比如说，你的10不是一个神奇的数字，而你使用的变量是从reverse开始查找的。 如果你的n情况是0，reversed(range(0))将不会执行，如果你偶然在0索引中有一个单一的对象，这是错误的。