पायथन लूप अनुकूलन

Question

मैं वर्तमान में 2 मिलियन से अधिक लाइनों वाली फ़ाइल के साथ काम कर रहा हूं। मैंने लाइनों को तत्वों की सूचियों में विभाजित कर दिया है (उदा: [a,b,c,d] = 1 पंक्ति, शब्द अलग)। मैं 2 मिलियन + लाइनों का जिक्र कर रहा हूँ

for a in aud: 
    for esps in final: 
     if a[0] in final[esps]: 
      a[0] = esps 

पाश के लिए पहले में:

मैं सभी लाइनों के माध्यम से जाने के लिए निम्न कोड का उपयोग करने की कोशिश कर रहा हूँ। लूप के लिए दूसरे में यह 2010 कुंजी के साथ एक शब्दकोश के माध्यम से जाता है, संभवतः कम से कम 50 संबंधित मानों के साथ प्रत्येक कुंजी। मैं a[0] तत्व को उन पंक्तियों में ढूंढना चाहता हूं जो शब्दकोश में मानों के बराबर हैं। यदि वे मेल खाते हैं, तो मैं चयनित लाइन में a[0] तत्व को शब्दकोश की कुंजी के मान में बदलता हूं।

समस्या यह है कि इस कोड को चलाने के लिए उम्र लगती है और मुझे ऑप्टिमाइज़ेशन और इसे बहुत तेज़ चलाने के बारे में ज्यादा कुछ नहीं समझता है। यदि कोई मुझे बता सकता है कि इस तरह कुछ कैसे करना है तो मैं बहुत धन्यवाद करता हूं।

Answer 1

जब आपके पास "बड़ी" चीजें चलाने के लिए होती है, इस तरह, चीजों को तेजी से चलने की कुंजी "एल्गोरिदमिक जटिलता को कम करना" है - यानी, यदि संभव हो तो डेटा सेट के आकार पर निर्भर किसी भी ऑपरेशन से बचें ।

उदाहरण में आपने दिया है, आप अपनी लाखों लाइनों में से प्रत्येक के लिए 50 x 2000 रैखिक खोज - यह बहुत कुछ है! समस्या यह है कि यदि आपकी प्रत्येक final[esps] एक सूची है, तो पाइथन इन 50 मानों में एक रैखिक खोज करता है - ऑपरेटर in के साथ।

चूंकि आप उल्लेख करते हैं कि आप फ़ाइल से अपने मूल्य पढ़ रहे हैं, मुझे यह मानना ​​है कि final की पंक्तियों में तत्व दोनों हैं - लेकिन यह संख्याओं के लिए भी काम करेगा। एक set साथ in ऑपरेटर परिवर्तन से मैच रैखिक जा रहा है (ओ (एम से लगातार समय में होना करने के लिए से के लिए) -

एक पहले, बहुत ही सरल अनुकूलन, बस सूचियों से भी अपने final पंक्तियों शब्दकोश set रों में बदलने के लिए है हे (1)) - हां, तो आप मूल रूप से अपनी खोज को समय 50 का एक पहलू से कटौती करता है, तो अपने उदाहरण में कोड को चलाने से पहले आप करते हैं:

for key in final: 
    final[key] = set(final[key]) 

लेकिन आप अभी भी 2010 के प्रत्येक में एक रेखीय खोज प्रदर्शन कर रहे हैं final की चाबियाँ। निरंतर खोज में बदलने का तरीका एक उल्टा शब्दकोश बनाना है - जिसमें final की पंक्ति में 50 मानों में से प्रत्येक कुंजी esp पर इंगित करता है। फिर आप इस उल्टा शब्दकोश में कुंजी के रूप में एक [0] का उपयोग करें - और आप एक शब्दकोश में निरंतर समय में खोज के लिए 100000 आइटम (2000 x 50) में एक रैखिक खोज बदल रहे हैं;

कि पूरा करने के लिए आसान है - बस के लिए अपने कोड बदलने के लिए:

rfinal = {} 
for esp, values in final.items(): 
    for value in values: 
     rfinal[value] = esp 


for a in aud: 
    if a[0] in rfinal: 
     a[0] = rfinal[a[0]] 
    else: 
     # code for when there is no match for a[0] 
     ...