उदाहरण के लिए:

import numpy as np
import datetime

class Test():

    def __init__(self,atti1,atti2):
        self.atti1 = atti1
        self.atti2 = atti2


l1 = [Test(i,i+1) for i in range(1000000)]

मेरा समाधान है:

start_time = datetime.datetime.now()
l11 = np.array([v.atti1 for v in l1])
l12 = np.array([v.atti2 for v in l1])
print(datetime.datetime.now()-start_time)

मेरी मैकबुकप्रो2017 में इसकी कीमत 0:00:00.234735 है।

इसे अजगर में बनाने के लिए एक और अधिक कुशल तरीका है?

---संपादित1

Numpy का उपयोग करना जरूरी नहीं है। यहां एक और समाधान है:

l11 = []
l12 = []

start_time = datetime.datetime.now()
for v in l1:
    l11.append(v.atti1)
    l12.append(v.atti2)
print(datetime.datetime.now()-start_time)

इसकी कीमत 0:00:00.225412 . है

---संपादित2

यहाँ एक बुरा समाधान है:

l11 = np.array([])
l12 = np.array([])
start_time = datetime.datetime.now()

for v in l1:
    l11 = np.append(l11,v.atti1)
    l12 = np.append(l12,v.atti2)
print(datetime.datetime.now()-start_time)
-3
DachuanZhao 27 पद 2018, 15:55

2 जवाब

सबसे बढ़िया उत्तर

यहां numpy का उपयोग करने की कोई आवश्यकता नहीं है, और आम तौर पर सूची समझ काफी अच्छी है। अर्थात। l11 = [v.atti1 for v in lst] बिलकुल ठीक है।

संकल्पनात्मक रूप से, आपको चाहिए सभी ऑब्जेक्ट्स पर पुनरावृति और प्रत्येक एक की एक्सेस विशेषता।

"आपको ओवरइंजीनियर क्यों नहीं करना चाहिए" पर मेट्रिक्स:

# numpy array builder
np.array([v.atti1 for v in lst])
np.array([v.atti2 for v in lst])
215 ms ± 3.69 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

यह धीमा है क्योंकि आप पहले समझ के साथ सूची बनाते हैं, और फिर एनपी सरणी और प्रतिलिपि के लिए स्मृति पुन: आवंटित करते हैं

# single list iteration with appending
l1 = []
l2 = []
for v in lst:
    l1.append(v.atti1)
    l2.append(v.atti2)
174 ms ± 384 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

बेहतर है, लेकिन आपके पास .append के लिए बहुत सारे फ़ंक्शन कॉल हैं और अंततः आप सूची को फिर से आवंटित और कॉपी कर रहे हैं।

# thing that you always start with, no pre-mature optimizations
l1 = [v.atti1 for v in lst]
l2 = [v.atti2 for v in lst]
99.3 ms ± 982 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

यह अधिक पठनीय है, पाइथोनिक, ठीक वही करता है जो यह कहता है, और यह तेज़ है। आंतरिक रूप से, समझ के निम्न-स्तरीय अनुकूलन के कारण यह तेज़ है।

साइड नोट, CPython (जिसका आप शायद सबसे अधिक उपयोग कर रहे हैं) 3.5 से शुरू (iirc) शेयर्ड-की डिक्शनरी ऑब्जेक्ट एट्रिब्यूट्स को स्टोर करने के लिए, और 3.6 से शुरू करके इसे कॉम्पैक्ट डिक्ट कार्यान्वयन के साथ मर्ज कर दिया गया है। दोनों एक साथ बढ़िया काम कर रहे हैं - मेमोरी दक्षता आपको कच्चे प्रदर्शन को बहुत बढ़ावा देती है।

सुनिश्चित नहीं है कि वीएम वास्तव में समझ (शायद नहीं) चलाते समय साझा किए गए निर्देश का लाभ उठाता है, लेकिन इसे 99% मामलों में वीएम अनुकूलन के लिए छोड़ दिया जाना चाहिए। उच्च स्तरीय अमूर्त भाषाएं (जैसे पायथन) वास्तव में सूक्ष्म अनुकूलन के बारे में नहीं हैं।

3
Slam 27 पद 2018, 16:29

आप पायथन में विशेषताओं और उनके मूल्यों के शब्दकोश को वापस करने के लिए self.__dict__ का उपयोग कर सकते हैं।

import numpy as np
import datetime
import pandas as pd
class Test():
    def __init__(self,atti1,atti2):
        self.atti1 = atti1
        self.atti2 = atti2

    def getAttr(self):
        return self.__dict__


l1 = [Test(i,i+1).getAttr() for i in range(1000000)]

l1 = pd.DataFrame(l1)

l11 = list(l1['atti1'])
l12 = list(l1['atti2'])
2
Rishabh Mishra 27 पद 2018, 16:57