list.sort()सूची को सॉर्ट करें और मूल सूची sorted(list)को बदले , जबकि मूल सूची को बदले बिना, सूची की एक हल की गई प्रति लौटाता है।
list.sort()को प्रदर्शन किए जाने के बाद अनसोल्ड स्थिति में वापस लाया जा सकता है ?जवाबों:
sorted()एक नई क्रमबद्ध सूची देता है, जिससे मूल सूची अप्रभावित रह जाती है। list.sort()सूची को इन-प्लेस में बदलें, सूची सूचकांकों को म्यूट करते हुए, और रिटर्न None(सभी इन-प्लेस ऑपरेशंस की तरह)।
sorted()किसी सूची पर काम करता है, न कि केवल सूचियों पर। स्ट्रिंग्स, ट्यूपल्स, डिक्शनरी (आपको चाबियाँ मिलेंगी), जनरेटर आदि सभी तत्वों से युक्त एक सूची लौटाते हैं।
list.sort()जब आप सूची को बदलना चाहते हैं, sorted()तब उपयोग करें , जब आप एक नई छंटनी वाली वस्तु वापस चाहते हैं। का प्रयोग करें sorted()आप कुछ है कि एक iterable, एक नहीं सूची है क्रमबद्ध करना चाहते हैं जब अभी तक ।
सूचियों के लिए, list.sort()की तुलना में तेज़ है sorted()क्योंकि इसमें प्रतिलिपि बनाने की आवश्यकता नहीं है। किसी अन्य पुनरावृत्ति के लिए, आपके पास कोई विकल्प नहीं है।
नहीं, आप मूल पदों को पुनः प्राप्त नहीं कर सकते। एक बार जब आप कहते हैं list.sort()कि मूल आदेश चला गया है।
None, तो यह एक संकेत है, कि संचालन जगह में किया जाता है, इसीलिए, जब आप list.sort()इसे प्रिंट करना चाहते हैं तो कोई नहीं लौटाता है।
sorted(list)बनाम के बीच अंतर क्या हैlist.sort()?
list.sort सूची को इन-प्लेस और रिटर्न म्यूट करता है Nonesorted किसी भी पुनरावृत्ति लेता है और क्रमबद्ध एक नई सूची देता है।sorted यह पायथन कार्यान्वयन के बराबर है, लेकिन सीपीथॉन बिलिन फ़ंक्शन को औसत रूप से तेज चलना चाहिए क्योंकि यह सी में लिखा गया है:
def sorted(iterable, key=None):
new_list = list(iterable) # make a new list
new_list.sort(key=key) # sort it
return new_list # return itकब कौन सा उपयोग करना है?
list.sortजब आप मूल क्रम क्रम को बनाए रखने की इच्छा नहीं रखते हैं, तब उपयोग करें (इस प्रकार आप मेमोरी में सूची का पुन: उपयोग कर पाएंगे।) और जब आप सूची के एकमात्र स्वामी हों (यदि सूची अन्य कोड द्वारा साझा की गई हो और आप इसे म्यूट करें, आप उन बगों को पेश कर सकते हैं जहां उस सूची का उपयोग किया जाता है।)sortedजब आप मूल सॉर्ट क्रम बनाए रखना चाहते हैं या जब आप एक नई सूची है कि केवल अपने स्थानीय कोड का मालिक बनाने के लिए कामना करता हूं।क्या सूची के बाद एक सूची के मूल पदों को पुनः प्राप्त किया जा सकता है?
नहीं - जब तक आप स्वयं एक प्रति नहीं बनाते, तब तक वह जानकारी खो जाती है क्योंकि इस तरह का काम किया जाता है।
"और जो तेज है? और कितना तेज है?"
नई सूची बनाने के लिए दंड का वर्णन करने के लिए, समय-सीमा मॉड्यूल का उपयोग करें, यहां हमारा सेटअप है:
import timeit
setup = """
import random
lists = [list(range(10000)) for _ in range(1000)] # list of lists
for l in lists:
random.shuffle(l) # shuffle each list
shuffled_iter = iter(lists) # wrap as iterator so next() yields one at a time
"""और यहाँ बेतरतीब ढंग से व्यवस्थित 10000 पूर्णांकों की सूची के लिए हमारे परिणाम हैं, जैसा कि हम यहाँ देख सकते हैं, हमने एक पुरानी सूची व्यय सूची को समाप्त कर दिया है :
पायथन 2.7
>>> timeit.repeat("next(shuffled_iter).sort()", setup=setup, number = 1000)
[3.75168503401801, 3.7473005310166627, 3.753129180986434]
>>> timeit.repeat("sorted(next(shuffled_iter))", setup=setup, number = 1000)
[3.702025591977872, 3.709248117986135, 3.71071034099441]अजगर ३
>>> timeit.repeat("next(shuffled_iter).sort()", setup=setup, number = 1000)
[2.797430992126465, 2.796825885772705, 2.7744789123535156]
>>> timeit.repeat("sorted(next(shuffled_iter))", setup=setup, number = 1000)
[2.675589084625244, 2.8019039630889893, 2.849375009536743]कुछ प्रतिक्रिया के बाद, मैंने फैसला किया कि एक और परीक्षा विभिन्न विशेषताओं के साथ वांछनीय होगी। यहाँ मैं एक ही बेतरतीब ढंग से आदेशित सूची की लंबाई में प्रत्येक पुनरावृत्ति के लिए 1,000 बार प्रदान करता हूं।
import timeit
setup = """
import random
random.seed(0)
lst = list(range(100000))
random.shuffle(lst)
"""मैं इस बड़े प्रकार के अंतर की व्याख्या मार्टिज़न द्वारा उल्लिखित नकल से कर रहा हूं, लेकिन यह पुराने अधिक लोकप्रिय उत्तर में बताए गए बिंदु पर हावी नहीं है, यहां समय में वृद्धि लगभग 10% है
>>> timeit.repeat("lst[:].sort()", setup=setup, number = 10000)
[572.919036605, 573.1384446719999, 568.5923951]
>>> timeit.repeat("sorted(lst[:])", setup=setup, number = 10000)
[647.0584738299999, 653.4040515829997, 657.9457361929999]मैंने भी बहुत छोटे प्रकार से ऊपर भाग लिया, और देखा कि नया sortedकॉपी संस्करण अभी भी 1000 की लंबाई के बराबर चलने में लगभग 2% अधिक समय लेता है।
पोक ने अपना कोड भी चलाया, यहाँ का कोड है:
setup = '''
import random
random.seed(12122353453462456)
lst = list(range({length}))
random.shuffle(lst)
lists = [lst[:] for _ in range({repeats})]
it = iter(lists)
'''
t1 = 'l = next(it); l.sort()'
t2 = 'l = next(it); sorted(l)'
length = 10 ** 7
repeats = 10 ** 2
print(length, repeats)
for t in t1, t2:
print(t)
print(timeit(t, setup=setup.format(length=length, repeats=repeats), number=repeats))उन्होंने 1000000 की लंबाई की छंटनी के लिए पाया, (100 बार दौड़ा) एक समान परिणाम, लेकिन समय में केवल 5% वृद्धि के बारे में, यहाँ एक आउटपुट है:
10000000 100
l = next(it); l.sort()
610.5015971539542
l = next(it); sorted(l)
646.7786222379655sortedप्रतिलिपि बनाने के साथ छांटे जाने वाले एक बड़े आकार की सूची में अंतरों पर हावी होने की संभावना होगी, लेकिन छंटनी खुद ऑपरेशन पर हावी है, और इन अंतरों के आसपास अपने कोड को व्यवस्थित करना समय से पहले अनुकूलन होगा। मैं का प्रयोग करेंगे sortedजब मैं डेटा की एक नई क्रमबद्ध सूची की ज़रूरत है, और मैं का प्रयोग करेंगे list.sortजब मैं यथा-स्थान ही सूची को क्रमबद्ध करने की जरूरत है, और कहा कि मेरी उपयोगिता का निर्धारण करते हैं।
sorted()एक नई सूची ऑब्जेक्ट को आवंटित करना और संदर्भों की प्रतिलिपि बनाना है; बाकी कोड पथ समान हैं। देखें कि क्या आप समान परीक्षणों को बड़ी सूचियों के साथ चला सकते हैं। बस सूचियों की प्रतियां बनाने के साथ तुलना करें और अगर आप मतभेदों को आप पाया, आदि की नकल कर सकते हैं
मुख्य अंतर यह है कि sorted(some_list)एक नयाlist रिटर्न :
a = [3, 2, 1]
print sorted(a) # new list
print a # is not modifiedऔर some_list.sort(), जगह की सूची को छाँटें :
a = [3, 2, 1]
print a.sort() # in place
print a # it's modifiedध्यान दें कि a.sort()कुछ भी वापस नहीं करता है, print a.sort()प्रिंट करेगा None।
क्या सूची के बाद एक सूची मूल पदों को पुनः प्राप्त किया जा सकता है? ()
नहीं, क्योंकि यह मूल सूची को संशोधित करता है।
print a.sort()कुछ भी नहीं छापेंगे।
None, मैं स्पष्ट करूंगा।
.Sort () फ़ंक्शन नई सूची के मूल्य को सीधे सूची चर में संग्रहीत करता है; इसलिए आपके तीसरे प्रश्न का उत्तर NO होगा। यदि आप इसे सॉर्ट किए गए (सूची) का उपयोग करते हैं, तो आप इसका उपयोग कर सकते हैं क्योंकि यह सूची चर में संग्रहीत नहीं है। इसके अलावा कभी-कभी .sort () विधि फ़ंक्शन के रूप में कार्य करती है, या कहें कि इसमें तर्क होते हैं।
आपको छांटे गए (सूची) के मूल्य को एक चर में स्पष्ट रूप से संग्रहीत करना होगा।
शॉर्ट डेटा प्रोसेसिंग के लिए भी गति में कोई अंतर नहीं होगा; लेकिन लंबी सूचियों के लिए; आपको तेज काम के लिए सीधे .sort () विधि का उपयोग करना चाहिए; लेकिन फिर से आपको अपरिवर्तनीय कार्यों का सामना करना पड़ेगा।
list.sort()विधि यथा-स्थान सूची वस्तु क्रमबद्ध करता है।
.sort()विधि तर्क लेती है, और कार्य के रूप में कार्य करती है। इसके अलावा हम इसे विधि कहते हैं क्योंकि यह सूची डेटाटाइप की विशेषता है।
कार्रवाई में अंतर देखने के लिए यहां कुछ सरल उदाहरण दिए गए हैं:
संख्याओं की सूची यहां देखें:
nums = [1, 9, -3, 4, 8, 5, 7, 14]sortedइस सूची पर कॉल करते समय, सूची की sortedएक प्रति बना देगा । (मतलब आपकी मूल सूची अपरिवर्तित रहेगी।)
चलो देखते हैं।
sorted(nums)रिटर्न
[-3, 1, 4, 5, 7, 8, 9, 14]numsफिर से देखना
numsहम मूल सूची देखते हैं (अनलेल्ड और सॉर्ट नहीं किया गया है।)। sortedमूल सूची नहीं बदली
[1, 2, -3, 4, 8, 5, 7, 14]उसी numsसूची को लेना और उस sortपर फ़ंक्शन को लागू करना, वास्तविक सूची को बदल देगा।
चलो देखते हैं।
numsसुनिश्चित करने के लिए हमारी सूची के साथ शुरू , सामग्री अभी भी समान है।
nums
[-3, 1, 4, 5, 7, 8, 9, 14]
nums.sort()अब मूल अंक सूची बदल गई है और अंकों को देखते हुए हम देखते हैं कि हमारी मूल सूची बदल गई है और अब इसे क्रमबद्ध किया गया है।
nums
[-3, 1, 2, 4, 5, 7, 8, 14]नोट: सॉर्ट () और सॉर्ट किए गए () के बीच सबसे सरल अंतर है: सॉर्ट () कोई मान वापस नहीं करता है, जबकि सॉर्ट किया गया () एक पुनरावृत्त सूची देता है।
सॉर्ट () कोई मान नहीं लौटाता है।
सॉर्ट () विधि किसी दिए गए सूची के तत्वों को एक विशिष्ट क्रम में सॉर्ट करती है - आरोही या अवरोही बिना कोई मूल्य दिए।
सॉर्ट का सिंटैक्स () विधि है:
list.sort(key=..., reverse=...)वैकल्पिक रूप से, आप पायथन के इन-बिल्ट फंक्शन सॉर्ट () को भी इसी उद्देश्य के लिए उपयोग कर सकते हैं। सॉर्ट किए गए फ़ंक्शन रिटर्न सॉर्ट की गई सूची
list=sorted(list, key=..., reverse=...)
sorted()एक स्ट्रिंग तर्क पर कॉल करते हैं, लेकिन लगता है कि यह एक सूची है, तो आपको एक सूची परिणाम मिलता है, न कि एक स्ट्रिंग :sorted("abcd", reverse=True)देता['d', 'c', 'b', 'a']है"dcba"