एक सूची में शामिल होना:
>>> ''.join([ str(_) for _ in xrange(10) ])
'0123456789'
join एक पुनरावृत्ति लेना चाहिए।
जाहिर है, joinतर्क है [ str(_) for _ in xrange(10) ], और यह एक सूची समझ है ।
इसे देखो:
>>>''.join( str(_) for _ in xrange(10) )
'0123456789'
अब, joinतर्क सिर्फ str(_) for _ in xrange(10), नहीं [], लेकिन परिणाम समान है।
क्यों? है str(_) for _ in xrange(10)भी एक सूची या एक iterable उत्पादन?
_कोई विशेष अर्थ नहीं है, यह एक नियमित चर नाम है। इसका उपयोग अक्सर थ्रो-दूर नाम के रूप में किया जाता है लेकिन यह मामला नहीं है (आप चर का उपयोग कर रहे हैं)। मैं एक कोड में इसका उपयोग करने से बचूंगा (इस तरह कम से कम)।
जवाबों:
>>>''.join( str(_) for _ in xrange(10) )
इसे एक जनरेटर अभिव्यक्ति कहा जाता है , और पीईपी 289 में समझाया गया है ।
जनरेटर अभिव्यक्तियों और सूची समझ के बीच मुख्य अंतर यह है कि पूर्व स्मृति में सूची नहीं बनाते हैं।
ध्यान दें कि अभिव्यक्ति लिखने का तीसरा तरीका है:
''.join(map(str, xrange(10)))
( str(_) for _ in xrange(10) )। लेकिन मुझे भ्रम था कि, क्यों ()छोड़ा जा सकता है join, जिसका अर्थ है, कोड `'की तरह होना चाहिए। (x (10)) में _ के लिए ((_)), सही?
tup = 1, 2, 3; print(tup)। इसे ध्यान में रखते हुए, forएक अभिव्यक्ति के हिस्से के रूप में उपयोग करने से जनरेटर का निर्माण होता है और इसे गलत लिखित लूप से अलग करने के लिए कोष्ठक होता है।
अन्य उत्तरदाता यह जवाब देने में सही थे कि आपने एक जनरेटर अभिव्यक्ति की खोज की थी (जिसमें सूची बोध के समान अंकन है लेकिन आसपास के वर्ग कोष्ठक के बिना)।
सामान्य तौर पर, जीनएक्सप्स (जैसा कि वे प्यार से जानते हैं) सूची की समझ से अधिक स्मृति कुशल और तेज हैं।
फिर भी, यह मामला है ''.join(), एक सूची समझ तेज और अधिक स्मृति कुशल दोनों है। कारण यह है कि जुड़ने के लिए डेटा पर दो पास बनाने की आवश्यकता होती है, इसलिए इसे वास्तव में एक वास्तविक सूची की आवश्यकता होती है। यदि आप इसे एक देते हैं, तो यह तुरंत अपना काम शुरू कर सकता है। यदि आप इसे इसके बजाय एक जीनएक्सपी देते हैं, तो यह तब तक काम शुरू नहीं कर सकता है जब तक कि यह जेनएक्सएक्स को थकावट से स्मृति में एक नई सूची नहीं बनाता है:
~ $ python -m timeit '"".join(str(n) for n in xrange(1000))'
1000 loops, best of 3: 335 usec per loop
~ $ python -m timeit '"".join([str(n) for n in xrange(1000)])'
1000 loops, best of 3: 288 usec per loop
नक्शे में itertools.imap की तुलना करते समय एक ही परिणाम होता है :
~ $ python -m timeit -s'from itertools import imap' '"".join(imap(str, xrange(1000)))'
1000 loops, best of 3: 220 usec per loop
~ $ python -m timeit '"".join(map(str, xrange(1000)))'
1000 loops, best of 3: 212 usec per loop
''.join()स्ट्रिंग बनाने के लिए इटरेटर पर 2 पास की आवश्यकता क्यों है ?
आपका दूसरा उदाहरण सूची की समझ के बजाय एक जनरेटर अभिव्यक्ति का उपयोग करता है। अंतर यह है कि सूची की समझ के साथ, एक सूची पूरी तरह से निर्मित और पारित की जाती है .join()। जनरेटर अभिव्यक्ति के साथ, आइटम एक-एक करके उत्पन्न होते हैं और इसके द्वारा खपत होती है .join()। उत्तरार्द्ध कम मेमोरी का उपयोग करता है और आम तौर पर तेज होता है।
जैसा कि होता है, सूची निर्माणकर्ता किसी जनरेटर अभिव्यक्ति सहित खुशी से किसी भी पुनरावृत्ति का उपभोग करेगा। इसलिए:
[str(n) for n in xrange(10)]
के लिए बस "कृत्रिम चीनी" है:
list(str(n) for n in xrange(10))
दूसरे शब्दों में, एक सूची बोध एक जनरेटर अभिव्यक्ति है जो एक सूची में बदल जाती है।
[str(x) for x in xrange(1000)]262 usec list(str(x) for x in xrange(1000)),: 304 usec।
seq = PySequence_Fast(orig, "");और यह एकमात्र कारण है कि iterators, str.join () कॉल करते समय सूचियों या ट्यूपल्स की तुलना में अधिक धीमी गति से चलते हैं। यदि आप इस पर आगे चर्चा करना चाहते हैं, तो आपका स्वागत है एक चैट शुरू करने के लिए। मुद्दे के साथ परिचित)।
जैसा कि उल्लेख किया गया है कि यह एक जनरेटर अभिव्यक्ति है ।
प्रलेखन से:
केवल एक तर्क के साथ कॉल पर कोष्ठकों को छोड़ा जा सकता है। विस्तार के लिए अनुभाग कॉल देखें ।
यदि यह पैरेन्स में है, लेकिन कोष्ठक नहीं है, तो यह तकनीकी रूप से एक जनरेटर अभिव्यक्ति है। जेनरेटर के भाव पहली बार अजगर 2.4 में पेश किए गए थे।
http://wiki.python.org/moin/Generators
शामिल होने के बाद का हिस्सा ( str(_) for _ in xrange(10) ), अपने आप में, एक जनरेटर अभिव्यक्ति है। आप कुछ ऐसा कर सकते हैं:
mylist = (str(_) for _ in xrange(10))
''.join(mylist)
और इसका मतलब बिल्कुल वही है जो आपने ऊपर के दूसरे मामले में लिखा था।
जनरेटर में कुछ बहुत ही रोचक गुण होते हैं, जिनमें से कम से कम यह नहीं है कि जब आपको एक की आवश्यकता नहीं होती है तो वे पूरी सूची को आवंटित नहीं करते हैं। इसके बजाय, एक फ़ंक्शन जैसे "पंप" एक समय में जनरेटर अभिव्यक्ति से आइटम को बाहर निकालता है, छोटे मध्यवर्ती भागों पर अपना काम करता है।
आपके विशेष उदाहरणों में, सूची और जनरेटर संभवतः बहुत अलग तरीके से प्रदर्शन नहीं करते हैं, लेकिन सामान्य तौर पर, जब भी मैं कर सकता हूं, तो मैं जनरेटर अभिव्यक्तियों (और यहां तक कि जनरेटर फ़ंक्शन) का उपयोग करना पसंद करता हूं, क्योंकि जनरेटर के लिए पूरी सूची की तुलना में धीमा होना बेहद दुर्लभ है भौतिकीकरण।
यह एक सूची बोध के बजाय एक जनरेटर है। जेनरेटर भी पुनरावृत्त होते हैं, लेकिन पूरी सूची बनाने के बजाय पहले इसे शामिल होने के लिए पास करते हैं, यह xrange में प्रत्येक मूल्य को एक-एक करके पास करता है, जो बहुत अधिक कुशल हो सकता है।
आपकी दूसरी joinकॉल का तर्क एक जनरेटर अभिव्यक्ति है। यह एक चलने का उत्पादन करता है।
joinहै कि यह सबसे अधिक संभावना है कि सी में लिखा है और इसलिए एक सूची समझ की तुलना में बहुत तेजी से चलता है ... परीक्षण का समय!