Python Language
प्रदर्शन अनुकूलन

टिप्पणियों

कोड प्रोफाइलिंग

सबसे पहले और सबसे महत्वपूर्ण बात यह है कि आपको अपनी स्क्रिप्ट की अड़चन का पता लगाने में सक्षम होना चाहिए और ध्यान दें कि कोई भी अनुकूलन डेटा संरचना में खराब विकल्प या आपके एल्गोरिथ्म डिजाइन में दोष की भरपाई नहीं कर सकता है। दूसरी बात यह है कि पठनीयता / डिज़ाइन / गुणवत्ता की कीमत पर अपनी कोडिंग प्रक्रिया में बहुत जल्दी अनुकूलन करने का प्रयास न करें। डोनाल्ड नूथ ने अनुकूलन पर निम्नलिखित बयान दिया:

"हमें छोटी क्षमताओं के बारे में भूलना चाहिए, समय के 97% के बारे में कहना चाहिए: समय से पहले अनुकूलन सभी बुराई की जड़ है। फिर भी हमें उस महत्वपूर्ण 3% में अपने अवसरों को पारित नहीं करना चाहिए"

: अपने कोड प्रोफ़ाइल करने के लिए आप कई उपकरण है cProfile (या धीमी profile ) मानक पुस्तकालय, से line_profiler और timeit । उनमें से प्रत्येक एक अलग उद्देश्य पूरा करते हैं।

cProfile एक नियतांक प्रोफाइलर है: फंक्शन कॉल, फंक्शन रिटर्न और अपवाद इवेंट्स की निगरानी की जाती है, और इन इवेंट्स (0.001 तक) के बीच के अंतराल के लिए सटीक टाइमिंग बनाई जाती है। पुस्तकालय प्रलेखन ([ https://docs.python.org/2/library/profile.htmldesing11]) हमें एक सरल नियंत्रण केस प्रदान करता है

import cProfile
def f(x):
    return "42!"
cProfile.run('f(12)')

या यदि आप अपने मौजूदा कोड के कुछ हिस्सों को लपेटना पसंद करते हैं:

import cProfile, pstats, StringIO
pr = cProfile.Profile()
pr.enable()
# ... do something ...
# ... long ...
pr.disable()
sortby = 'cumulative'
ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
ps.print_stats()
print s.getvalue()

यह नीचे दी गई तालिका की तरह दिखने वाले आउटपुट पैदा करेगा, जहां आप जल्दी से देख सकते हैं कि आपका प्रोग्राम अपना अधिकांश समय कहां बिताता है और अनुकूलन के लिए कार्यों की पहचान करता है।

         3 function calls in 0.000 seconds

Ordered by: standard name
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     1    0.000    0.000    0.000    0.000 <stdin>:1(f)
     1    0.000    0.000    0.000    0.000 <string>:1(<module>)
     1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

मॉड्यूल line_profiler ([ https://github.com/rkern/line_profileracing [1 ]] आपके कोड के लाइन विश्लेषण द्वारा एक पंक्ति के लिए उपयोगी है। यह स्पष्ट रूप से लंबी लिपियों के लिए प्रबंधनीय नहीं है, लेकिन स्निपेट के उद्देश्य से है। अधिक विवरण के लिए प्रलेखन देखें। आरंभ करने का सबसे आसान तरीका है किर्नफ़्री लिपि का उपयोग करना जैसा कि एक पैकेज पृष्ठ को समझाया गया है, ध्यान दें कि आपको प्रोफ़ाइल में मैन्युअल रूप से फ़ंक्शन (एस) निर्दिष्ट करने की आवश्यकता होगी।

$ kernprof -l script_to_profile.py

kernprof, लाइनप्रोफ़ाइलर का एक उदाहरण बनाएगा और नाम प्रोफ़ाइल के साथ __builtins__ नामस्थान में सम्मिलित करेगा। इसे डेकोरेटर के रूप में उपयोग करने के लिए लिखा गया है, इसलिए अपनी स्क्रिप्ट में, आप उन फ़ंक्शंस को सजाते हैं जिन्हें आप @profile साथ प्रोफाइल करना चाहते हैं।

@profile
def slow_function(a, b, c):
    ...

Kernprof का डिफ़ॉल्ट व्यवहार परिणामों को एक बाइनरी फ़ाइल script_to_profile.py.lprof । आप [-v / - view] विकल्प के साथ टर्मिनल पर स्वरूपित परिणामों को तुरंत देखने के लिए kernitable बता सकते हैं। अन्यथा, आप बाद में परिणाम इस तरह देख सकते हैं:

$ python -m line_profiler script_to_profile.py.lprof

अंत में timeit कमांड लाइन और पायथन शेल से एक लाइनर या छोटी अभिव्यक्ति का परीक्षण करने का एक सरल तरीका प्रदान करता है। यह मॉड्यूल इस तरह के प्रश्न का उत्तर देगा, क्या किसी सूची में एक सेट को परिवर्तित करते समय किसी सूची को समझने या अंतर्निहित list() उपयोग करना तेजी से होता है। सेटअप कोड जोड़ने के लिए setup कीवर्ड या -s विकल्प देखें।

>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
0.8187260627746582

एक टर्मिनल से

$ python -m timeit '"-".join(str(n) for n in range(100))'
10000 loops, best of 3: 40.3 usec per loop