आप range()पायथन में निम्न सूची कैसे बना सकते हैं ?
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]जवाबों:
उपयोग reversed()समारोह:
reversed(range(10))यह बहुत अधिक सार्थक है।
अपडेट करें:
यदि आप चाहते हैं कि यह एक सूची हो (जैसा कि बीटीके ने कहा है):
list(reversed(range(10)))अपडेट करें:
यदि आप केवल rangeउसी परिणाम को प्राप्त करने के लिए उपयोग करना चाहते हैं , तो आप इसके सभी मापदंडों का उपयोग कर सकते हैं।range(start, stop, step)
उदाहरण के लिए, सूची बनाने के लिए [5,4,3,2,1,0], आप निम्नलिखित का उपयोग कर सकते हैं:
range(5, -1, -1)यह कम सहज हो सकता है लेकिन जैसा कि टिप्पणियों का उल्लेख है, यह अधिक कुशल है और उलट सूची के लिए सीमा का सही उपयोग है।
range(10), नहीं range(9)। इसके अलावा, यदि आप पूरी तरह से गठित सूची (स्लाइसिंग आदि के लिए) चाहते हैं, तो आपको करना चाहिए list(reversed(range(10)))।
reversedसामान्य रूप से जनरेटर को स्वीकार नहीं करता है लेकिन यह स्वीकार करता है range। reversed(range(10000))पूरी सूची के लिए मेमोरी आवंटित करने की आवश्यकता क्यों होगी ? rangeएक ऐसी वस्तु को लौटा सकता है जो उस __reversed__विधि को लागू करती है जो कुशल रिवर्स पुनरावृत्ति की अनुमति देती है?
'रेंज' बिल्ट-इन फ़ंक्शन का उपयोग करें। हस्ताक्षर है 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]
पायथन 3 में, यह एक गैर-सूची rangeऑब्जेक्ट का उत्पादन करता है , जो प्रभावी रूप से रीड-ओनली सूची की तरह कार्य करता है (लेकिन कम मेमोरी का उपयोग करता है, विशेष रूप से बड़ी रेंज के लिए)।
help(range)एक अजगर खोल में चलाते हैं तो यह आपको तर्क बताएगा। वे शुरू करने की संख्या, (समाप्त होने वाली संख्या) (अनन्य), और लेने का चरण है, इसलिए यह 9 से शुरू होता है और 1 तक घटाता है जब तक कि यह -1 तक नहीं पहुंच जाता (जिस बिंदु पर यह बिना वापस आए रुक जाता है, यही कारण है कि सीमा 0 पर समाप्त होती है)
range(start, stop, step) - संख्या पर शुरू start, और उपज परिणाम जब तक stopपहुँच गया है, stepहर बार से बढ़ रहा है ।
आप उपयोग कर सकते हैं range(10)[::-1]जो समान रूप से समान है range(9, -1, -1)और यकीनन अधिक पठनीय है (यदि आप सामान्य sequence[::-1]पायथन मुहावरे से परिचित हैं )।
उन लोगों के लिए जो अब तक एकत्र किए गए विकल्पों की "दक्षता" में रुचि रखते हैं ...
जैमे आरजीपी के जवाब मुझे करने के लिए नेतृत्व अपने कंप्यूटर को पुनः आरंभ करने के बाद समय की कुछ हद तक "को चुनौती देने" समाधान जेसन सचमुच मेरे अपने सुझाव (टिप्पणी के माध्यम से) के बाद। आप नीचे के उत्सुक को दूर करने के लिए, मैं यहाँ अपने परिणाम (सबसे खराब) पेश कर रहा हूँ:
जेसन का जवाब (शायद सूची समझ की शक्ति में एक भ्रमण ):
$ 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मिशैल harajer का उत्तर (स्वीकृत एक, बहुत पठनीय):
$ 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) द्वारा नोटेशन का उपयोग करना याद रखना आसान है ।
reverseक्योंकि रेंज विधि उलटी सूची वापस कर सकती है।जब आपके पास n आइटम पर पुनरावृत्ति होती है और range(start, stop, step)आपके द्वारा दी गई सूची के क्रम को बदलना चाहते हैं, तो रेंज के तीसरे पैरामीटर का उपयोग करना होगा जो stepइसे पहचानता है और इसे सेट करता है -1, अन्य मापदंडों को तदनुसार समायोजित किया जाएगा:
-1(इसके बारे में पिछले मान है stop - 1, stopके बराबर था 0)।n-1।तो रिवर्स ऑर्डर में रेंज (n) के बराबर होगा:
n = 10
print range(n-1,-1,-1)
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]reversed(range(n))
एक तरफ पठनीयता, की 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बस अगर किसी को आश्चर्य हो रहा था :)
range(1000000000-1,-1,-1)?
timeit range(1000000000-1,-1,-1)कि कमांड लाइन पर कोशिश न करें , इसके बजाय मेरे परिणाम देखें :-)
इस प्रश्न की आवश्यकता listअवरोही क्रम में आकार 10 के पूर्णांक के लिए कहती है । तो, चलो अजगर में एक सूची का उत्पादन करते हैं।
# 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]-1 पसंद है यह बिल्कुल यही पैटर्न है जो इसे रखना आसान बनाता है wrap one's head around this- आज मैंने सीखा कि अगर इसे वास्तव में कुशल होना है , range(n-1, -1, -1)तो रिवर्स ऑर्डर में एक सीमा को पार करते समय उपयोग करें ।
आप रेंज के साथ रिवर्स नंबरों की प्रिंटिंग कर सकते हैं () बीआईएफ लाइक,
for number in range ( 10 , 0 , -1 ) :
print ( number ) आउटपुट [10,9,8,7,6,5,4,3,2,1] होगा
रेंज () - रेंज (स्टार्ट, एंड, इन्क्रीमेंट / डिक्रीमेंट) जहां स्टार्ट इंक्लूसिव है, एंड एक्सक्लूसिव है और इंक्रीमेंट कोई भी नंबर हो सकता है और स्टेप की तरह बर्ताव कर सकता है
बहुत बार पूछा गया सवाल कि क्या पायथन 3 range(9, -1, -1)से बेहतर है reversed(range(10))? जो लोग पुनरावृत्तियों के साथ अन्य भाषाओं में काम करते हैं, वे तुरंत सोचते हैं कि उलट () सभी मूल्यों को कैश करना होगा और फिर रिवर्स ऑर्डर में वापस आना होगा। बात यह है कि reversed()यदि ऑब्जेक्ट सिर्फ एक पुनरावृत्ति है तो पायथन का ऑपरेटर काम नहीं करता है। ऑब्जेक्ट को काम करने के लिए दो के नीचे एक होना चाहिए ():
len()और पूर्णांक अनुक्रमित के माध्यम से[]__reversed__()विधि को लागू किया है।यदि आप ऐसी वस्तु पर उल्टा () प्रयोग करने का प्रयास करते हैं जिसमें ऊपर कोई नहीं है तो आपको मिलेगा:
>>> [reversed((x for x in range(10)))]
TypeError: 'generator' object is not reversibleतो संक्षेप में, पायथन reversed()केवल वस्तुओं की तरह सरणी पर होता है और इसलिए इसे आगे के पुनरावृत्ति के समान प्रदर्शन होना चाहिए।
लेकिन इससे क्या range()? क्या वह जनरेटर नहीं है? पायथन 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]reversed(range(10))कम त्रुटि वाला क्यों है। कोई अपराध नहीं। बस एक ईमानदार अवलोकन।
आपको आवश्यक रूप से रेंज फ़ंक्शन का उपयोग करने की आवश्यकता नहीं है, आप बस सूची [:: - 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)) निष्पादित नहीं होगा जो कि गलत है यदि आप संयोग से शून्य सूचकांक में एक ही वस्तु रखते हैं।
मैंने सोचा था कि कई (खुद के रूप में) एक मौजूदा सूची में उलट क्रम के बजाय मौजूदा सूची को ट्रेस करने के एक सामान्य मामले में अधिक रुचि हो सकती है , जैसा कि शीर्षक में कहा गया है, बजाय इस तरह के ट्रैवर्सल के लिए सूचक उत्पन्न करने के।
हालांकि, इस मामले के लिए सभी सही जवाब अभी भी पूरी तरह से ठीक हैं, मैं यह बताना चाहता हूं कि वुल्फ के जवाब में किए गए प्रदर्शन की तुलना केवल सूचकांक उत्पन्न करने के लिए है। इसलिए मैंने एक मौजूदा सूची को उल्टे क्रम में ट्रेस करने के लिए समान बेंचमार्क बनाया है।
टीएल; डीआर 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)जैसा कि आप देखते हैं, इस मामले में सूचकांकों को स्पष्ट रूप से उत्पन्न करने की कोई आवश्यकता नहीं है, इसलिए सबसे तेज़ तरीका वह है जो कम अतिरिक्त कार्य करता है।
नायब: मैंने जुपिटरलैब में परीक्षण किया जिसमें "मैजिक कमांड" है %timeit। यह timeit.timeitहुड के तहत मानक का उपयोग करता है । पायथन 3.7.3 के लिए परीक्षण किया गया