Как вы можете создать следующий список range()в Python?

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

использовать 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).

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

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

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

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

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

$ 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)обозначение Val Neekman .

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

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

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

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

1. Укажите параметр stop as -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]

Читаем в стороне, 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

Просто если кому было интересно :)

Требование в этом вопросе требует listцелых чисел размера 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))
<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]

Вы можете печатать обратные числа с помощью range () BIF Like,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

reversed(range(10))

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

Я подумал, что многие (как и я) могли бы больше интересоваться общим случаем обхода существующего списка в обратном порядке , как это указано в заголовке, а не просто генерированием индексов для такого обхода.

Несмотря на то, что все правильные ответы по-прежнему идеально подходят для этого случая, я хочу отметить, что сравнение производительности, выполненное в ответе Вольфа, предназначено только для генерации индексов. Поэтому я сделал аналогичный тест для обхода существующего списка в обратном порядке.

TL; DR a[::-1] самый быстрый.

Предпосылки:

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)

Как видите, в этом случае нет необходимости явно генерировать индексы, поэтому самый быстрый метод - это тот, который выполняет меньше дополнительных действий.

NB: я тестировал в JupyterLab, у которого есть удобная «волшебная команда» %timeit. Используется стандарт timeit.timeitпод капотом. Протестировано на Python 3.7.3