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

Question 1

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

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

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

[[]]*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))

यह वास्तव में धीमी है। :(

Question 2

शायद एकमात्र तरीका जो की तुलना में थोड़ा तेज है

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

है

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

इसे intहर पुनरावृत्ति में एक नई वस्तु बनाने की ज़रूरत नहीं है और यह मेरी मशीन पर लगभग 15% तेज है।

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

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

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

Question 3

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

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

Question 4

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

विधि 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 को छोड़कर एक सूची के रूप में 50 पंक्तियों के साथ डेटासेट को अलग करने में रुचि रखता हूं, जो कि मेरा समझाया गया चर है, इसलिए इसे ऑर्निगल ट्रेन डेटासेट से हटाया जाना चाहिए, और फिर सूची के बाद सूची को स्केल करना होगा - अर्थात सूची की सूची । यहाँ वह कोड है जो ऐसा करता है।

ध्यान दें कि मैं "1" से आंतरिक लूप में पढ़ रहा हूं क्योंकि मैं केवल व्याख्यात्मक चर में रुचि रखता हूं। और मैं दूसरे लूप में X1 = [] को फिर से इनिशियलाइज़ करता हूं, दूसरे X2.append ([0: (len (train [0]) - 1)]) X1 को फिर से और फिर से लिखेंगे - इसके अलावा यह अधिक मेमोरी कुशल है।

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)])

Question 5

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

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

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

सिंटैक्स के नीचे उपयोग की सूची बनाने के लिए।

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

यह 10 * 3 आयाम और मान 0 के साथ सूचियों की सूची को इनिशियलाइज़ करेगा

तत्व तक पहुंचने / हेरफेर करने के लिए

    x[1][5]=value

Question 6

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

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

(लंबाई 2 ** एन की एक सूची का उत्पादन करता है, निश्चित रूप से) यह निर्माण सूची की समझ से दोगुना है, समय के अनुसार, दोनों छोटी और लंबी (एक मिलियन) सूची के लिए।

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

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

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

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

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

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

लेकिन यह स्टार्मैप कॉल की तुलना में धीमा था।

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