पायथन

Question

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

बहुत पहले मेरे कोड पर इस तरह है:

#build the dictionary 
blablabla 
#look up some information in the ditionary 
blablabla 

मैं कई बार ऊपर से देखने की जरूरत के रूप में, मुझे लगता है कि यह एक समारोह के रूप में इसे लागू करने के एक अच्छा विचार है शुरू करते हैं, कहते हैं कि देखने (जानकारी)।

फिर यहां समस्या आती है, मुझे बड़े शब्दकोश से कैसे निपटना चाहिए?

मैं देखने (जानकारी, शब्दकोश) का उपयोग करना चाहिए एक तर्क के रूप में यह पारित करने के लिए, या मैं बस में मुख्य() शब्दकोश प्रारंभ करना चाहिए और सिर्फ एक वैश्विक चर के रूप में इसका इस्तेमाल करते हैं?

पहला व्यक्ति अधिक सुरुचिपूर्ण लगता है क्योंकि मुझे लगता है कि वैश्विक चर बनाए रखना परेशानी है। लेकिन दूसरी तरफ, मैं एक समारोह में एक बड़ा शब्दकोश गुजरने की दक्षता के बारे में निश्चित नहीं हूं। इसे कई बार बुलाया जाएगा और यदि तर्क गुजरना अक्षम है तो यह निश्चित रूप से एक दुःस्वप्न होगा।

धन्यवाद।

Edit1:

यहाँ कोड का टुकड़ा है:

मैं सिर्फ ऊपर दो तरीकों में से एक प्रयोग किया जाता। लुकअप 1 लुकअप 2 देखकर तर्क को लागू करता है जबकि लुकअप 2 वैश्विक डेटा संरचना "big_dict" का उपयोग करता है।

lookup1 है 8,410885
lookup2 है 8,157661
वर्ग 4,525721

है तो ऐसा लगता है कि दो तरीके:

class CityDict(): 
    def __init__(): 
     self.code_dict = get_code_dict() 
    def get_city(city): 
     try: 
      return self.code_dict[city] 
     except Exception: 
      return None   

def get_code_dict(): 
    # initiate code dictionary from file 
    return code_dict 

def lookup1(city, city_code_dict): 
    try: 
     return city_code_dict[city] 
    except Exception: 
     return None 

def lookup2(city): 
    try: 
     return big_dict[city] 
    except Exception: 
     return None 


t = time.time() 
d = get_code_dict() 
for i in range(0, 1000000): 
    lookup1(random.randint(0, 10000), d) 

print "lookup1 is %f" % (time.time() - t) 


t = time.time() 
big_dict = get_code_dict() 
for i in range(0, 1000000): 
    lookup2(random.randint(0, 1000)) 
print "lookup2 is %f" % (time.time() - t) 


t = time.time() 
cd = CityDict() 
for i in range(0, 1000000): 
    cd.get_city(str(i)) 
print "class is %f" % (time.time() - t) 

यह आउटपुट है लगभग वें हैं वही, और हां, वैश्विक परिवर्तनीय विधि थोड़ा और अधिक कुशल है।

EDIT2:

जोड़ा वर्ग संस्करण एम्बर ने सुझाव दिया, और फिर दक्षता फिर से परीक्षण करें। फिर हम उन परिणामों से देख सकते थे कि एम्बर सही है, हमें कक्षा संस्करण का उपयोग करना चाहिए।

Answer 1

न तो। डेटा (सदस्य) के साथ एक वर्ग है, जो विशेष रूप से समूहीकरण कार्य (विधि) के लिए डिज़ाइन किया गया है का उपयोग करें:

class BigDictLookup(object): 
    def __init__(self): 
     self.bigdict = build_big_dict() # or some other means of generating it 
    def lookup(self): 
     # do something with self.bigdict 

def main(): 
    my_bigdict = BigDictLookup() 
    # ... 
    my_bigdict.lookup() 
    # ... 
    my_bigdict.lookup() 

Answer 2

कोर प्रश्न का उत्तर देना, पैरामीटर गुजर अक्षम नहीं है, यह की तरह नहीं है अपने मूल्यों के आसपास की नकल की हो जाएगी। पायथन ने संदर्भों को पारित किया, जो यह नहीं कहना है कि पैरामीटर पारित करने के तरीके "पास-बाय-वैल्यू" या "पास-बाय-रेफरेंस" की जाने-माने योजनाओं को फिट करते हैं।

कॉलर द्वारा प्रदत्त संदर्भ मूल्य के साथ एक परिवर्तनीय स्थानीय के मूल्य को प्रारंभ करने के रूप में यह सबसे अच्छी कल्पना की जाती है, जो मूल्य से गुजरती हैं।

फिर भी, कक्षा का उपयोग करने का सुझाव शायद एक अच्छा विचार है।