Ответ 1

использовать reversed() функцию:

reversed(range(10))

Это гораздо более значимый.

Update:

Если вы хотите, чтобы это был список (как указывал btk):

list(reversed(range(10)))

Update:

Если вы хотите использовать только range для достижения того же результата, вы можете использовать все его параметры. range(start, stop, step)

Например, чтобы сгенерировать список [5,4,3,2,1,0], вы можете использовать следующее:

range(5, -1, -1)

Это может быть менее интуитивно понятным, но, как отмечают комментарии, это более эффективное и правильное использование диапазона для перевернутого списка.

Ответ 2

Используйте встроенную функцию "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 это создает объект non-list range, который эффективно функционирует как список только для чтения (но использует меньше памяти, особенно для больших диапазонов).

Ответ 3

Вы можете использовать range(10)[::-1], что является тем же самым, что и range(9, -1, -1) и, возможно, более читаемым (если вы знакомы с общей идиомой Python sequence[::-1]).

Ответ 4

Для тех, кто интересуется "эффективностью" собранных пока вариантов...

Ответ Jaime RGP привел меня к перезагрузке компьютера после того, как было выбрано "сложное" решение Джейсона, буквально следуя моему собственному предложению (через комментарий). Чтобы избавить вас от любопытного простоя, я представлю здесь свои результаты (в худшем случае):

Ответ Джейсона (может быть, просто экскурсия в силу понимания списка):

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

Ответ martineau (читается, если вы знакомы с синтаксисом расширенных слайсов):

$ 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

Ответ бене (самый первый, но очень схематичный в то время):

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

Последний вариант легко запомнить, используя обозначения range(n-1,-1,-1) Вала Никмана.

Ответ 5

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

решит эту проблему. Он будет выводить 8 в 1, а -1 означает обратный список

Ответ 6

Отказоустойчивость, 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

Просто, если кто-то задавался вопросом:)

Ответ 7

Нет смысла использовать reverse, потому что метод диапазона может возвращать обратный список.

Если у вас есть итерация по n элементам и вы хотите изменить порядок списка, возвращаемого range(start, stop, step), вы должны использовать третий параметр диапазона, который идентифицирует step, и установить его в -1, другие параметры должны быть скорректированы соответственно:

1. Укажите параметр stop как -1 (предыдущее значение stop - 1, stop было равно 0).
2. В качестве параметра запуска используйте n-1.

Таким образом, эквивалент диапазона (n) в обратном порядке будет:

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

Ответ 8

Требование в этом вопросе требует list целых чисел размера 10 в нисходящем заказ. Итак, давайте создадим список в python.

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

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

Ответ 9

Вы можете печатать обратные номера с диапазоном() BIF Like,

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

Выход будет [10,9,8,7,6,5,4,3,2,1]

range() - диапазон (начало, конец, приращение/уменьшение) где start is inclusive, end является эксклюзивным, а increment может быть любым числом и ведет себя как шаг

Ответ 10

Очень часто задаваемый вопрос: лучше ли range(9, -1, -1) чем reversed(range(10)) в Python 3? Люди, которые работали на других языках с итераторами, сразу же склонны думать, что метод 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)) без какого-либо снижения производительности.

Ответ 11

Я считаю, что это может помочь,

range(5)[::-1]

ниже: Использование

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

Ответ 12

Использование без [:: - 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!")

Ответ 13

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

Ответ 14

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

Ответ 15

Вам необязательно использовать функцию диапазона, вы можете просто сделать список [:: - 1], который должен быстро возвращать список в обратном порядке без каких-либо добавлений.

Ответ 16

Предположим, что у вас есть вызов списка а = {1,2,3,4,5} Теперь, если вы хотите распечатать список в обратном порядке, просто используйте следующий код.

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

Я знаю, что вы попросили использовать диапазон, но он уже ответил.

Ответ 17

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

Правильная форма. Если вы используете

reversed(range(10))

вы не получите случай 0. Например, скажем, что ваш 10 не является магическим числом и переменной, которую вы используете для начала поиска с обратного. Если ваш n-й случай равен 0, то наоборот (диапазон (0)) не будет выполняться, что неверно, если вы случайно имеете один объект в нулевом индексе.