Як можна створити наступний список 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)позначення Валя Некмана .

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

вирішить цю проблему. Він виведе 8 на 1, а -1 означає перевернутий список

Немає сенсу користуватися reverse оскільки метод діапазону може повернути перевернутий список.

Коли у вас є ітерація над n елементами і ви хочете замінити порядок поверненого списку, range(start, stop, step)ви повинні використовувати третій параметр діапазону, який ідентифікує stepі встановлює його -1, інші параметри повинні бути відповідно скориговані:

1. Надайте параметр зупинки як -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]

Ви можете робити друк зворотних чисел з діапазоном () 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's 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]

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

Припустимо, у вас є список, називайте його = {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