मैं पायथन में सूची कैसे बदल सकता हूं?

Question

मैं पायथन में निम्नलिखित कैसे कर सकता हूं?

array = [0, 10, 20, 40]
for (i = array.length() - 1; i >= 0; i--)

मुझे एक एरे के तत्वों की आवश्यकता है, लेकिन अंत से शुरुआत तक।

Answer 1

आप इसके लिए reversedफ़ंक्शन का उपयोग कर सकते हैं :

>>> array=[0,10,20,40]
>>> for i in reversed(array):
...     print(i)

ध्यान दें कि reversed(...)एक सूची वापस नहीं आती है। आप एक उलटी सूची का उपयोग कर प्राप्त कर सकते हैं list(reversed(array))।

Comments

क्या आप अभी उपयोग नहीं कर सकते हैं: सरणी [:: - 1]?

— kdlannoy

@kdlannoy जवाब में जुड़े पेज के अनुसार, "विस्तारित स्लाइसिंग की तुलना में, जैसे कि रेंज (1,4) [:: - 1], उलटा () पढ़ने में आसान है, तेजी से चलता है, और काफी कम मेमोरी का उपयोग करता है। "

— जिम ओल्डफील्ड

जब मैंने इस स्लाइसिंग का परीक्षण किया तो यह लगभग दो गुना तेज था (जब 10k तत्वों की सूची को उलट दिया गया और इससे एक सूची बनाई गई)। मैंने हालांकि मेमोरी खपत का परीक्षण नहीं किया। reverseयदि आप बाद में सूची में डालने की जरूरत नहीं है, हालांकि तेजी से हो सकता है।

— डेकरॉन

यह ध्यान देने योग्य है कि यह रिवर्स ([1,2,3]) के समान नहीं है, अंत में 'd' को nb करें ... जो नीचे दिए गए अन्य उत्तरों में से एक है, जो इसे इन-प्लेस करता है, जबकि यह रिटर्न एक सूचना देने वाला।

— लुसियानो

reversed()स्लाइसिंग के बजाय उपयोग क्यों करें ? पायथन के ज़ेन को पढ़ें, नियम संख्या 7: पठनीयता मायने रखती है!

— kramer65

Answer 2

>>> L = [0,10,20,40]
>>> L[::-1]
[40, 20, 10, 0]

विस्तारित स्लाइस सिंटैक्स को रिलीज़ के लिए पायथन व्हाट्स न्यू एंट्री में अच्छी तरह से समझाया गया है2.3.5

एक टिप्पणी में विशेष अनुरोध द्वारा यह सबसे वर्तमान स्लाइस प्रलेखन है ।

Comments

यह किसी भी इंटरएबल के लिए काम करता है, न कि केवल सूचियों के लिए। नुकसान यह है कि यह जगह में नहीं है।

— स्विस

@ यह एक टुकड़ा लौटाता है, इसलिए वास्तविक सूची सामग्री को नहीं बदलता है

— फोरट्रान 15'10

@lunixbochs ने पलटवार किया और न ही पायथन 3 में एक सूची दी

— स्विस 7

जब तक स्वाभाविक रूप से सरणी के भीतर अच्छी तरह से समझाया नहीं गया

— एयार पीटरसन 11

मैं @Swiss से सहमत हूं। +1 प्रश्न चूंकि मुझे एक सरणी के तत्वों की आवश्यकता थी, लेकिन अंत से शुरुआत तक। - reversedएक listreverseiteratorऑब्जेक्ट (पायथन 2.7.x) देता है, जिसे तब के माध्यम से पुनरावृत्त होना चाहिए - रिवर्स स्लाइसिंग एक उलट सूची / टपल / स्ट्रैट (आप क्या टुकड़ा कर रहे हैं पर निर्भर करता है) देता है। @ ईयर पीटरसन जो एक स्ट्रिंग को उलट रहा है, इसलिए आउटपुट सही है। कोशिश करें:co2=['ae','ad','ac','ab','aa','z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'] >>> co2[::-1]

— एरॉन न्यूटन

Answer 3

>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]

या

>>> L[::-1]
[40, 20, 10, 0]

Comments

[शुरू: स्टॉप: स्टेप] तो स्टेप -1 है

— पापलगी

विवरण: पहली सूची को इन-प्लेस संशोधित करता है, दूसरा केवल एक नई उलट सूची लौटाता है, लेकिन यह मूल को संशोधित नहीं करता है।

— फ्रैंज़ेलेंज़ोन

दूसरा उदाहरण L=L[::-1]वास्तव में सूची को उल्टा करने का होना चाहिए अन्यथा आप केवल रिवर्स में मान लौटा रहे हैं

— robertmoggach

मान लीजिए कि अगर मेरे पास l = [1,2,3,4,5,6] और n = 2 हैं तो उनका परिणाम [6,5,1,2,3,4] होना चाहिए, हम यह कैसे कर सकते हैं

— अतुल जैन

आप ऐसा कर सकते हैं:b = l[-n:] b.reverse() l = b + l[:len(l) - n]

— शोएब शकील

Answer 4

यह सूची की नकल करना है:

L = [0,10,20,40]
p = L[::-1]  #  Here p will be having reversed list

यह सूची को जगह में उलटना है:

L.reverse() # Here L will be reversed in-place (no new list made)

Answer 5

मुझे लगता है कि पायथन में सूची को उलटने का सबसे अच्छा तरीका है:

a = [1,2,3,4]
a = a[::-1]
print(a)
>>> [4,3,2,1]

काम पूरा हो गया है, और अब आपके पास एक उलट सूची है।

Answer 6

उसी सूची के उपयोग को उलटने के लिए:

array.reverse()

उलट सूची को कुछ अन्य सूची उपयोग में नियत करने के लिए:

newArray = array[::-1] 

Answer 7

स्लाइसिंग का उपयोग करते हुए, उदाहरण के लिए सरणी = सरणी [:: - 1], एक साफ सुथरी चाल है और बहुत पाइथोनिक है, लेकिन हो सकता है कि नए शौक के लिए थोड़ा अस्पष्ट हो। रिवर्स () विधि का उपयोग करना दिन के लिए दिन के कोडिंग में जाने का एक अच्छा तरीका है क्योंकि यह आसानी से पठनीय है।

हालांकि, अगर आपको साक्षात्कार प्रश्न के अनुसार सूची को उलटने की आवश्यकता है, तो आप संभवत: इन जैसे तरीकों का उपयोग नहीं कर पाएंगे। साक्षात्कारकर्ता यह देख रहा होगा कि आप पायथन ज्ञान की गहराई के बजाय समस्या को कैसे देखते हैं, एक एल्गोरिथम दृष्टिकोण की आवश्यकता है। निम्न उदाहरण, एक क्लासिक स्वैप का उपयोग करते हुए, इसे करने का एक तरीका हो सकता है: -

def reverse_in_place(lst):      # Declare a function
    size = len(lst)             # Get the length of the sequence
    hiindex = size - 1
    its = size/2                # Number of iterations required
    for i in xrange(0, its):    # i is the low index pointer
        temp = lst[hiindex]     # Perform a classic swap
        lst[hiindex] = lst[i]
        lst[i] = temp
        hiindex -= 1            # Decrement the high index pointer
    print "Done!"

# Now test it!!
array = [2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]

print array                    # Print the original sequence
reverse_in_place(array)        # Call the function passing the list
print array                    # Print reversed list


**The result:**
[2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]
Done!
[654, 124, 24, 7, 1, 65, 60, 32, 27, 25, 19, 12, 9, 8, 5, 2]

ध्यान दें कि यह Tuples या स्ट्रिंग अनुक्रमों पर काम नहीं करेगा, क्योंकि तार और tuples अपरिवर्तनीय हैं, अर्थात, आप तत्वों को बदलने के लिए उनमें नहीं लिख सकते।

Comments

क्लासिक स्वैप के माध्यम से किया जा सकता है lst[hiindex], lst[i] = lst[i], lst[hiindex], मुझे लगता है ... ;-)

— सैमोथ

@Samoth वह वाक्य-विन्यास उतना स्पष्ट नहीं है और व्यवहार बिल्कुल स्पष्ट नहीं है। विकृत कदम अधिक समझ में आता है।

— एंथनी

क्यों लोग कहते हैं कि सरणी जैसी चीजें ::: - 1] पायथोनिक हैं? अजगर ज़ेन हमें सिखाते हैं कि स्पष्ट रूप से निहित और पठनीयता की गणना से बेहतर है। सामान की तरह स्पष्ट और पठनीय नहीं हैं।

— k4ppa

@ k4ppa: यदि आप पायथन को जानते हैं तोarray[::-1] पूरी तरह से पठनीय और पूरी तरह से स्पष्ट है । "पठनीय" का मतलब यह नहीं है "कोई व्यक्ति जिसने पहले पायथन स्लाइसिंग का उपयोग नहीं किया है, उसे पढ़ने में सक्षम होना चाहिए"; पीछे टुकड़ा (यदि आप मौजूदा कोड हर समय में यह सामना करना पड़ेगा) पायथन में एक हास्यास्पद आम मुहावरा है, और यह पूरी तरह से पठनीय है यदि आप नियमित रूप अजगर का उपयोग । बेशक, , स्पष्ट और स्पष्ट है, लेकिन है कि यह तुलना में बेहतर नहीं है । [::-1]first10 = []for i in range(10): first10.append(array[i])first10 = array[:10]

— शैडो रेंजर

Answer 8

मुझे लगता है (कुछ अन्य सुझावों के विपरीत) जो कि l.reverse()पायथन 3 और 2 में एक लंबी सूची को उलटने का सबसे तेज़ तरीका है। मुझे यह जानने में दिलचस्पी होगी कि क्या अन्य लोग इन समयों को दोहरा सकते हैं।

l[::-1]शायद धीमा है क्योंकि यह सूची को उलटने से पहले कॉपी करता है। जोड़ा जा रहा है list()के द्वारा बनाई गई इटरेटर चारों ओर कॉल reversed(l)कुछ भूमि के ऊपर जोड़ना होगा। बेशक यदि आप सूची या एक पुनरावृत्त की प्रतिलिपि चाहते हैं, तो उन संबंधित विधियों का उपयोग करें, लेकिन यदि आप सूची को उल्टा करना चाहते हैं तो l.reverse()सबसे तेज़ तरीका प्रतीत होता है।

कार्य

def rev_list1(l):
    return l[::-1]

def rev_list2(l):
    return list(reversed(l))

def rev_list3(l):
    l.reverse()
    return l

सूची

l = list(range(1000000))

पायथन 3.5 समय

timeit(lambda: rev_list1(l), number=1000)
# 6.48
timeit(lambda: rev_list2(l), number=1000)
# 7.13
timeit(lambda: rev_list3(l), number=1000)
# 0.44

पायथन 2.7 समय

timeit(lambda: rev_list1(l), number=1000)
# 6.76
timeit(lambda: rev_list2(l), number=1000)
# 9.18
timeit(lambda: rev_list3(l), number=1000)
# 0.46

Comments

list.reverseसबसे तेज है, क्योंकि यह जगह में उलट जाता है

— युद्धविरुक

आप सही हैं list.reverse()सबसे तेज़ हैं, लेकिन आप दंड दे रहे हैं reversed(जिसका उपयोग तब किया जाता है जब आप नया नहीं चाहते हैं list, बस listमूल को बदलने के बिना रिवर्स ऑर्डर में किसी मौजूदा को पुनरावृत्त करने के लिए ), और टुकड़ा (जो मूल को बदलने से भी बचता है) list, और आम तौर पर reversedइनपुट छोटा होने पर) की तुलना में तेज होता है। हां, अगर आपको कॉपी की आवश्यकता नहीं है, तो कुछ भी जो प्रतियां अधिक महंगा है, लेकिन बहुत समय, आप मूल मूल्य को म्यूट नहीं करना चाहते हैं।

— शैडो रेंजर

ऐसा लगता है कि reversed अभीlist.reverse() भी ऐसा करने के लिए खो देता है , लेकिन इसे देखते हुए इनपुट को म्यूट नहीं किया जाता है list, यह कई मामलों में बेहतर है। के लिए नुकसान reversedछोटा है (~ 1/6 से अधिक लंबा list.reverse())।

— शैडो रेंजर

Answer 9

for x in array[::-1]:
    do stuff

Comments

यह टुकड़ा करने की विधि बहुत पठनीय नहीं है। पाइथोनिक तरीका रिवर्स () विधि का उपयोग करना होगा। ;-)

— सिमोन

@SimonM रिवर्स () निश्चित रूप से एक नज़र में समझना आसान है।

— स्विस

Answer 10

के साथ reversedऔर list:

>>> list1 = [1,2,3]
>>> reversed_list = list(reversed(list1))
>>> reversed_list
>>> [3, 2, 1]

Answer 11

array=[0,10,20,40]
for e in reversed(array):
  print e

Answer 12

उलट (सरणी) का उपयोग करने की संभावना सबसे अच्छा मार्ग होगा।

>>> array = [1,2,3,4]
>>> for item in reversed(array):
>>>     print item

क्या आपको यह समझने की आवश्यकता है कि बिना बिल्ट इन का उपयोग किए इसे कैसे लागू किया जा सकता है reversed।

def reverse(a):
    midpoint = len(a)/2
    for item in a[:midpoint]:
        otherside = (len(a) - a.index(item)) - 1
        temp = a[otherside]
        a[otherside] = a[a.index(item)]
        a[a.index(item)] = temp
    return a

यह O (N) समय लेना चाहिए।

Comments

रिवर्स फ़ंक्शन का उपयोग किए बिना ऐसा करने के लिए देख रहा था। धन्यवाद।

— बर्नार्ड 'बीटा बर्लिन' पारा

या जगह उपयोग सूची में उलटने के लिए = list.reverse ()

— सिमोन

Answer 13

यदि आप किसी अन्य चर में उल्टे सूची के तत्वों को संग्रहीत करना चाहते हैं, तो आप उपयोग कर सकते हैं revArray = array[::-1]या कर सकते हैं revArray = list(reversed(array))।

लेकिन पहला संस्करण थोड़ा तेज है:

z = range(1000000)
startTimeTic = time.time()
y = z[::-1]
print("Time: %s s" % (time.time() - startTimeTic))

f = range(1000000)
startTimeTic = time.time()
g = list(reversed(f))
print("Time: %s s" % (time.time() - startTimeTic))

आउटपुट:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

Comments

अगली बार, आप उपयोग करना चाह सकते हैं timeit।

— नाली

Answer 14

संगठन का मूल्य:

पायथन में, सूचियों के क्रम को भी क्रमबद्ध किया जा सकता है , अपने चर को संख्यात्मक / वर्णमाला क्रम में व्यवस्थित करना:

अस्थायी रूप से:

print(sorted(my_list))

स्थायी:

my_list.sort(), print(my_list)

आप ध्वज "रिवर्स = ट्रू" के साथ सॉर्ट कर सकते हैं :

print(sorted(my_list, reverse=True))

या

my_list.sort(reverse=True), print(my_list)

संगठन के बिना

हो सकता है कि आप मूल्यों को क्रमबद्ध नहीं करना चाहते हैं, लेकिन केवल मूल्यों को उल्टा कर सकते हैं। फिर हम इसे इस तरह से कर सकते हैं:

print(list(reversed(my_list)))

** नंबरों की लिस्टिंग क्रम में वर्णमाला पर प्राथमिकता है। पायथन मूल्यों का संगठन कमाल का है।

Answer 15

स्पष्टीकरण और समय परिणामों के साथ तरीकों का सारांश

कई अच्छे उत्तर हैं, लेकिन फैल गए हैं और अधिकांश प्रत्येक दृष्टिकोण के बुनियादी अंतर को इंगित नहीं करते हैं।

कुल मिलाकर, बिल्ट-इन फ़ंक्शन / तरीकों का उपयोग करना बेहतर है, जैसे कि किसी फ़ंक्शन के बारे में। इस मामले में, वे छोटी सूचियों (10 आइटम) पर लगभग 2 से 8 गुना तेजी से होते हैं, और मैन्युअल रूप से अनुक्रमण के साधन की तुलना में लंबी सूचियों पर ~ 300 + गुना अधिक तेज होते हैं। यह समझ में आता है क्योंकि उनके पास विशेषज्ञ हैं जो उन्हें बनाते हैं, छानबीन करते हैं, और अनुकूलन करते हैं। वे दोषों के लिए भी कम प्रवण हैं और किनारे और कोने के मामलों को संभालने की अधिक संभावना है।

यह भी विचार करें कि क्या आप चाहते हैं:

1. किसी मौजूदा सूची को इन-प्लेस में उलट दें
   • सबसे अच्छा समाधान `object.reverse () विधि है
2. सूची के उल्टे हिस्से का एक इटरेटर बनाएं (क्योंकि आप इसे फॉर-लूप, एक जनरेटर आदि के लिए फीड करने जा रहे हैं)
   • सबसे अच्छा समाधान 'उलट (वस्तु) `है जो पुनरावृत्त बनाता है
3. या एक पूर्ण प्रति बनाएँ जो रिवर्स ऑर्डर में हो
   • सर्वश्रेष्ठ समाधान -1 चरण आकार के साथ स्लाइस का उपयोग कर रहा है: object[::-1]

टेस्ट स्क्रिप्ट

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

from timeit import timeit
from copy import copy

def time_str_ms(t):
    return '{0:8.2f} ms'.format(t * 1000)

विधि 1: obj.reverse के साथ जगह में उल्टा ()

यदि लक्ष्य एक मौजूदा सूची में वस्तुओं के क्रम को उलटने के लिए है, तो उन पर नियंत्रण किए बिना या कार्य करने के लिए एक प्रति प्राप्त करने के बिना, <list>.reverse()फ़ंक्शन का उपयोग करें । इसे सीधे किसी सूची ऑब्जेक्ट पर चलाएँ, और सभी आइटमों का क्रम उलट जाएगा:

ध्यान दें कि निम्नलिखित दिए गए मूल चर को उलट देगा, भले ही वह उलट सूची को वापस लौटा दे। यानी आप इस फंक्शन आउटपुट का उपयोग करके एक कॉपी बना सकते हैं। आमतौर पर, आप इसके लिए कोई फ़ंक्शन नहीं करेंगे, लेकिन मैंने अंत में टाइमिंग कोड का उपयोग करने के लिए ऐसा किया।

हम इस दो तरीकों के प्रदर्शन का परीक्षण करेंगे - पहले केवल एक सूची को इन-प्लेस (मूल सूची में परिवर्तन) को उल्टा कर रहे हैं, और फिर सूची की प्रतिलिपि बनाकर उसे बाद में उलट देंगे।

def rev_in_place(mylist):
    mylist.reverse()
    return mylist

def rev_copy_reverse(mylist):
    a = copy(mylist)
    a.reverse()
    return a

विधि 2: स्लाइस का उपयोग करके किसी सूची को उल्टा करें obj[::-1]

अंतर्निहित इंडेक्स स्लाइसिंग विधि आपको किसी भी अनुक्रमित वस्तु के हिस्से की प्रतिलिपि बनाने की अनुमति देती है।

• यह मूल वस्तु को प्रभावित नहीं करता है
• यह एक पूर्ण सूची बनाता है, एक पुनरावृत्ति नहीं

सामान्य वाक्य रचना है: <object>[first_index:last_index:step]। सरल उलट सूची बनाने के लिए स्लाइसिंग का फायदा उठाने के लिए, उपयोग करें <list>[::-1]:। किसी विकल्प को खाली छोड़ते समय, यह उन्हें ऑब्जेक्ट के पहले और अंतिम तत्व की डिफॉल्ट करने के लिए सेट करता है (यदि स्टेप साइज निगेटिव है तो उल्टा)।

अनुक्रमण एक को नकारात्मक संख्याओं का उपयोग करने की अनुमति देता है, जो कि वस्तु के सूचकांक के अंत से पीछे की ओर गिनती करता है (यानी -2 अंतिम आइटम के लिए दूसरा है)। जब चरण का आकार नकारात्मक होता है, तो यह अंतिम राशि और उस राशि द्वारा पिछड़े सूचकांक के साथ शुरू होगा। इससे जुड़े कुछ स्टार्ट-एंड लॉजिक हैं जिन्हें ऑप्टिमाइज़ किया गया है।

def rev_slice(mylist):
    a = mylist[::-1]
    return a

विधि 3: reversed(obj)पुनरावृत्ति फ़ंक्शन के साथ किसी सूची को उल्टा

एक reversed(indexed_object)समारोह है:

• यह एक सूची नहीं बल्कि एक रिवर्स इंडेक्स इटरेटर बनाता है। यदि आप बड़ी सूची में बेहतर प्रदर्शन के लिए इसे लूप में खिला रहे हैं तो बढ़िया है
• यह एक प्रति बनाता है और मूल वस्तु को प्रभावित नहीं करता है

एक कच्चे पुनरावृत्त दोनों के साथ परीक्षण करें, और पुनरावृत्त से एक सूची बनाएं।

def reversed_iterator(mylist):
    a = reversed(mylist)
    return a

def reversed_with_list(mylist):
    a = list(reversed(mylist))
    return a

विधि 4: कस्टम / मैन्युअल अनुक्रमण के साथ सूची को उल्टा

जैसे ही समय प्रदर्शित होगा, अनुक्रमण के अपने तरीके बनाना एक बुरा विचार है। अंतर्निहित विधियों का उपयोग करें जब तक कि आपको वास्तव में कुछ कस्टम करने की आवश्यकता न हो।

उस ने कहा, छोटी सूची के आकार के साथ एक बहुत बड़ा जुर्माना नहीं है, लेकिन जब आप पेनल्टी लेते हैं तो यह जबरदस्त हो जाता है। मुझे यकीन है कि नीचे दिया गया मेरा कोड अनुकूलित किया जा सकता है, लेकिन मैं बिल्ट-इन तरीकों के साथ रहना चाहूंगा।

def rev_manual_pos_gen(mylist):
    max_index = len(mylist) - 1
    return [ mylist[max_index - index] for index in range(len(mylist)) ]

def rev_manual_neg_gen(mylist):
    ## index is 0 to 9, but we need -1 to -10
    return [ mylist[-index-1] for index in range(len(mylist)) ]

def rev_manual_index_loop(mylist):
    a = []
    reverse_index = len(mylist) - 1
    for index in range(len(mylist)):
        a.append(mylist[reverse_index - index])
    return a

def rev_manual_loop(mylist):
    a = []
    reverse_index = len(mylist)
    for index, _ in enumerate(mylist):
        reverse_index -= 1
        a.append(mylist[reverse_index])
    return a

प्रत्येक विधि का समय

निम्नलिखित प्रत्येक विधि को पलटने की स्क्रिप्ट के बाद है। यह जगह में उलट-पुलट दिखाता है obj.reverse()और reversed(obj)पुनरावृत्त बनाना हमेशा सबसे तेज़ होता है, जबकि स्लाइस का उपयोग प्रतिलिपि बनाने का सबसे तेज़ तरीका है।

यह भी साबित करने की कोशिश नहीं करता है कि इसे अपने दम पर करने का एक तरीका है जब तक कि आपके पास नहीं है!

loops_to_test = 100000
number_of_items = 10
list_to_reverse = list(range(number_of_items))
if number_of_items < 15:
    print("a: {}".format(list_to_reverse))
print('Loops: {:,}'.format(loops_to_test))
# List of the functions we want to test with the timer, in print order
fcns = [rev_in_place, reversed_iterator, rev_slice, rev_copy_reverse,
        reversed_with_list, rev_manual_pos_gen, rev_manual_neg_gen,
        rev_manual_index_loop, rev_manual_loop]
max_name_string = max([ len(fcn.__name__) for fcn in fcns ])
for fcn in fcns:
    a = copy(list_to_reverse) # copy to start fresh each loop
    out_str = ' | out = {}'.format(fcn(a)) if number_of_items < 15 else ''
    # Time in ms for the given # of loops on this fcn
    time_str = time_str_ms(timeit(lambda: fcn(a), number=loops_to_test))
    # Get the output string for this function
    fcn_str = '{}(a):'.format(fcn.__name__)
    # Add the correct string length to accommodate the maximum fcn name
    format_str = '{{fx:{}s}} {{time}}{{rev}}'.format(max_name_string + 4)
    print(format_str.format(fx=fcn_str, time=time_str, rev=out_str))

समय परिणाम

परिणाम बताते हैं कि स्केलिंग बिल्ट-इन तरीकों के साथ सबसे अच्छा काम करती है जो किसी दिए गए कार्य के लिए सबसे उपयुक्त है। दूसरे शब्दों में, जैसे-जैसे ऑब्जेक्ट एलिमेंट काउंट बढ़ता है, बिल्ट-इन तरीकों में बेहतर प्रदर्शन परिणाम होने लगते हैं।

तुम भी सबसे अच्छा में निर्मित विधि का उपयोग कर बेहतर है कि सीधे क्या आप एक साथ स्ट्रिंग चीजों की तुलना में की जरूरत है प्राप्त करता है। यदि आप उलटी सूची की एक प्रति की आवश्यकता है, तो स्लाइसिंग सबसे अच्छा है - यह reversed()फ़ंक्शन से एक सूची बनाने की तुलना में तेज़ है , और सूची की एक प्रतिलिपि बनाने की तुलना में तेज़ है और फिर इन-प्लेस कर रहा है obj.reverse()। लेकिन अगर उन तरीकों में से कोई भी वास्तव में आपकी ज़रूरत है, तो वे तेज़ हैं, लेकिन कभी भी दोगुनी से अधिक गति से नहीं। इस बीच, रिवाज, मैनुअल तरीके, परिमाण के आदेशों को लंबे समय तक ले सकते हैं, खासकर बहुत बड़ी सूचियों के साथ।

स्केलिंग के लिए, एक 1000 आइटम सूची के साथ, reversed(<list>)फंक्शन कॉल ~ 30 एमएस को इट्रर सेटअप करने के लिए लेता है, इन-प्लेस को पलटने में सिर्फ ~ 55 एमएस लगता है, स्लाइस विधि का उपयोग करके ~ 210 एमएस को पूर्ण उलट सूची की प्रतिलिपि बनाने के लिए, लेकिन सबसे तेज मैनुअल विधि मैंने बनाई ~ 8400 एमएस !!

सूची में 2 आइटम के साथ:

a: [0, 1]
Loops: 100,000
rev_in_place(a):             24.70 ms | out = [1, 0]
reversed_iterator(a):        30.48 ms | out = <list_reverseiterator object at 0x0000020242580408>
rev_slice(a):                31.65 ms | out = [1, 0]
rev_copy_reverse(a):         63.42 ms | out = [1, 0]
reversed_with_list(a):       48.65 ms | out = [1, 0]
rev_manual_pos_gen(a):       98.94 ms | out = [1, 0]
rev_manual_neg_gen(a):       88.11 ms | out = [1, 0]
rev_manual_index_loop(a):    87.23 ms | out = [1, 0]
rev_manual_loop(a):          79.24 ms | out = [1, 0]

सूची में 10 आइटम के साथ:

rev_in_place(a):             23.39 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_iterator(a):        30.23 ms | out = <list_reverseiterator object at 0x00000290A3CB0388>
rev_slice(a):                36.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_copy_reverse(a):         64.67 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_with_list(a):       50.77 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_pos_gen(a):      162.83 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_neg_gen(a):      167.43 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_index_loop(a):   152.04 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_loop(a):         183.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

और सूची में 1000 वस्तुओं के साथ:

rev_in_place(a):             56.37 ms
reversed_iterator(a):        30.47 ms
rev_slice(a):               211.42 ms
rev_copy_reverse(a):        295.74 ms
reversed_with_list(a):      418.45 ms
rev_manual_pos_gen(a):     8410.01 ms
rev_manual_neg_gen(a):    11054.84 ms
rev_manual_index_loop(a): 10543.11 ms
rev_manual_loop(a):       15472.66 ms

Answer 16

कुछ तर्क का उपयोग करना

साक्षात्कार के लिए अभ्यास करने के लिए कुछ पुराने स्कूल तर्क का उपयोग करना।

आगे से पीछे की ओर स्वैपिंग संख्या। दो पॉइंटर्स का उपयोग करनाindex[0] and index[last]

def reverse(array):
    n = array
    first = 0
    last = len(array) - 1
    while first < last:
      holder = n[first]
      n[first] = n[last]
      n[last] = holder
      first += 1
      last -= 1
    return n

input -> [-1 ,1, 2, 3, 4, 5, 6]
output -> [6, 1, 2, 3, 4, 5, -1]

Comments

अगर हम सूची को दो में विभाजित करते हैं और पहले को अंतिम सूचकांक के साथ स्वैप करते हैं और समय जटिलता सूचीबद्ध नमूने की तुलना में अधिक कुशल होगी।

— इज़राइल Manzo

Answer 17

आप सरणी इंडेक्स के बिटवाइज़ सप्लीमेंट का उपयोग रिवर्स में सरणी के माध्यम से करने के लिए भी कर सकते हैं :

>>> array = [0, 10, 20, 40]
>>> [array[~i] for i, _ in enumerate(array)]
[40, 20, 10, 0]

आप जो भी करते हैं, उसे इस तरह से नहीं करते हैं।

Answer 18

सूची समझ का उपयोग करें:

[array[n] for n in range(len(array)-1, -1, -1)]

Answer 19

एक अन्य समाधान का उपयोग करने के होगा numpy.flip इस के लिए

import numpy as np
array = [0, 10, 20, 40]
list(np.flip(array))
[40, 20, 10, 0]

Answer 20

कड़ाई से बोलते हुए, सवाल यह नहीं है कि किसी सूची को रिवर्स में कैसे लौटाया जाए, बल्कि उदाहरण सूची नाम के साथ किसी सूची को कैसे रिवर्स किया जाए array।

"array"उपयोग नामक सूची को उलटने के लिए array.reverse()।

वर्णित के रूप में अविश्वसनीय रूप से उपयोगी स्लाइस विधि का उपयोग सूची के स्थान पर एक सूची को उलटने के लिए भी किया जा सकता है array = array[::-1]।

Comments

अंतिम वाक्य सत्य नहीं है, यह जगह की सूची को उलट नहीं करता है; यह कहना चाहिएarray[:] = array[::-1]

— एंटिटी हवाला

Answer 21

def reverse(text):
    output = []
    for i in range(len(text)-1, -1, -1):
        output.append(text[i])
    return output

Answer 22

बिल्ट-इन फ़ंक्शन की न्यूनतम मात्रा के साथ, यह साक्षात्कार सेटिंग्स है

array = [1, 2, 3, 4, 5, 6,7, 8]
inverse = [] #create container for inverse array
length = len(array)  #to iterate later, returns 8 
counter = length - 1  #because the 8th element is on position 7 (as python starts from 0)

for i in range(length): 
   inverse.append(array[counter])
   counter -= 1
print(inverse)

Answer 23

पायथन में आपकी आवश्यकता का सबसे सीधा अनुवाद यह forकथन है:

for i in xrange(len(array) - 1, -1, -1):
   print i, array[i]

यह बल्कि गुप्त है लेकिन उपयोगी हो सकता है।

Answer 24

def reverse(my_list):
  L = len(my_list)
  for i in range(L/2):
    my_list[i], my_list[L-i - 1] = my_list[L-i-1], my_list[i]
  return my_list

Comments

//फ्लोर डिवीजन ऑपरेटर के साथ बेहतर है ।

— वैलेंटाइन पॉडकामेनी

Answer 25

आप हमेशा सूची को एक स्टैक की तरह मान सकते हैं, सूची के पीछे के छोर से स्टैक के शीर्ष पर स्थित तत्वों को पॉपअप करते हुए। इस तरह से आप स्टैक की अंतिम विशेषताओं में पहले का लाभ उठाते हैं। बेशक आप 1 सरणी का उपभोग कर रहे हैं। मुझे यह तरीका पसंद है कि यह बहुत सहज है कि आप एक सूची को पीछे के छोर से उपभोग करते हुए देखते हैं जबकि दूसरे को सामने के छोर से बनाया जा रहा है।

>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
        nl.append(l.pop())  
>>> print nl
[6, 5, 4, 3, 2, 1]

Answer 26

list_data = [1,2,3,4,5]
l = len(list_data)
i=l+1
rev_data = []
while l>0:
  j=i-l
  l-=1
  rev_data.append(list_data[-j])
print "After Rev:- %s" %rev_data 

Answer 27

उपयोग

print(reversed(list_name))

Answer 28

यहाँ एक जनरेटर का उपयोग करके उल्टे का मूल्यांकन करने का एक तरीका है :

def reverse(seq):
    for x in range(len(seq), -1, -1): #Iterate through a sequence starting from -1 and increasing by -1.
        yield seq[x] #Yield a value to the generator

अब इस तरह के माध्यम से पुनरावृति:

for x in reverse([1, 2, 3]):
    print(x)

यदि आपको सूची चाहिए:

l = list(reverse([1, 2, 3]))

Answer 29

उलटी सूची प्राप्त करने के लिए 3 विधियाँ हैं:

1. टुकड़ा करने की क्रिया विधि 1: reversed_array = array[-1::-1]

2. टुकड़ा करने की क्रिया विधि 2: reversed_array2 = array[::-1]

3. बिलिन फ़ंक्शन का उपयोग करना: reversed_array = array.reverse()

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

Answer 30

>>> l = [1, 2, 3, 4, 5]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]

Comments

यह समाधान की तुलना में लगभग 4.5k गुना धीमा है l[::-1], और एक ही समय में बहुत कम सुपाठ्य है। पायथन में कार्यात्मक प्रोग्रामिंग दु: खद है बल्कि धीमी है।

— १३:०