पायथन में "उलट" सूची बनाने का सबसे अच्छा तरीका?

Question 1

पायथन में, एक नई सूची बनाने का सबसे अच्छा तरीका क्या है जिसकी वस्तुएं किसी अन्य सूची के समान हैं, लेकिन रिवर्स ऑर्डर में? (मैं मौजूदा सूची को संशोधित नहीं करना चाहता।)

यहाँ एक समाधान है जो मेरे साथ हुआ है:

new_list = list(reversed(old_list))

डुप्लिकेट करना संभव है old_listतब डुप्लिकेट को उल्टा कर दें:

new_list = list(old_list) # or `new_list = old_list[:]`
new_list.reverse()

क्या कोई बेहतर विकल्प है जिसकी मैंने अनदेखी की है? यदि नहीं, तो क्या उपरोक्त कारणों में से किसी एक का उपयोग करने के लिए एक सम्मोहक कारण (जैसे दक्षता) है?

Question 2

newlist = oldlist[::-1]

[::-1]टुकड़ा करने की क्रिया (जो मेरी पत्नी अन्ना को "द मार्टियन स्माइली" कहलाना पसंद करती है; ;-) का अर्थ है: पूरे क्रम को टुकड़ा करना, -1 के एक कदम के साथ, अर्थात, उल्टा। यह सभी दृश्यों के लिए काम करता है।

ध्यान दें कि यह ( और आपके द्वारा उल्लिखित विकल्प) एक "उथले कॉपी" के बराबर है, अर्थात: यदि आइटम परस्पर हैं और आप उन पर म्यूटेटर कहते हैं, तो मूल सूची में रखे गए आइटमों में म्यूटेशन भी आइटम में हैं। उलटी सूची, और इसके विपरीत। यदि आपको इससे बचने की आवश्यकता है, copy.deepcopy(जबकि हमेशा एक संभावित महंगा ऑपरेशन), इस मामले में एक के बाद .reverse, एक ही अच्छा विकल्प है।

Question 3

अब चलो timeit। संकेत: एलेक्स का [::-1]सबसे तेज :)

$ p -m timeit "ol = [1, 2, 3]; nl = list(reversed(ol))"
100000 loops, best of 3: 2.34 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = list(ol); nl.reverse();"
1000000 loops, best of 3: 0.686 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = ol[::-1];"
1000000 loops, best of 3: 0.569 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = [i for i in reversed(ol)];"
1000000 loops, best of 3: 1.48 usec per loop


$ p -m timeit "ol = [1, 2, 3]*1000; nl = list(reversed(ol))"
10000 loops, best of 3: 44.7 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = list(ol); nl.reverse();"
10000 loops, best of 3: 27.2 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = ol[::-1];"
10000 loops, best of 3: 24.3 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = [i for i in reversed(ol)];"
10000 loops, best of 3: 155 usec per loop

अपडेट: इंस्पेक्टर जी 4 डग द्वारा सुझाई गई सूची सूची विधि। मैं परिणामों को अपने लिए बोलने देता हूँ।

Question 4

समायोजन

यह sdolan द्वारा समय गणना के लिए एक बेसलाइन बेंचमार्क / समायोजन प्रदान करने के लायक है जो अक्सर अनावश्यक list()रूपांतरण के बिना 'उलट' के प्रदर्शन को दिखाता है । यह list()ऑपरेशन रनटाइम में एक अतिरिक्त 26 usecs जोड़ता है और केवल एक ईटरेटर अस्वीकार्य होने की स्थिति में इसकी आवश्यकता होती है।

परिणाम:

reversed(lst) -- 11.2 usecs

list(reversed(lst)) -- 37.1 usecs

lst[::-1] -- 23.6 usecs

गणना:

# I ran this set of 100000 and came up with 11.2, twice:
python -m timeit "ol = [1, 2, 3]*1000; nl = reversed(ol)"
100000 loops, best of 3: 11.2 usec per loop

# This shows the overhead of list()
python -m timeit "ol = [1, 2, 3]*1000; nl = list(reversed(ol))"
10000 loops, best of 3: 37.1 usec per loop

# This is the result for reverse via -1 step slices
python -m timeit "ol = [1, 2, 3]*1000;nl = ol[::-1]"
10000 loops, best of 3: 23.6 usec per loop

निष्कर्ष:

इन परीक्षणों का निष्कर्ष 12.4 usecs द्वारा reversed()स्लाइस से तेज है[::-1]