दिलचस्प पोस्ट
'रिसीवर (<ViewController>) पहचानकर्ता' addSegue 'के साथ कोई segue नहीं है चहचहाना बूटस्ट्रैप नेविबार शीर्ष ओवरलैपिंग साइट तय की Google चेतावनी: संसाधन को फ़ॉन्ट के रूप में व्याख्या की गई, लेकिन माइम प्रकार के आवेदन / ऑक्टेट-स्ट्रीम के साथ स्थानांतरित किया गया रूबीगाम्स: मैं मंच-विशिष्ट निर्भरता कैसे जोड़ूं? PHP में संरचना कोड को घुंघराले ब्रैकेट का उपयोग करें jQuery के AJAX फ़ाइल अपलोड PHP साथफ़ाइल बनाम ओपनफ़ाइल SQL सर्वर: एक टाइमस्टैम्प कॉलम में एक स्पष्ट मान सम्मिलित नहीं कर सकता एंड्रॉइड ऐप का पैकेज नाम क्या होना चाहिए? Linq को EntityFramework DateTime के लिए HTTPS पेज के माध्यम से HTTP अजाक्स अनुरोध अलग-अलग लंबाई के दूसरे डेटा फ्रेम को संदर्भित करके एक डेटा फ्रेम में एनएएस को बदलने के लिए ifelse () का उपयोग करना Python में एक नियमित अभिव्यक्ति के साथ आप एक यूआरएल को कैसे मान्य करते हैं? जेमीटर फ़ील्ड निकालने / JSON प्रतिक्रिया पार्सिंग एक विधि पैरामीटर का नाम प्राप्त करना

पायथन: एन सूचियों की सूची बनाने का सबसे तेज़ तरीका

तो मैं सोच रहा था कि रिक्त सूचियों की सबसे अच्छी सूची कैसे बनाएं:

[[],[],[]...] 

स्मृति में सूचियों के साथ पायथन कैसे काम करता है, यह काम नहीं करता है:

 [[]]*n 

यह [[],[],...] लेकिन प्रत्येक तत्व एक ही सूची है:

 d = [[]]*n d[0].append(1) #[[1],[1],...] 

एक सूची समझ की तरह कुछ काम करता है:

 d = [[] for x in xrange(0,n)] 

लेकिन यह पाइथन वीएम का उपयोग लूपिंग के लिए करता है। क्या कोई निहित पाश का उपयोग करने का कोई तरीका है (इसका लाभ लेने के लिए सी में लिखा है)?

 d = [] map(lambda n: d.append([]),xrange(0,10)) 

यह वास्तव में धीमी है 🙁

Solutions Collecting From Web of "पायथन: एन सूचियों की सूची बनाने का सबसे तेज़ तरीका"

शायद एक ही रास्ता है जो मामूली तेजी से अधिक है

 d = [[] for x in xrange(n)] 

है

 from itertools import repeat d = [[] for i in repeat(None, n)] 

यह प्रत्येक पुनरावृत्ति में एक नया int ऑब्जेक्ट बनाने की ज़रूरत नहीं है और मेरी मशीन पर लगभग 5% अधिक तेज है।

संपादित करें : NumPy का उपयोग करके, आप पायथन लूप से बच सकते हैं

 d = numpy.empty((n, 0)).tolist() 

लेकिन यह वास्तव में 2.5 गुणा सूची समझ से धीमी है।

सूची की अभिव्यक्ति वास्तव में स्पष्ट पाश से अधिक कुशलतापूर्वक कार्यान्वित की जाती है ( उदाहरण के कार्यों के लिए डिस्क आउटपुट देखें) और map मार्ग को प्रत्येक चलना पर एक ऑप्कक कॉल करने योग्य ऑब्जेक्ट का उपयोग करना पड़ता है, जिसमें काफी ऊपरी ओवरहेड होता है

चाहे, [[] for _dummy in xrange(n)] लिए यह करने का सही तरीका है और छोटे से कोई भी (यदि सभी में विद्यमान है [[] for _dummy in xrange(n)] भिन्न अन्य तरीकों के बीच अंतर होना चाहिए । जब तक आप अपना समय अपनाए न तो ज़्यादातर खर्च करते हैं – लेकिन उस स्थिति में, आपको अपने एल्गोरिदम पर काम करना चाहिए। आप इन सूचियों को कितनी बार बनाते हैं?

यहां दो तरीके हैं, एक मीठा और सरल (और वैचारिक), अन्य औपचारिक और एक डाटासेट पढ़ने के बाद विभिन्न स्थितियों में विस्तारित किया जा सकता है।

विधि 1: संकल्पनात्मक

 X2=[] X1=[1,2,3] X2.append(X1) X3=[4,5,6] X2.append(X3) X2 thus has [[1,2,3],[4,5,6]] ie a list of lists. 

विधि 2: औपचारिक और एक्स्टेंसिबल

सूची को अलग-अलग नंबरों की सूची के रूप में सूची में संग्रहित करने का एक और शानदार तरीका – जो कि वह फ़ाइल से पढ़ता है (फ़ाइल में डेटासेट ट्रेन है) ट्रेन एक डेटा सेट है जिसमें 50 पंक्तियां और 20 कॉलम हैं। अर्थात। ट्रेन [0] मुझे एक सीएसवी फ़ाइल की पहली पंक्ति देता है, ट्रेन [1] मुझे दूसरी पंक्ति देता है और इतने पर। मैं डाटासेट को एक सूची के रूप में एक सूची के रूप में अलग करने में दिलचस्पी है, कॉलम 0 को छोड़कर, जो कि मेरी यहाँ व्याख्या की गई है, इसलिए इसे ऑरगनल ट्रेन डाटासेट से हटा दिया जाना चाहिए और फिर सूची के बाद सूची को स्केलिंग करना होगा- यानी सूची की एक सूची । यह वह कोड है जो ऐसा करता है।

ध्यान दें कि मैं भीतर की लूप में "1" से पढ़ रहा हूं, क्योंकि मैं केवल व्याख्यात्मक चर में दिलचस्पी ले रहा हूं। और मैं दूसरे लूप में एक्स 1 = [] फिर से शुरू करता हूं, और एक्स 2। ऐपेंड ([0: (लेन [ट्रेन] [0]) – 1)]) फिर से एक्स 1 को फिर से लिखना होगा – इससे अधिक कुशलतापूर्वक स्मृति

 X2=[] for j in range(0,len(train)): X1=[] for k in range(1,len(train[0])): txt2=train[j][k] X1.append(txt2) X2.append(X1[0:(len(train[0])-1)]) 

इसलिए मैंने सबसे तेज़ तरीका प्राप्त करने के लिए कुछ गति की तुलना की। सूची की समझ वास्तव में बहुत तेज है करीब पहुंचने का एकमात्र तरीका है कि सूची के निर्माण के दौरान बाइटकोड को एक्सक्चुड किया जाए। मेरा पहला प्रयास निम्न विधि था, जो सिद्धांत रूप में तेजी से प्रकट होगा:

 l = [[]] for _ in range(n): l.extend(map(list,l)) 

(निश्चित रूप से लम्बाई 2 ** एन की सूची तैयार होती है) समय-समय पर, यह संक्षिप्त और लम्बी (एक लाख) सूचियों दोनों के लिए, यह सूची दो बार के रूप में धीमे है।

मेरा दूसरा प्रयास मेरे लिए सूची निर्माता को कॉल करने के लिए स्टार्मेप का इस्तेमाल करना था, एक निर्माण होता है, जो सूची निर्माता को शीर्ष गति पर चलाने में प्रतीत होता है, लेकिन अभी भी धीमी है, लेकिन केवल एक छोटी राशि के द्वारा:

 from itertools import starmap l = list(starmap(list,[()]*(1<<n))) 

पर्याप्त निष्पादन समय बताता है कि यह अंतिम सूची कॉल है जो starmap समाधान को धीमा बनाता है, क्योंकि इसके निष्पादन का समय लगभग लगभग की गति के बराबर है:

 l = list([] for _ in range(1<<n)) 

मेरा तीसरा प्रयास तब आया जब मुझे पता चला कि सूची (()) भी एक सूची उत्पन्न करती है, इसलिए मैंने स्पष्ट रूप से सरलता की कोशिश की:

 l = list(map(list, [()]*(1<<n))) 

लेकिन यह सुस्त कॉल से धीमी थी।

निष्कर्ष: गति पागलों के लिए: सूची समझ का उपयोग करें। केवल कॉल फ़ंक्शन, यदि आपको करना है बिल्डिन का उपयोग करें

सूचियों की सूची और सूची बनाने के लिए वाक्यविन्यास के नीचे का उपयोग करें

  x = [[] for i in range(10)] 

यह 1-डी सूची बनायेगा और इसे आरंभ करने के लिए [[संख्या] में नंबर डाल सकता है और लंबाई की लंबाई निर्धारित करें (लंबाई)

  • सूचियों की सूची बनाने के लिए वाक्यविन्यास के नीचे का उपयोग करें

    x = [[[0] श्रेणी के लिए मैं (3) में श्रेणी के लिए (10)]

यह 10 * 3 आयाम के साथ सूचियों की सूची और मूल्य 0 के साथ आरंभ करेगा

  • तत्व का उपयोग / हेरफेर करने के लिए

    एक्स [1] [5] = मूल्य