पायथन में रिवर्स ऑर्डर में एक सूची को पार करें

Question

इसलिए मैं शुरू कर सकता हूं len(collection)और अंत कर सकता हूं collection[0]।

मैं लूप इंडेक्स तक पहुंचने में भी सक्षम होना चाहता हूं।

Answer 1

अंतर्निहित reversed()फ़ंक्शन का उपयोग करें :

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

मूल सूचकांक तक पहुंचने के लिए, enumerate()इसे पास करने से पहले अपनी सूची में उपयोग करें reversed():

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

चूंकि enumerate()रिटर्न जेनरेटर और जनरेटर को उलट नहीं किया जा सकता है, इसलिए आपको इसे listपहले बदलने की जरूरत है ।

Comments

कोई प्रतिलिपि नहीं बनाई गई है, तत्वों को ट्रैवर्स करते समय मक्खी पर उलट दिया जाता है! यह इन सभी पुनरावृत्ति कार्यों की एक महत्वपूर्ण विशेषता है (जो सभी "एड" पर समाप्त होते हैं)।

— कोनराड रुडोल्फ

@Greg Hewgill नहीं, यह मूल पर एक पुनरावृत्ति है, कोई प्रतिलिपि नहीं बनाई गई है!

— एंड्रे

भ्रम से बचने के लिए: reversed()सूची को संशोधित नहीं करता है। reversed()सूची की एक प्रति नहीं बनाता है (अन्यथा इसे ओ (एन) अतिरिक्त मेमोरी की आवश्यकता होगी)। यदि आपको सूची उपयोग को संशोधित करने की आवश्यकता है alist.reverse(); यदि आपको उल्टे क्रम के उपयोग में सूची की एक प्रति चाहिए alist[::-1]।

— JFS

इस उत्तर में हालांकि, सूची (गणना) (क) एक प्रतिलिपि बनाता है।

— त्रिपिटक

@ JF, उलटा () प्रतिलिपि नहीं बनाता है, लेकिन सूची (गणना) () प्रतिलिपि बनाता है।

— त्रिपिटक

Answer 2

तुम कर सकते हो:

for item in my_list[::-1]:
    print item

(या आप जो कुछ भी करना चाहते हैं लूप में करें।)

[::-1]टुकड़ा पाश के लिए में सूची पराजयों (लेकिन वास्तव में अपनी सूची "स्थायी रूप से" संशोधित नहीं होगा)।

Comments

[::-1]एक उथली प्रतिलिपि बनाता है, इसलिए यह न तो "स्थायी रूप से" और न ही "अस्थायी" सरणी को बदलता है।

— JFS

यह उलट का उपयोग करने की तुलना में थोड़ा धीमा है, कम से कम पायथन 2.7 (परीक्षण) के तहत।

— kgriffs

यह उत्तर कैसे काम करता है : यह पैरामीटर के साथ सूची की एक कटा हुआ प्रतिलिपि बनाता है: प्रारंभ बिंदु : अनिर्दिष्ट (सूची की लंबाई इतनी अंत में शुरू होती है), अंत बिंदु : अनिर्दिष्ट (कुछ जादू की संख्या के अलावा 0, शायद -1, इसलिए शुरू होता है ) और चरण : -1( 1एक समय में सूची, आइटम के माध्यम से पीछे की ओर )।

— एडवर्ड

मैंने इसे (अजगर 2.7) के रूप में अच्छी तरह से परखा और यह ~ 10% धीमा था [:: - 1] का उपयोग करने के लिएreversed()

— RustyShackleford

Answer 3

यदि आपको लूप इंडेक्स की आवश्यकता है, और पूरी सूची को दो बार नहीं निकालना है, या अतिरिक्त मेमोरी का उपयोग करना चाहते हैं, तो मैं एक जनरेटर लिखूंगा।

def reverse_enum(L):
   for index in reversed(xrange(len(L))):
      yield index, L[index]

L = ['foo', 'bar', 'bas']
for index, item in reverse_enum(L):
   print index, item

Comments

मैं फ़ंक्शन को enumerate_reversed कहूंगा, लेकिन यह केवल मेरा स्वाद हो सकता है। मेरा मानना ​​है कि विशिष्ट प्रश्न के लिए आपका उत्तर सबसे साफ है।

— tzot 20

reversed(xrange(len(L)))के रूप में एक ही सूचकांक का उत्पादन xrange(len(L)-1, -1, -1)।

— 16

मैं समझने के लिए कम चलती भागों को पसंद करता हूं:for index, item in enumerate(reversed(L)): print len(L)-1-index, item

— डॉन किर्कबी

@ ट्रिटिक मुझे बस इस तथ्य से जूझना था कि उलट () से उलटा अनुक्रमणिका नहीं निकलेगी, और आपके कोड ने बहुत मदद की। यह विधि मानक पुस्तकालय में होनी चाहिए।

— 1842 को ऑस्की 86

उलट (xrange) () काम करता है क्योंकि एक xrange ऑब्जेक्ट में __reversed__ विधि के साथ-साथ __len__ और __getitem__ तरीके हैं, और उलट पता लगा सकते हैं और उनका उपयोग कर सकते हैं। लेकिन एक गूढ़ वस्तु में __reversed__, __len__ या __getitem__ नहीं है। लेकिन उनके पास क्यों नहीं है? मुझे नहीं पता।

— FutureNerd

Answer 4

इसे इस तरह किया जा सकता है:

मैं सीमा में (लेन (संग्रह) -1, -1, -1):
    प्रिंट संग्रह [i]

    अजगर के लिए # प्रिंट (संग्रह [i]) + +

तो आपका अनुमान बहुत करीब था :) थोड़ा अजीब है, लेकिन यह मूल रूप से कह रहा है: 1 से कम से शुरू करें len(collection), जब तक आप -1 से पहले नहीं मिलते, तब तक चलते रहें।

Fyi, helpफ़ंक्शन बहुत उपयोगी है क्योंकि यह आपको पायथन कंसोल से किसी चीज़ के लिए डॉक्स देखने देता है, जैसे:

help(range)

Comments

3.0 से पहले पायथन के संस्करणों के लिए, मेरा मानना ​​है कि xrange को बड़ी लेन (संग्रह) के लिए रेंज करना बेहतर है।

— ब्रायन एम। हंट

मेरा मानना ​​है कि आप सही हैं :) iirc, रेंज () एक सरणी के रूप में पूरी रेंज उत्पन्न करता है लेकिन xrange () एक पुनरावृत्ति देता है जो केवल मानों को उत्पन्न करता है जैसे कि वे आवश्यक हैं।

— एलन रोवर्थ 23

यह सिर्फ इतने सारे के साथ बहुत अजीब लग रहा है -1। मैं सिर्फ इतना ही कहूंगाreversed(xrange(len(collection)))

— मुशीफिल

Answer 5

reversedBuiltin समारोह उपयोगी है:

for item in reversed(sequence):

प्रलेखन उलट के लिए अपनी सीमाएं बताते हैं।

उन मामलों के लिए जहां मुझे अनुक्रम के साथ रिवर्स में अनुक्रम चलना है (उदाहरण के लिए अनुक्रम लंबाई को बदलने के लिए इन-प्लेस संशोधनों), मैंने इस फ़ंक्शन को मेरे कोडुटिल मॉड्यूल को परिभाषित किया है:

import itertools
def reversed_enumerate(sequence):
    return itertools.izip(
        reversed(xrange(len(sequence))),
        reversed(sequence),
    )

यह एक अनुक्रम की एक प्रति बनाने से बचता है। जाहिर है, reversedसीमाएं अभी भी लागू होती हैं।

Answer 6

कैसे एक नई सूची को फिर से बनाए बिना, आप अनुक्रमण द्वारा कर सकते हैं:

>>> foo = ['1a','2b','3c','4d']
>>> for i in range(len(foo)):
...     print foo[-(i+1)]
...
4d
3c
2b
1a
>>>

या

>>> length = len(foo)
>>> for i in range(length):
...     print foo[length-i-1]
...
4d
3c
2b
1a
>>>

Answer 7

>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']

या

>>> print l[::-1]
['d', 'c', 'b', 'a']

Answer 8

मुझे वन-लाइनर जनरेटर दृष्टिकोण पसंद है:

((i, sequence[i]) for i in reversed(xrange(len(sequence))))

Answer 9

इसके अलावा, आप या तो "रेंज" या "गणना" फ़ंक्शन का उपयोग कर सकते हैं। निम्नलिखित नुसार:

a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
    print(i, a[i])

3 baz
2 bar
1 foo

आप निम्नानुसार इटर्टूल से "काउंट" का भी उपयोग कर सकते हैं:

a = ["foo", "bar", "baz"]
from itertools import count, takewhile

def larger_than_0(x):
    return x > 0

for x in takewhile(larger_than_0, count(3, -1)):
    print(x, a[x-1])

3 baz
2 bar
1 foo

Comments

आपके पहले ब्लॉक का कोड सही आउटपुट नहीं देता है; आउटपुट वास्तव में है3 foo\n2 bar\n1 baz

— amiller27

पहले उदाहरण में "a [i-1]" का उपयोग करने से बचने के लिए, इस श्रेणी का उपयोग करें "सीमा (len (a) -1, -1, -1,")। यह अधिक सरलीकृत है।

— फ्रांसिस

Answer 10

list.reverse()जैसा कि आप सामान्य रूप से करते हैं, उसका उपयोग करें और फिर पुनरावृति करें ।

http://docs.python.org/tutorial/datastructures.html

Answer 11

कोई आयात नहीं के साथ एक दृष्टिकोण:

for i in range(1,len(arr)+1):
    print(arr[-i])

या

for i in arr[::-1]:
    print(i)

Answer 12

def reverse(spam):
    k = []
    for i in spam:
        k.insert(0,i)
    return "".join(k)

Answer 13

जो कभी आपके लायक है, आप उसे इस तरह भी कर सकते हैं। बहुत आसान।

a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
    x += 1
    print a[-x]

Comments

आप भी कर सकते हैं print a[-(x+1)]और लूप के शरीर में सूचकांक को पुन: सौंपने से बच सकते हैं ।

— मैल्कम

Answer 14

reverse(enumerate(collection))अजगर 3 में प्राप्त करने के लिए एक अर्थपूर्ण तरीका :

zip(reversed(range(len(collection))), reversed(collection))

अजगर 2 में:

izip(reversed(xrange(len(collection))), reversed(collection))

मुझे यकीन नहीं है कि हमारे पास इसके लिए शॉर्टहैंड क्यों नहीं है, उदाहरण के लिए:

def reversed_enumerate(collection):
    return zip(reversed(range(len(collection))), reversed(collection))

या हमारे पास क्यों नहीं है reversed_range()

Answer 15

यदि आपको सूचकांक की आवश्यकता है और आपकी सूची छोटी है, तो सबसे अधिक पठनीय तरीका यह है reversed(list(enumerate(your_list)))कि स्वीकृत उत्तर में कहा गया है। लेकिन इस अपनी सूची एक कॉपी बन जाती है, इसलिए यदि आपकी सूची अपनी स्मृति के एक बड़े हिस्से को ले रहा है आप सूचकांक द्वारा दिया घटाना होगा enumerate(reversed())से len()-1।

यदि आपको इसे एक बार करने की आवश्यकता है:

a = ['b', 'd', 'c', 'a']

for index, value in enumerate(reversed(a)):
    index = len(a)-1 - index

    do_something(index, value)

या यदि आपको कई बार ऐसा करने की आवश्यकता है तो आपको एक जनरेटर का उपयोग करना चाहिए:

def enumerate_reversed(lyst):
    for index, value in enumerate(reversed(lyst)):
        index = len(lyst)-1 - index
        yield index, value

for index, value in enumerate_reversed(a):
    do_something(index, value)

Answer 16

रिवर्स फ़ंक्शन यहां काम आता है:

myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
    print x

Comments

list.reverse () का कोई रिटर्न मान नहीं है

— Georg Schölly

Answer 17

आप एक whileलूप का उपयोग भी कर सकते हैं :

i = len(collection)-1
while i>=0:
    value = collection[i]
    index = i
    i-=1

Answer 18

आप लूप के लिए एक साधारण में एक नकारात्मक सूचकांक का उपयोग कर सकते हैं:

>>> collection = ["ham", "spam", "eggs", "baked beans"]
>>> for i in range(1, len(collection) + 1):
...     print(collection[-i])
... 
baked beans
eggs
spam
ham

इंडेक्स तक पहुँचने के लिए यद्यपि आप संग्रह की उलटी प्रतिलिपि पर आगे चलना चाहते हैं, उपयोग करें i - 1:

>>> for i in range(1, len(collection) + 1):
...     print(i-1, collection[-i])
... 
0 baked beans
1 eggs
2 spam
3 ham

मूल, संयुक्त राष्ट्र उलट सूचकांक का उपयोग करने के लिए len(collection) - i:

>>> for i in range(1, len(collection) + 1):
...     print(len(collection)-i, collection[-i])
... 
3 baked beans
2 eggs
1 spam
0 ham

Answer 19

यदि आप इंडेक्स को नकारात्मक होने का बुरा नहीं मानते हैं, तो आप कर सकते हैं:

>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
...     print(~i, a[~i]))
-1 baz
-2 bar
-3 foo

Answer 20

मुझे लगता है कि निम्नलिखित जनरेटर को बदलने enumerateऔर reversedउपयोग करने का सबसे सुरुचिपूर्ण तरीका है

(-(ri+1), val) for ri, val in enumerate(reversed(foo))

जो enumerateपुनरावृत्त के रिवर्स उत्पन्न करता है

उदाहरण:

foo = [1,2,3]
bar = [3,6,9]
[
    bar[i] - val
    for i, val in ((-(ri+1), val) for ri, val in enumerate(reversed(foo)))
]

परिणाम:

[6, 4, 2]

Answer 21

अन्य उत्तर अच्छे हैं, लेकिन यदि आप सूची समझ शैली के रूप में करना चाहते हैं

collection = ['a','b','c']
[item for item in reversed( collection ) ]

Comments

क्या यह बिल्कुल उलटा (संग्रह) जैसा नहीं है? सूची की समझ को जोड़ना अनावश्यक गणना के अलावा कुछ नहीं करता है। यह एक = [1, 2, 3] में आइटम के लिए आइटम लिखने जैसा है = एक = [1, 2, 3]।

— इपिकावि

Answer 22

नकारात्मक सूचकांकों का उपयोग करने के लिए: -1 से शुरू करें और प्रत्येक पुनरावृत्ति पर -1 से पीछे जाएँ।

>>> a = ["foo", "bar", "baz"]
>>> for i in range(-1, -1*(len(a)+1), -1):
...     print i, a[i]
... 
-1 baz
-2 bar
-3 foo

Answer 23

एक सरल तरीका:

n = int(input())
arr = list(map(int, input().split()))

for i in reversed(range(0, n)):
    print("%d %d" %(i, arr[i]))

Answer 24

input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
    print(input_list[i])

मुझे लगता है कि यह एक आसान तरीका भी है ... इसे अंत से पढ़ें और सूची की लंबाई तक घटते रहें, क्योंकि हम कभी भी "अंत" सूचकांक निष्पादित नहीं करते हैं इसलिए -1 भी जोड़ा जाता है।

Answer 25

मान लेना कार्य अंतिम तत्व को खोजना है जो किसी सूची में कुछ स्थिति को संतुष्ट करता है (यानी पहली बार जब पीछे की ओर देखता है), तो मुझे निम्नलिखित नंबर मिल रहे हैं:

>>> min(timeit.repeat('for i in xrange(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
4.6937971115112305
>>> min(timeit.repeat('for i in reversed(xrange(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
4.809093952178955
>>> min(timeit.repeat('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
4.931743860244751
>>> min(timeit.repeat('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
5.548468112945557
>>> min(timeit.repeat('for i in xrange(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', repeat=8))
6.286104917526245
>>> min(timeit.repeat('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
8.384078979492188

तो, कुरकुरा विकल्प xrange(len(xs)-1,-1,-1)सबसे तेज है।

Answer 26

आप एक जनरेटर का उपयोग कर सकते हैं:

li = [1,2,3,4,5,6]
len_li = len(li)
gen = (len_li-1-i for i in range(len_li))

आखिरकार:

for i in gen:
    print(li[i])

आशा है कि यह आपकी मदद करेगा।