🥋 ◻️ ⚜️ पायथन प्रोफाइलिंग और डिबगिंग, चलो अभ्यास के लिए आगे बढ़ते हैं 👍 👩🏽‍🎤 🤱🏼

पिछले लेख में, हमने प्रोफाइलिंग और ऑप्टिमाइज़ेशन की अवधारणाओं को परिभाषित किया, प्रोफाइलिंग और टूल के विभिन्न तरीकों से परिचित हुए। प्रोफाइलर्स के इतिहास को थोड़ा सा छुआ।

आज मैं मैनुअल प्रोफाइलिंग विधियों (और यहां तक कि "टकटकी विधि") के उदाहरणों का अभ्यास करने और दिखाने के लिए आगे बढ़ने का प्रस्ताव करता हूं। सांख्यिकीय प्रोफाइलिंग के लिए उपकरणों की भी जांच की जाएगी।

परिचय और सिद्धांत - आपको प्रोफाइलिंग, विभिन्न दृष्टिकोण, उपकरण और उनके बीच अंतर की आवश्यकता क्यों है?
मैनुअल और सांख्यिकीय रूपरेखा - चलें अभ्यास के लिए
इवेंट प्रोफाइलिंग - उपकरण और उनके आवेदन
डिबगिंग - क्या करना है जब कुछ भी नहीं काम करता है

गाड़ी

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

सामान्य तौर पर, मैं यूलर प्रोजेक्ट से पहेलियों को सुलझाने की अत्यधिक सलाह देता हूं। विचलित, ध्यान और आराम करने में मदद करता है, और साथ ही साथ आपके मस्तिष्क को अच्छे आकार में रखता है।

लेख के लिए एक उदाहरण के रूप में, कार्य 3 को लें :

13195 के प्रमुख विभाजक 5, 7, 13 और 29 हैं।
600851475143 का सबसे बड़ा विभाजक क्या है?

हम एक सरल समाधान "माथे" लिखते हैं:

"""Project Euler problem 3 solve""" from __future__ import print_function import sys def is_prime(num): """Checks if num is prime number""" for i in range(2, num): if not num % i: return False return True def find_prime_factors(num): """Find prime factors of num""" result = [] for i in range(2, num): if is_prime(i) and not num % i: result.append(i) return result if __name__ == '__main__': try: num = int(sys.argv[1]) except (TypeError, ValueError, IndexError): sys.exit("Usage: euler_3.py number") if num < 1: sys.exit("Error: number must be greater than zero") prime_factors = find_prime_factors(num) if len(prime_factors) == 0: print("Can't find prime factors of %d" % num) else: print("Answer: %d" % prime_factors[-1])

एक चौकस या अनुभवी पाठक मुझे तुरंत एक नॉब कह सकते हैं, इस कार्यक्रम की कुछ समस्याओं को नाम दे सकते हैं और इसके अनुकूलन के लिए कुछ व्यंजनों को दे सकते हैं, लेकिन हमने विशेष रूप से एक सरल उदाहरण लिया और दिखावा किया कि हम इस कोड को अच्छा मानते हैं, जिस तरह से इसके साथ अनुकूलन करते हैं।

जाँच करने के लिए, उस प्रोग्राम को एक नंबर से चलाएं जिसके विभाजक हमें ज्ञात हों:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
19 अजगर euler_3.py 13195
उत्तर: 29

कार्यक्रम द्वारा जारी किया गया उत्तर 29 सही है (यह समस्या कथन में पाया जा सकता है)। हुर्रे! अब हमारे लिए ब्याज की संख्या 600851475143 के साथ कार्यक्रम चलाएं:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
85 अजगर euler_3.py 600851475143

और ... कुछ नहीं होता। CPU उपयोग 100% है, कई घंटों के ऑपरेशन के बाद भी कार्यक्रम पूरा नहीं हुआ है। हम समझने लगते हैं। हम याद करते हैं कि आप केवल उस कोड को ऑप्टिमाइज़ कर सकते हैं जो सही तरीके से काम करता है, लेकिन हमने प्रोग्राम को कम संख्या में चेक किया और उत्तर सही था। जाहिर है, समस्या प्रदर्शन में है और हमें अनुकूलन शुरू करने की आवश्यकता है।

टकटकी विधि

वास्तविक जीवन में, मैं 13195 तर्क के साथ कार्यक्रम की रूपरेखा तैयार करूंगा (जब इसका परिचालन समय पर्याप्त हो)। लेकिन जब से हम यहां और सामान्य रूप से प्रशिक्षण ले रहे हैं, सिर्फ जून के लिए, हम "टकटकी विधि" का उपयोग करेंगे।

हम कोड खोलते हैं और ध्यान से देखते हैं। हम समझते हैं (यदि हम भाग्यशाली हैं, तो हम जल्दी से समझते हैं) कि संख्या N के विभाजकों की खोज करने के लिए , यह अंतराल sqrt (N) + 1 ... N-1 से संख्याओं को हल करने का कोई मतलब नहीं है, क्योंकि हम पहले ही इस सीमा से सभी विभाजक पाए गए जब अंतराल 2 से संख्याओं पर पुनरावृत्ति ... sqrt (N) । हम कोड को थोड़ा संशोधित करते हैं (9 और 18 लाइनें देखें):

 """Project Euler problem 3 solve""" from __future__ import print_function import math import sys def is_prime(num): """Checks if num is prime number""" for i in range(2, int(math.sqrt(num)) + 1): if not num % i: return False return True def find_prime_factors(num): """Find prime factors of num""" result = [] for i in range(1, int(math.sqrt(num)) + 1): if is_prime(i) and not num % i: result.append(i) if is_prime(num): result.append(i) return result if __name__ == '__main__': try: num = int(sys.argv[1]) except (TypeError, ValueError, IndexError): sys.exit("Usage: euler_3.py number") if num < 1: sys.exit("Error: number must be greater than zero") prime_factors = find_prime_factors(num) if len(prime_factors) == 0: print("Can't find prime factors of %d" % num) else: print("Answer: %d" % prime_factors[-1])

जाँच करने के लिए, प्रोग्राम को फिर से एक नंबर के साथ चलाएं, जिसके विभाजक हमें ज्ञात हैं:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
19 अजगर euler_3.py 13195
उत्तर: 29

विशेष रूप से, कार्यक्रम ने बहुत तेजी से काम किया, जिसका मतलब है कि हम इसे फिर से शुरू कर रहे हैं:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
85 अजगर euler_3.py 600851475143
उत्तर- 6857

हम साइट पर उत्तर की जांच करते हैं, यह सही निकला, समस्या हल हो गई है, हम नैतिक संतुष्टि महसूस करते हैं।

कार्यक्रम एक स्वीकार्य समय (एक मिनट से भी कम समय) में पूरा हो गया था, उत्तर सही था, इस मामले में आगे अनुकूलन में कोई मतलब नहीं है, क्योंकि हमने कार्य को हल कर लिया है। जैसा कि हम याद करते हैं, अनुकूलन में सबसे महत्वपूर्ण बात समय में रोकना सक्षम होना है।

हां, मुझे पता है कि प्रोजेक्ट यूलर के लोग आपसे सार्वजनिक डोमेन में उत्तर और समाधान साझा नहीं करने के लिए कह रहे हैं। लेकिन टास्क 3 के जवाब को एक बार में "प्रोजेक्ट यूलर प्रॉब्लम 3 का जवाब" कहा जाता है। उदाहरण के लिए, मुझे लगता है कि यह ठीक है कि मैंने जवाब लिखा है।

मैनुअल प्रोफाइलिंग

सबसे आम तरीकों में से एक यह पता लगाने के लिए कि क्या है। सबसे प्राथमिक मामले में, यदि हम यूनिक्स उपयोगिता "समय" का उपयोग करते हैं तो यह इस तरह दिखता है (अनुकूलन से पहले):

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
➜ समय अजगर euler_3.py 13195
उत्तर: 29
python euler_3.py 13195 3.83s उपयोगकर्ता 0.03s सिस्टम 99% cpu 3.877 कुल

और इसलिए (अनुकूलन के बाद):

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
➜ समय अजगर euler_3.py 13195
उत्तर: 29
अजगर euler_3.py 13195 0.03s उपयोगकर्ता 0.02s सिस्टम 90% सीपीयू 0.061 कुल

लगभग 65 गुना (~ 3.87 सेकंड से ~ 61 मिलीसेकंड) तक त्वरण!

मैनुअल रूपरेखा भी इस तरह दिख सकती है:

 import time ... start = time.time() prime_factors = find_prime_factors(num) print("Time: %.03f s" % (time.time() - start))

परिणाम:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
85 अजगर euler_3.py 600851475143
उत्तर- 6857
समय: 19.811 एस

या विशेष " टाइमिट " मॉड्यूल का उपयोग करना, जिसे छोटे कार्यक्रमों के प्रदर्शन को मापने के लिए डिज़ाइन किया गया है। आवेदन उदाहरण:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
10 पायथन एम-एम टाइमिट-एन 10 -s'import euler_3 '' euler_3.find_prime_factors (600851475143) '
10 लूप, सर्वश्रेष्ठ 3: 21.3 प्रति लूप सेकेंड

मैनुअल प्रोफाइलिंग कब लागू की जा सकती है? सबसे पहले, यह डेवलपर्स के बीच विभिन्न प्रकार की प्रतियोगिताओं का संचालन करने का एक शानदार तरीका है ("मेरा कोड अब आपकी तुलना में तेज है, इसलिए मैं एक बेहतर प्रोग्रामर हूं!"), और यह अच्छा है। दूसरे, जब कार्यक्रम की गति (20 सेकंड!) निर्धारित करने के लिए "आंख से" आवश्यक हो तो (सुधार 100 बार कोड प्राप्त करने के लिए!)।

लेकिन सबसे महत्वपूर्ण अनुप्रयोग उत्पादन पर सीधे वास्तविक समय में कोड के रनटाइम पर आंकड़ों का संग्रह है। ऐसा करने के लिए, हम मेट्रिक्स और ड्राइंग ग्राफ़ इकट्ठा करने के लिए किसी भी प्रणाली के लिए मापा समय भेजते हैं (मैं वास्तव में ग्रेफाइट और स्टैट्सड को ग्रेफाइट के लिए एक एग्रीगेटर के रूप में उपयोग करना पसंद करता हूं)।

ऐसा करने के लिए, आप एक साधारण संदर्भ प्रबंधक का उपयोग कर सकते हैं:

 """Collect profiling statistic into graphite""" import socket import time CARBON_SERVER = '127.0.0.1' CARBON_PORT = 2003 class Stats(object): """Context manager for send stats to graphite""" def __init__(self, name): self.name = name def __enter__(self): self.start = time.time() return self def __exit__(self, *args): duration = (time.time() - self.start) * 1000 # msec message = '%s %d %d\n' % (self.name, duration, time.time()) sock = socket.socket() sock.connect((CARBON_SERVER, CARBON_PORT)) sock.sendall(message) sock.close()

इसके उपयोग का एक उदाहरण:

 from python_profiling.context_managers import Stats ... with Stats('project.application.some_action'): do_some_action()

या एक साधारण डेकोरेटर:

 """Collect profiling statistic into graphite""" import socket import time CARBON_SERVER = '127.0.0.1' CARBON_PORT = 2003 def stats(name): """Decorator for send stats to graphite""" def _timing(func): def _wrapper(*args, **kwargs): start = time.time() result = func(*args, **kwargs) duration = (time.time() - start) * 1000 # msec message = '%s %d %d\n' % (name, duration, time.time()) sock = socket.socket() sock.connect((CARBON_SERVER, CARBON_PORT)) sock.sendall(message) sock.close() return result return _wrapper return _timing

डेकोरेटर का उपयोग करने का एक उदाहरण:

 from python_profiling.decorators import stats ... @stats('project.application.some_action') def do_some_action(): """Doing some useful action"""

आउटपुट पर, हमें कोड सेक्शन का रनटाइम ग्राफ मिलता है जो हमें रुचता है, उदाहरण के लिए, इस तरह:

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

विधि में इसकी कमियां हैं, और उनमें से सबसे महत्वपूर्ण इनपुट डेटा पर निर्भरता की कमी है। इसलिए, प्राइम नंबर "is_prime" निर्धारित करने के लिए फ़ंक्शन के लिए, निष्पादन समय दृढ़ता से इस संख्या के मूल्य पर निर्भर करेगा, और यदि यह फ़ंक्शन प्रोजेक्ट में बहुत बार कहा जाता है, तो शेड्यूल पूरी तरह से अर्थहीन होगा। यह स्पष्ट रूप से समझना महत्वपूर्ण है कि किस दृष्टिकोण का उपयोग किया जा सकता है और हमारे पास क्या है।

बेशक, आप ग्रेफाइट "सांख्यिकीय" में मैट्रिक्स के संग्रह के माध्यम से प्रोफाइलिंग विधि कह सकते हैं, क्योंकि हम कार्यक्रम के आंकड़े एकत्र करते हैं। लेकिन मैं पहले भाग में हमारे द्वारा अपनाई गई शब्दावली का पालन करने का प्रस्ताव रखता हूं, और "सांख्यिकीय" रूपरेखा का अर्थ है निश्चित अंतराल पर सूचना (नमूनाकरण) का संग्रह।

Django आँकड़े

इसके लिए ग्रेफाइट और एक एग्रीगेटिंग सर्वर ( StatsD ) का उपयोग करने के मामले में, एक मीट्रिक के लिए हमें एक साथ कई ग्राफ़ मिलते हैं: न्यूनतम और अधिकतम कोड निष्पादन का समय, साथ ही माध्यिका और रिकॉर्ड किए गए रीडिंग की संख्या (फ़ंक्शन कॉल) प्रति यूनिट समय, जो बहुत सुविधाजनक है। आइए देखें कि स्टैट्सड को जिंजो से जोड़ना कितना आसान है।

हम मॉड्यूल डालते हैं:

Z पिप स्थापित करें django-आँकड़े-मोज़िला

सेटिंग में सेटिंग्स को जोड़ें:

 INSTALLED_APPS += ('django_statsd',) MIDDLEWARE_CLASSES += ( 'django_statsd.middleware.GraphiteRequestTimingMiddleware', 'django_statsd.middleware.GraphiteMiddleware', ) # send DB timings STATSD_PATCHES = ['django_statsd.patches.db']

और यह बात है! आउटपुट पर, हमें निम्नलिखित ग्राफ़ मिलते हैं:

पेशेवरों और StatsD के विपक्ष:
+ आसान स्थापित करने और उपयोग करने के लिए
+ उत्पादन के लिए उपयुक्त (होना चाहिए, सामान्य रूप में)
- छोटी जानकारी (मात्रा / समय)
- ग्रेफाइट और स्टैटस की आवश्यकता (भी होनी चाहिए)

सांख्यिकीय प्रोफाइलर

घटना प्रोफाइलरों के विपरीत, सांख्यिकीय प्रोफाइलिंग के लिए कुछ उपकरण हैं। मैं तीन के बारे में बात करूंगा:

StatProf

शायद अजगर के लिए सबसे प्रसिद्ध सांख्यिकीय प्रोफाइल स्टेटमैट है । हम डालते हैं:

Install पाइप स्थापित स्टेटिफ़ाइट

हम उदाहरण के लिए उपयोग करते हैं। इस तरह:

 import statprof ... statprof.start() try: do_some_action() finally: statprof.stop() statprof.display()

या एक संदर्भ प्रबंधक के रूप में (पीपीपी से संस्करण 0.1.2 में नहीं, केवल भंडार से संस्करण में)

 import statprof ... with statprof.profile(): do_some_action()

आइए हमारे कोड को प्रोफाइल करने का प्रयास करें:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
85 अजगर euler_3.py 600851475143
% संचयी स्व
समय सेकंड सेकंड नाम
44.42 8.63 8.63 euler_3.py:12:is_prime
37.12 7.21 7.21 euler_3.py:11:is_prime
16.90 19.40 3.28 euler_3.py:21:find_prime_factors
0.95 0.18 0.18 euler_3.py:9:is_prime
0.48 0.09 0.09 euler_3.py:13:is_prime
0.06 0.01 0.01 euler_3.py:14:is_prime
0.06 0.01 0.01 euler_3.py:20:find_prime_factors
0.03 0.01 0.01 euler_3.py:23:find_prime_factors
0.00 19.42 0.00 euler_3.py:37: <मॉड्यूल>
- नमूना गणना: 3575
कुल समय: 19.420000 सेकंड
उत्तर- 6857

हम अपने कार्यक्रम में दो हॉटस्पॉट देखते हैं। पहला: is_prime फ़ंक्शन (जो कि तार्किक है) की पंक्तियाँ 12 और 11, उनका निष्पादन प्रोग्राम के समय का लगभग 82% लेता है, और दूसरा: find_prime_factors फ़ंक्शन की लाइन 21 (समय का लगभग 17%):

 if is_prime(i) and not num % i:

यह इस पंक्ति से है कि is_prime प्रोग्राम का सबसे गर्म कार्य कहा जाता है। बस हालत में ऑपरेंड्स को बदलकर, हम प्रोग्राम को महत्वपूर्ण रूप से गति देंगे, क्योंकि विभाजन के शेष (संख्यात्मक% i) को प्राप्त करने का संचालन "is_prime" फ़ंक्शन की तुलना में तेज़ है, और एक ही समय में अक्सर एक संख्या को दूसरे से विभाजित करने का शेष शून्य के बराबर नहीं है, और "संख्या% i" को गलत नहीं माना जाएगा। इस प्रकार, हम is_prime फ़ंक्शन में कॉल की संख्या को बहुत कम कर देंगे:

 if not num % i and is_prime(i):

हम प्रोफाइलिंग शुरू करते हैं:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
85 अजगर euler_3.py 600851475143
% संचयी स्व
समय सेकंड सेकंड नाम
87.50 0.22 0.22 euler_3.py:21:find_prime_factors
5.00 0.01 0.01 euler_3.py:20:find_prime_factors
5.00 0.01 0.01 euler_3.py:11:is_prime
2.50 0.01 0.01 euler_3.py:23:find_prime_factors
0.00 0.25 0.00 euler_3.py:37: <मॉड्यूल>
- सैंपल काउंट: 40
कुल समय: 0.250000 सेकंड
उत्तर- 6857

हमारे कार्यक्रम में सबसे गर्म स्थान अब फ़ंक्शन "find_prime_factors" की पंक्ति 21 है, अर्थात, विभाजन के शेष को प्राप्त करने का संचालन ("संख्या% i")। फ़ंक्शन "is_prime" अब बहुत कम बार कहा जाता है और कार्यक्रम चलने के समय का केवल 5%। कार्यक्रम चलाने का समय काफी कम हो गया है और 600851475143 नंबर का सबसे बड़ा सरल विभाजक अब केवल 0.25 सेकंड में स्थित है (उन्होंने कार्यक्रम को लगभग 80 बार तेज किया)।

आइए ध्यान दें कि प्रोफाइलर ऑपरेशन की सटीकता कितनी कम हो गई है: 3575 नमूनों (अनुकूलन से पहले उदाहरण में) के बजाय, केवल 40 माप लिए गए और केवल पांच लाइनों पर जानकारी प्राप्त की गई। बेशक, यह पर्याप्त नहीं है। दरअसल, यह सांख्यिकीय प्रोफाइलर्स की विशेषता है: जितना अधिक समय हम डेटा एकत्र करते हैं, विश्लेषण उतना ही सटीक होता है। यदि, उदाहरण के लिए, हमने दस या सौ बार कार्यक्रम चलाया, तो हमें अधिक सटीक परिणाम मिले।

यहां मुझे थोड़ा विषयांतर करना होगा।

सभी सहायक उपयोगिताओं का 99%, जैसे कि प्रोफाइलर या कोड कवरेज विश्लेषण उपकरण, सूचना की न्यूनतम इकाई के रूप में तार के साथ काम करते हैं। इस प्रकार, यदि हम कोड को यथासंभव कॉम्पैक्ट रूप से लिखने का प्रयास करते हैं, उदाहरण के लिए:

 result = foo() if bar else baz()

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

 if bar: result = foo() else: result = baz()

और फिर हम तुरंत देखेंगे कि कौन सी लाइनें निष्पादित नहीं की गई हैं, और कौन से निष्पादित हैं (और कितनी बार)। सिंगल-लाइन और कॉम्पैक्टीनेस अच्छे और मज़ेदार हैं, लेकिन कभी-कभी अधिक समय बिताना और कोड प्राप्त करना बेहतर होता है जो प्रोफ़ाइल, परीक्षण और रखरखाव के लिए आसान होता है।

सांख्यिकीय लाभ और लाभ:
+ न्यूनतम ओवरहेड
+ आसान उपयोग
- कार्यान्वयन काफी कच्चा और प्रायोगिक है
- पर्याप्त परिणाम के लिए, एक लंबे विश्लेषण की आवश्यकता है
- थोड़ा डेटा आउटपुट

Django-लिव-प्रोफाइलर

ध्यान देने योग्य एक अलग बिंदु django-live-profiler है - स्टेटो का उपयोग करके एक Django एप्लिकेशन प्रोफाइलर। इसे काम करने के लिए, आपको पहले zeromq स्थापित करना होगा:

➜ काढ़ा स्थापित zmq

हमने मॉड्यूल खुद रखा:

। पाइप स्थापित django-live-profiler

और एग्रीगेटर चलाएं:

➜ एग्रीगेटेड --होस्ट 127.0.0.1 --पोर्ट 5556

अगला, सेटिंग में प्रोफाइलर को भेजें।

 #  application INSTALLED_APPS += ('profiler',) #  middleware MIDDLEWARE_CLASSES += ( 'profiler.middleware.ProfilerMiddleware', 'profiler.middleware.StatProfMiddleware', )

और urls.py में:

 url(r'^profiler/', include('profiler.urls'))

हम सर्वर शुरू करते हैं:

N अजगर प्रबंधन ओरेकल रनवेवर - नॉरेलैड - निथ्रेडिंग

हम ब्राउज़र में प्रोफाइलर को खोलते हैं: 127.0.0.1 : 8000 / प्रोफाइलर / और वास्तविक समय में लाइव प्रोजेक्ट को प्रोफाइल करने के परिणामों को देखकर जीवन का आनंद लें:

और django-live-profiler SQL क्वेरी दिखा सकता है:

Django-live-profiler के फायदे और नुकसान:
+ छोटा ओवरहेड
+ उत्पादन में रखा जा सकता है (बहुत सावधानी से)
+ SQL क्वेरी प्रोफाइलिंग
- जटिल स्थापना, निर्भरता
- थोड़ा डेटा आउटपुट

खटखटाने से

एक अन्य सांख्यिकीय प्रोफाइलर को प्लॉप (पायथन लो-ओवरहेड प्रोफाइलर) कहा जाता है। लेखक तुरंत चेतावनी देता है कि कार्यान्वयन कच्चा है और परियोजना सक्रिय विकास के तहत है। स्थापना तुच्छ है:

➜ पाइप स्थापित प्लॉप बवंडर

हम प्रोफाइलिंग शुरू करते हैं:

rudnyh @ काम : ~ / काम / अजगर-प्रोफाइलिंग (venv: अजगर-प्रोफाइलिंग )
➜ पायथन -m plop.collector euler_3.py 600851475143
उत्तर- 6857
प्रोफ़ाइल आउटपुट /tmp/plop.out पर सहेजा गया
ओवरहेड 5.89810884916e-05 प्रति नमूना (0.00589810884916%) था

हम परिणाम देखने के लिए सर्वर शुरू करते हैं:

On अजगर- m plop.viewer - दातादिर = / tmp /

ब्राउज़र में http: // localhost: 8888 / पृष्ठ खोलें और परिणामों का आनंद लें:

प्लॉप का उपयोग Django अनुप्रयोगों को प्रोफाइल करने के लिए किया जा सकता है। ऐसा करने के लिए, django-plop पैकेज स्थापित करें:

➜ पाइप स्थापित django-plop

सेटिंग्स को जोड़ने के लिए सेटिंग्स को मध्य-दिशा में रखें।

 MIDDLEWARE_CLASSES += ( 'django-plop.middleware.PlopMiddleware', ) PLOP_DIR = os.path.join(PROJECT_ROOT, 'plop')

एक बड़ी परियोजना में, ग्राफ अधिक प्रभावशाली दिखाई देगा:

चित्र काफी साइकेडेलिक है, इसे एक गंभीर प्रोफाइलिंग टूल कहना मुश्किल है, लेकिन फिर भी हमारे पास कॉल ग्राफ़ है, कोड के सबसे गर्म भाग दिखाई दे रहे हैं, ओवरहेड न्यूनतम है (लेखकों के अनुसार, केवल 2%), और कुछ मामलों में यह टूल वर्गों का पता लगाने के लिए पर्याप्त है कोड की जरूरत है रूपरेखा। ड्रॉपबॉक्स सेवा उत्पादन में सीधे प्लॉप का उपयोग करती है, और यह बहुत कुछ कहती है।

प्लॉप के फायदे और नुकसान:
+ न्यूनतम ओवरहेड
+ उत्पादन में डाला जा सकता है
- जटिल स्थापना, निर्भरता
- बहुत कम आउटपुट

नया अवशेष

सांख्यिकीय प्रोफाइलरों के बारे में बोलते हुए, कोई भी नई अवशेष सेवा के बारे में नहीं कह सकता है, जिसका उद्देश्य न केवल प्रोफाइलिंग के लिए है, बल्कि सर्वर और वेब एप्लिकेशन (साथ ही मोबाइल संस्करण) की निगरानी के लिए भी है। जो लोग चाहते हैं वे कंपनी की वेबसाइट पर सभी जानकारी देख सकते हैं, साथ ही साथ मुफ्त में सेवा की कोशिश कर सकते हैं। मैं इसके बारे में बात नहीं करूंगा क्योंकि मैंने व्यक्तिगत रूप से न्यू रेलिक के साथ काम करने की कोशिश नहीं की है, और मुझे केवल उन चीजों के बारे में बात करने की आदत है जो मैंने खुद की कोशिश की। प्रोफाइलर पृष्ठ पर स्क्रीनशॉट देखें।

फायदे और नुकसान:
+ उत्पादन के लिए इरादा
+ कई अलग-अलग कार्य (केवल प्रोफाइलिंग नहीं)
- भुगतान किया गया (एक निःशुल्क संस्करण है)
- डेटा अन्य लोगों के सर्वर पर भेजा जाता है

अगले लेख में, हम घटना प्रोफाइलरों के अध्ययन पर आगे बढ़ेंगे - पायथन की रूपरेखा के लिए मुख्य उपकरण। संपर्क में रहें!

पायथन प्रोफाइलिंग और डिबगिंग, चलो अभ्यास के लिए आगे बढ़ते हैं