आप एक पायथन स्क्रिप्ट कैसे प्रोफाइल कर सकते हैं?

Question

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

एक अच्छा तरीका है कि एक पायथन प्रोग्राम को चलाने में कितना समय लगता है?

Comments

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

— एस.लॉट

एस.लॉट: प्रोफाइलिंग अक्सर यह निर्धारित करने का एक सहायक तरीका है कि कौन से सबरूटीन्स धीमे हैं। सबरूटीन्स जो एक लंबा समय लेते हैं एल्गोरिथम सुधार के लिए महान उम्मीदवार हैं।

— स्टेपलप्रेटज़ेल

Answer 1

पायथन में एक प्रोफाइलर कहा जाता है cProfile । यह न केवल कुल चलने का समय देता है, बल्कि प्रत्येक फ़ंक्शन को अलग-अलग समय भी देता है, और आपको बताता है कि प्रत्येक फ़ंक्शन को कितनी बार कॉल किया गया था, जिससे यह निर्धारित करना आसान हो जाता है कि आपको कहां अनुकूलन करना चाहिए।

आप इसे अपने कोड के भीतर या दुभाषिया से इस तरह से कॉल कर सकते हैं:

import cProfile
cProfile.run('foo()')

और भी उपयोगी रूप से, आप स्क्रिप्ट चलाते समय cProfile का उपयोग कर सकते हैं:

python -m cProfile myscript.py

इसे और भी आसान बनाने के लिए, मैंने 'profile.bat' नामक एक छोटी बैच फ़ाइल बनाई:

python -m cProfile %1

तो मुझे बस इतना करना है:

profile euler048.py

और मुझे यह मिलता है:

1007 function calls in 0.061 CPU seconds

Ordered by: standard name
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.000    0.000    0.061    0.061 <string>:1(<module>)
 1000    0.051    0.000    0.051    0.000 euler048.py:2(<lambda>)
    1    0.005    0.005    0.061    0.061 euler048.py:2(<module>)
    1    0.000    0.000    0.061    0.061 {execfile}
    1    0.002    0.002    0.053    0.053 {map}
    1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler objects}
    1    0.000    0.000    0.000    0.000 {range}
    1    0.003    0.003    0.003    0.003 {sum}

EDIT: PyCon 2013 के एक अच्छे वीडियो संसाधन का अपडेट किया गया लिंक जिसका शीर्षक Python Profiling
Also YouTube के माध्यम से है ।

Comments

परिणामों को क्रमबद्ध करने के लिए भी यह उपयोगी है, जिसे -s स्विच द्वारा किया जा सकता है, उदाहरण: '-s time'। आप संचयी / नाम / समय / फ़ाइल छँटाई विकल्प का उपयोग कर सकते हैं।

— जिरी

यह भी ध्यान देने योग्य है कि आप जादुई फ़ंक्शन% प्रून (प्रोफ़ाइल रन) का उपयोग करके ipython से cProfile मॉड्यूल का उपयोग कर सकते हैं। पहले अपने मॉड्यूल को आयात करें, और फिर% प्रून के साथ मुख्य फ़ंक्शन को कॉल करें: euler048 आयात करें; % प्रून ईलर 048.main ()

— रसेलस्टार्ट 19

CProfile dumps (द्वारा बनाई गई python -m cProfile -o <out.profile> <script>), RunSnakeRun को देखने के लिए , जैसा runsnake <out.profile>कि अमूल्य है।

— लिली चुंग

अजगर 3 के लिए भी @ नील, cprofileअभी भी खत्म की सिफारिश की है profile।

— ट्राइकोप्लाक्स

सीप्रोफाइल डंप्स की कल्पना के लिए, RunSnakeRun को 2011 से अपडेट नहीं किया गया है और यह python3 का समर्थन नहीं करता है। आपको इसके स्थान पर स्नेकविज़ का उपयोग करना चाहिए

— जियाको टेकी पिगानी

Answer 2

कुछ समय पहले मैंने बनाया था pycallgraphजो आपके पायथन कोड से एक दृश्य उत्पन्न करता है। संपादित करें: मैंने 3.3 के साथ काम करने के लिए उदाहरण को अद्यतन किया है, इस लेखन के रूप में नवीनतम रिलीज।

ग्राफविज़ कोpip install pycallgraph स्थापित करने और स्थापित करने के बाद आप इसे कमांड लाइन से चला सकते हैं:

pycallgraph graphviz -- ./mypythonscript.py

या, आप अपने कोड के विशेष भागों को प्रोफाइल कर सकते हैं:

from pycallgraph import PyCallGraph
from pycallgraph.output import GraphvizOutput

with PyCallGraph(output=GraphvizOutput()):
    code_to_profile()

इनमें से कोई भी pycallgraph.pngनीचे की छवि के समान एक फ़ाइल उत्पन्न करेगा :

Comments

क्या आप कॉल की मात्रा के आधार पर रंग कर रहे हैं? यदि हां, तो आपको समय के आधार पर रंग देना चाहिए क्योंकि सबसे अधिक कॉल वाला फ़ंक्शन हमेशा ऐसा नहीं होता है जो सबसे अधिक समय लेता है।

— लाल

@ आप अपने पसंद के अनुसार रंग अनुकूलित कर सकते हैं, और प्रत्येक माप के लिए स्वतंत्र रूप से भी। उदाहरण के लिए कॉल के लिए लाल, समय के लिए नीला, मेमोरी के उपयोग के लिए हरा।

— gak

इस त्रुटि को Traceback (most recent call last): /pycallgraph.py", line 90, in generate output.done() File "/net_downloaded/pycallgraph-develop/pycallgraph/output/graphviz.py", line 94, in done source = self.generate() File "/net_downloaded/pycallgraph-develop/pycallgraph/output/graphviz.py", line 143, in generate indent_join.join(self.generate_attributes()), File "/net_downloaded/pycallgraph-develop/pycallgraph/output/graphviz.py", line 169, in generate_attributes section, self.attrs_from_dict(attrs), ValueError: zero length field name in format

— पाकर

मैंने यह उल्लेख करने के लिए अद्यतन किया है कि आपको वर्णित के रूप में काम करने के लिए ग्राफ़विज़ को स्थापित करने की आवश्यकता है। उबंटू पर यह सिर्फ है sudo apt-get install graphviz।

— mlissner

इसे स्थापित करने के लिए थोड़ी सी मेहनत की आवश्यकता है यहां मदद के लिए 3 चरण हैं। 1. पाइप के माध्यम से स्थापित करें, 2. exe के माध्यम से ग्राफविज़ स्थापित करें। ग्राफविज़ निर्देशिका के लिए पथ चर सेट करें। 4. अन्य सभी त्रुटियों को ठीक करने का तरीका जानें। 5. यह पीएनजी फ़ाइल को कहाँ बचाता है?

— मार्श

Answer 3

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

यदि आप थ्रेड्स को प्रोफाइल करना चाहते हैं, तो आप डॉक्स में threading.setprofile()फ़ंक्शन को देखना चाहेंगे ।

आप threading.Threadइसे करने के लिए अपना उपवर्ग भी बना सकते हैं :

class ProfiledThread(threading.Thread):
    # Overrides threading.Thread.run()
    def run(self):
        profiler = cProfile.Profile()
        try:
            return profiler.runcall(threading.Thread.run, self)
        finally:
            profiler.dump_stats('myprofile-%d.profile' % (self.ident,))

और ProfiledThreadमानक एक के बजाय उस वर्ग का उपयोग करें । यह आपको अधिक लचीलापन दे सकता है, लेकिन मुझे यकीन नहीं है कि यह इसके लायक है, खासकर यदि आप तृतीय-पक्ष कोड का उपयोग कर रहे हैं जो आपकी कक्षा का उपयोग नहीं करेगा।

Comments

मैं या तो दस्तावेज़ में रनकॉल का कोई संदर्भ नहीं देखता। CProfile.py पर एक नज़र देते हुए, मुझे यकीन नहीं है कि आप थ्रेडिंग का उपयोग क्यों करते हैं। थ्रेड.रुण फ़ंक्शन और न ही तर्क के रूप में स्वयं। मुझे यहाँ एक और थ्रेड रन विधि का संदर्भ देखने की उम्मीद है।

— PypeBros

यह प्रलेखन में नहीं है, लेकिन यह मॉड्यूल में है। देखHg.python.org/cpython/file/6bf07db23445/Lib/cProfile.py#l140 । यह आपको एक विशिष्ट फ़ंक्शन कॉल को प्रोफाइल करने की अनुमति देता है, और हमारे मामले में हम थ्रेड के targetफ़ंक्शन को प्रोफ़ाइल करना चाहते हैं , जो कि threading.Thread.run()कॉल निष्पादित करता है। लेकिन जैसा कि मैंने जवाब में कहा, थ्रेड को उप-वर्ग के लिए संभवतः इसके लायक नहीं है, क्योंकि कोई भी तृतीय-पक्ष कोड इसका उपयोग नहीं करेगा, और इसके बजाय उपयोग करने के लिए threading.setprofile()।

— जो शॉ

profiler.enable () और profiler.disable () के साथ कोड को लपेटना काफी अच्छी तरह से काम करने लगता है। यही कारण है कि मूल रूप से रनकॉल करते हैं और यह किसी भी तरह के तर्क या इसी तरह की चीजों को लागू नहीं करता है।

— PypeBros

मैंने अपना खुद का स्टैन्कओवरफ़्लो.com /questions/10748118/… संयुक्त किया को ddaa.net/blog/python/lsprof-calltree के साथ जोड़ा और यह काम करता है! -!)

— Dima Tisnek

जो, क्या आप जानते हैं कि पायथन 3.4 में प्रोफाइलर एसिनेसियो के साथ कैसे खेलता है?

— निक चामास

Answer 4

पायथन विकी प्रोफाइलिंग संसाधनों के लिए एक महान पृष्ठ है: http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code

जैसा कि अजगर डॉक्स है: http://docs.python.org/library/profile.html

जैसा कि क्रिस लॉरल द्वारा दिखाया गया है cProfile एक बेहतरीन टूल है और इसे आसानी से स्क्रीन पर प्रिंट करने के लिए इस्तेमाल किया जा सकता है:

python -m cProfile -s time mine.py <args>

या फाइल करने के लिए:

python -m cProfile -o output.file mine.py <args>

PS> यदि आप उबंटू का उपयोग कर रहे हैं, तो सुनिश्चित करें कि अजगर-प्रोफाइल स्थापित करें

apt-get install python-profiler 

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

PyCallGraph: कॉल ग्राफ चित्र बनाने के लिए एक उपकरण
स्थापित:

 pip install pycallgraph

Daud:

 pycallgraph mine.py args

राय:

 gimp pycallgraph.png

आप png फ़ाइल को देखने के लिए जो कुछ भी पसंद करते हैं, आप उसका उपयोग कर सकते हैं, मैंने जिम्प का उपयोग किया
दुर्भाग्य से मुझे अक्सर मिलता है

डॉट: कैरो-रेंडरर बिटमैप्स के लिए ग्राफ बहुत बड़ा है। फिट करने के लिए 0.257079 द्वारा स्केलिंग

जो मेरी छवियों को असामान्य रूप से छोटा बनाता है। इसलिए मैं आम तौर पर svg फाइलें बनाता हूं:

pycallgraph -f svg -o pycallgraph.svg mine.py <args>

PS> ग्राफ़विज़ (जो डॉट प्रोग्राम प्रदान करता है) स्थापित करना सुनिश्चित करें:

pip install graphviz

@Maxy / @quodlibetor के माध्यम से gprof2dot का उपयोग करके वैकल्पिक रेखांकन:

pip install gprof2dot
python -m cProfile -o profile.pstats mine.py
gprof2dot -f pstats profile.pstats | dot -Tsvg -o mine.svg

Comments

gprof2dot उन रेखांकन भी कर सकते हैं। मुझे लगता है कि आउटपुट थोड़ा अच्छा है ( उदाहरण )।

— अधिकतम

यदि आप OSX

— वैभव मिश्रा

Answer 5

@ इस जवाब पर मैक्सी की टिप्पणी से मुझे काफी मदद मिली कि मुझे लगता है कि यह इसका खुद का जवाब देने योग्य है: मेरे पास पहले से ही cPile-Generate .pstats फाइलें थीं और मैं pycallgraph के साथ चीजों को फिर से नहीं चलाना चाहता था, इसलिए मैंने g52dot का उपयोग किया , और बहुत सुंदर मिला। SVGs:

$ sudo apt-get install graphviz
$ git clone https://github.com/jrfonseca/gprof2dot
$ ln -s "$PWD"/gprof2dot/gprof2dot.py ~/bin
$ cd $PROJECT_DIR
$ gprof2dot.py -f pstats profile.pstats | dot -Tsvg -o callgraph.svg

और BLAM!

यह डॉट (एक ही चीज़ जो pycallgraph उपयोग करता है) का उपयोग करता है, इसलिए आउटपुट समान दिखता है। मुझे लगता है कि gprof2dot कम जानकारी खो देता है हालांकि:

Comments

अच्छा दृष्टिकोण, वास्तव में अच्छी तरह से काम करता है जैसा कि आप एसवीजी को क्रोम आदि में देख सकते हैं और इसे ऊपर / नीचे स्केल कर सकते हैं। तीसरी पंक्ति में टाइपो, होना चाहिए: ln -s pwd/gprof2dot/gprof2dot.py $ HOME / bin (या उपयोग ln -s $ PWD / gprof2dot / gprof2dot.py ~ / bin in most shells - grave accent को पहले स्वरूपण के रूप में लिया जाता है। संस्करण)।

— रिचवेल

आह, अच्छी बात है। मुझे lnलगभग हर बार तर्क-व्यवस्था गलत लगती है।

— quodlibetor

चाल को याद रखना है कि ln और cp के पास एक ही तर्क क्रम है - इसे 'file1 को file2 या

— dir2 में

यह समझ में आता है, मुझे लगता है कि मैनपेज में "TARGET" का उपयोग मुझे फेंकता है।

— quodlibetor

कृपया, आपको गोल कोनों कैसे मिला? मुझे लगता है कि यह पठनीयता में सुधार करता है। मुझे बस बदसूरत तेज कोनों मिलते हैं जो बक्से के चारों ओर कई किनारों की उपस्थिति में शांत नहीं होते हैं।

— हिबू ५ou

Answer 6

मैं इस विषय पर शोध करते समय स्नेपविज़ नामक एक उपयोगी उपकरण में भाग गया । स्नेपविज़ एक वेब-आधारित प्रोफाइलिंग विज़ुअलाइज़ेशन टूल है। इसे स्थापित करना और उपयोग करना बहुत आसान है। जिस तरह से मैं इसका उपयोग करता हूं वह एक स्टेट फाइल के साथ उत्पन्न होता है%prun करना है और फिर स्नेपविज़ में विश्लेषण करना है।

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

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

Comments

कोडकैबी के उत्तर में (लघु) इंस्टॉलेशन निर्देश शामिल हैं, और दिखाता है कि कैसे (आसानी से) स्नेपविज़ का उपयोग करें।

— ओरेन मिलमैन

: यहाँ मैं पढ़ा है IMHO अच्छा मार्गदर्शक कैसे jupyter नोटबुक पर पायथन के लिए रूपरेखा का उपयोग करने के towardsdatascience.com/speed-up-jupyter-notebooks-20716cbe2025

— अलेक्सई Martianov

Answer 7

यह जानने का सबसे सरल और तेज तरीका है कि हर समय कहां जा रहा है।

1. pip install snakeviz

2. python -m cProfile -o temp.dat <PROGRAM>.py

3. snakeviz temp.dat

एक ब्राउज़र में एक पाई चार्ट बनाता है। सबसे बड़ा टुकड़ा समस्या कार्य है। बहुत आसान।

Comments

यह बहुत मददगार था। धन्यवाद।

— jippyjoe4

Answer 8

मुझे लगता है कि cProfileयह रूपरेखा के लिए महान है, जबकि kcachegrindपरिणामों को देखने के लिए महान है। pyprof2calltreeफ़ाइल रूपांतरण हैंडल के बीच में।

python -m cProfile -o script.profile script.py
pyprof2calltree -i script.profile -o script.calltree
kcachegrind script.calltree

आवश्यक उपकरण स्थापित करने के लिए (उबंटू पर, कम से कम):

apt-get install kcachegrind
pip install pyprof2calltree

परिणाम:

Comments

मैक उपयोगकर्ता सफल प्रोफाइलिंग के विवरण में brew install qcachegrindप्रत्येक kcachegrind को स्थापित और प्रतिस्थापित करते हैं qcachegrind ।

— केविन काट्ज्के

यह काम करने के लिए मुझे ऐसा करना पड़ा:export QT_X11_NO_MITSHM=1

— योनातन सिमसन

Answer 9

इसके अलावा उल्लेख के लायक है GUI cProfile डंप दर्शक RunSnakeRun । यह आपको क्रमबद्ध और चयन करने की अनुमति देता है, जिससे कार्यक्रम के संबंधित भागों को ज़ूम इन किया जा सकता है। चित्र में आयतों का आकार लिए गए समय के समानुपाती होता है। यदि आप एक आयत पर माउस ले जाते हैं, तो यह उस हाइलाइट को तालिका में और हर जगह मैप पर बताता है। जब आप एक आयत पर डबल क्लिक करते हैं तो यह उस हिस्से पर ज़ूम करता है। यह आपको दिखाएगा कि कौन उस हिस्से को कॉल करता है और कौन सा हिस्सा कॉल करता है।

वर्णनात्मक जानकारी बहुत मददगार है। यह आपको उस बिट के लिए कोड दिखाता है जो आपके द्वारा निर्मित लाइब्रेरी कॉल के साथ काम करने में मददगार हो सकता है। यह आपको बताता है कि कोड खोजने के लिए कौन सी फ़ाइल और कौन सी लाइन है।

यह भी बताना चाहते हैं कि ओपी ने कहा कि 'प्रोफाइलिंग' लेकिन ऐसा प्रतीत होता है कि उसका मतलब 'टाइमिंग' था। ध्यान रखें कि प्रोग्राम धीमा होने पर धीमी गति से चलेगा।

Answer 10

एक अच्छा रूपरेखा मॉड्यूल लाइन_प्रोफाइलर है (जिसे स्क्रिप्ट kernprof.py का उपयोग करके कहा जाता है)। इसे यहां से डाउनलोड किया जा सकता है ।

मेरी समझ यह है कि cProfile केवल प्रत्येक फ़ंक्शन में बिताए गए कुल समय के बारे में जानकारी देता है। इसलिए कोड की व्यक्तिगत लाइनें समयबद्ध नहीं हैं। यह वैज्ञानिक कंप्यूटिंग में एक मुद्दा है क्योंकि अक्सर एक एकल लाइन में बहुत समय लग सकता है। इसके अलावा, जैसा कि मुझे याद है, cProfile ने उस समय को नहीं पकड़ा, जिसे मैं numpy.dot कह रहा था।

Answer 11

मैंने हाल ही में पायथन रनटाइम और आयात प्रोफाइल की कल्पना के लिए ट्यूना बनाया ; यह यहाँ सहायक हो सकता है।

के साथ स्थापित करें

pip install tuna

एक रनटाइम प्रोफ़ाइल बनाएं

python3 -m cProfile -o program.prof yourfile.py

या एक आयात प्रोफ़ाइल (पायथन 3.7+ आवश्यक)

python3 -X importprofile yourfile.py 2> import.log

फिर फ़ाइल पर ट्यूना चलाएं

tuna program.prof

Answer 12

pprofile

line_profiler(पहले से ही यहां प्रस्तुत) भी प्रेरित है pprofile, जो इस प्रकार है:

लाइन-ग्रैन्युलैरिटी, थ्रेड-अवेयर निर्धारक और सांख्यिकीय शुद्ध-पायथन प्रोफाइलर

यह लाइन-ग्रैन्युलैरिटी प्रदान करता है line_profiler, जैसा कि शुद्ध पायथन है, इसे स्टैंडअलोन कमांड या मॉड्यूल के रूप में इस्तेमाल किया जा सकता है, और यहां तक ​​कि कॉलग्रिंड-प्रारूप फाइलें भी उत्पन्न कर सकते हैं जिनके साथ आसानी से विश्लेषण किया जा सकता है [k|q]cachegrind।

vprof

विहिप भी है , जिसे पायथन पैकेज के रूप में वर्णित किया गया है:

[...] विभिन्न पायथन कार्यक्रम विशेषताओं के लिए समृद्ध और इंटरैक्टिव विज़ुअलाइज़ेशन प्रदान करते हैं जैसे कि समय और स्मृति उपयोग।

Answer 13

बहुत सारे शानदार जवाब हैं लेकिन वे या तो कमांड लाइन या प्रोफाइलिंग और / या परिणामों को छांटने के लिए कुछ बाहरी कार्यक्रम का उपयोग करते हैं।

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

कमांड लाइन के बिना प्रोफाइलिंग

def count():
    from math import sqrt
    for x in range(10**5):
        sqrt(x)

if __name__ == '__main__':
    import cProfile, pstats
    cProfile.run("count()", "{}.profile".format(__file__))
    s = pstats.Stats("{}.profile".format(__file__))
    s.strip_dirs()
    s.sort_stats("time").print_stats(10)

अधिक जानकारी के लिए डॉक्स या अन्य उत्तर देखें ।

Comments

उदाहरण के लिए, प्रोफ़ाइल {map} या {xxx} प्रिंट करता है। मुझे कैसे पता चलेगा कि विधि {xxx} को किस फ़ाइल से कहा जाता है? मेरा प्रोफ़ाइल 'zlib.Compress' ऑब्जेक्ट्स की {विधि 'कम्प्रेस' को प्रिंट करने में अधिक समय लेता है, लेकिन मैं किसी भी zlib का उपयोग नहीं करता हूं, इसलिए मुझे लगता है कि कुछ कॉल numpy फ़ंक्शन इसका उपयोग कर सकते हैं। मुझे कैसे पता चलेगा कि कौन सी फ़ाइल और लाइन में कितना समय लगता है?

— रिंगटोन के रूप

Answer 14

मल्टी-थ्रेडेड कोड के बारे में जो शॉ के जवाब के अनुसार उम्मीद के मुताबिक काम न करने के लिए, मुझे लगा कि runcallcProfile में विधि केवल काम कर रही है self.enable()और प्रोफाईल फंक्शन self.disable()कॉल के आसपास कॉल करती है, इसलिए आप बस यह कर सकते हैं कि आपके पास और जो भी कोड आप चाहते हैं उसके साथ मौजूदा कोड के साथ न्यूनतम हस्तक्षेप।

Comments

बहुत बढ़िया टिप! cprofile.pyस्रोत कोड पर एक त्वरित झलका से पता चलता है कि वास्तव में क्या runcall()करता है। अधिक विशिष्ट होने के नाते prof = cprofile.Profile(), तुरंत के साथ एक प्रोफ़ाइल उदाहरण बनाने के बाद , तुरंत कॉल करें prof.disable(), और फिर जिस कोड को आप प्रोफाइल करना चाहते हैं उसके अनुभाग के चारों ओर जोड़ें prof.enable()और prof.disable()कॉल करें।

— 21:39 पर मार्टिन

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

— बॉब स्टीन

Answer 15

पुण्यकाल के स्रोत में एक बहुत ही उपयोगी वर्ग और सज्जाकार है जो प्रोफाइलिंग कर सकता है (विशिष्ट तरीकों / कार्यों के लिए भी) बहुत आसान है। तब आउटपुट को KCacheGrind में बहुत आराम से देखा जा सकता है।

Comments

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

— आमजीथ

Answer 16

cProfile त्वरित रूपरेखा के लिए बहुत अच्छा है, लेकिन अधिकांश समय यह मेरे लिए त्रुटियों के साथ समाप्त हो रहा था। फंक्शन रनटेक्स पर्यावरण और चर को सही ढंग से शुरू करके इस समस्या को हल करता है, आशा है कि यह किसी के लिए उपयोगी हो सकता है:

import cProfile
cProfile.runctx('foo()', None, locals())

Answer 17

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

आप इस cumulative_profilerडेकोरेटर का उपयोग कर सकते हैं :

यह अजगर> = 3.6 विशिष्ट है, लेकिन आप nonlocalपुराने संस्करणों पर काम करने के लिए इसे हटा सकते हैं ।

import cProfile, pstats

class _ProfileFunc:
    def __init__(self, func, sort_stats_by):
        self.func =  func
        self.profile_runs = []
        self.sort_stats_by = sort_stats_by

    def __call__(self, *args, **kwargs):
        pr = cProfile.Profile()
        pr.enable()  # this is the profiling section
        retval = self.func(*args, **kwargs)
        pr.disable()

        self.profile_runs.append(pr)
        ps = pstats.Stats(*self.profile_runs).sort_stats(self.sort_stats_by)
        return retval, ps

def cumulative_profiler(amount_of_times, sort_stats_by='time'):
    def real_decorator(function):
        def wrapper(*args, **kwargs):
            nonlocal function, amount_of_times, sort_stats_by  # for python 2.x remove this row

            profiled_func = _ProfileFunc(function, sort_stats_by)
            for i in range(amount_of_times):
                retval, ps = profiled_func(*args, **kwargs)
            ps.print_stats()
            return retval  # returns the results of the function
        return wrapper

    if callable(amount_of_times):  # incase you don't want to specify the amount of times
        func = amount_of_times  # amount_of_times is the function in here
        amount_of_times = 5  # the default amount
        return real_decorator(func)
    return real_decorator

उदाहरण

फ़ंक्शन को प्रोफाइल करना baz

import time

@cumulative_profiler
def baz():
    time.sleep(1)
    time.sleep(2)
    return 1

baz()

baz 5 बार दौड़ा और यह छपा:

         20 function calls in 15.003 seconds

   Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       10   15.003    1.500   15.003    1.500 {built-in method time.sleep}
        5    0.000    0.000   15.003    3.001 <ipython-input-9-c89afe010372>:3(baz)
        5    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

समय की राशि निर्दिष्ट करना

@cumulative_profiler(3)
def baz():
    ...

Answer 18

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

इंस्टॉल:

$ pip install pyinstrument

प्रोफ़ाइल और प्रदर्शन परिणाम:

$ python -m pyinstrument ./prog.py

Python2 और 3 के साथ काम करता है।

[संपादित करें] एपीआई का दस्तावेज़ीकरण, कोड का केवल एक हिस्सा रूपरेखा के लिए, यहाँ पाया जा सकता है ।

Answer 19

मेरा तरीका yappi ( https://github.com/sumerc/yappi ) का उपयोग करना है । यह विशेष रूप से एक आरपीसी सर्वर के साथ संयुक्त रूप से उपयोगी है, जहां (यहां तक ​​कि डिबगिंग के लिए भी) आप प्रोफाइलिंग जानकारी शुरू करने, रोकने और प्रिंट करने के लिए विधि रजिस्टर करते हैं, जैसे कि इस तरह से:

@staticmethod
def startProfiler():
    yappi.start()

@staticmethod
def stopProfiler():
    yappi.stop()

@staticmethod
def printProfiler():
    stats = yappi.get_stats(yappi.SORTTYPE_TTOT, yappi.SORTORDER_DESC, 20)
    statPrint = '\n'
    namesArr = [len(str(stat[0])) for stat in stats.func_stats]
    log.debug("namesArr %s", str(namesArr))
    maxNameLen = max(namesArr)
    log.debug("maxNameLen: %s", maxNameLen)

    for stat in stats.func_stats:
        nameAppendSpaces = [' ' for i in range(maxNameLen - len(stat[0]))]
        log.debug('nameAppendSpaces: %s', nameAppendSpaces)
        blankSpace = ''
        for space in nameAppendSpaces:
            blankSpace += space

        log.debug("adding spaces: %s", len(nameAppendSpaces))
        statPrint = statPrint + str(stat[0]) + blankSpace + " " + str(stat[1]).ljust(8) + "\t" + str(
            round(stat[2], 2)).ljust(8 - len(str(stat[2]))) + "\t" + str(round(stat[3], 2)) + "\n"

    log.log(1000, "\nname" + ''.ljust(maxNameLen - 4) + " ncall \tttot \ttsub")
    log.log(1000, statPrint)

फिर जब आपका प्रोग्राम काम करता है तो आप किसी भी समय startProfilerआरपीसी विधि को कॉल करके प्रोफाइलर को शुरू कर सकते हैं और कॉल करके printProfiler(या इसे कॉल करने वाले को वापस करने के लिए आरपीसी विधि को संशोधित करके) एक लॉग फ़ाइल में जानकारी को डंप कर सकते हैं और इस तरह का आउटपुट प्राप्त कर सकते हैं:

2014-02-19 16:32:24,128-|SVR-MAIN  |-(Thread-3   )-Level 1000: 
name                                                                                                                                      ncall     ttot    tsub
2014-02-19 16:32:24,128-|SVR-MAIN  |-(Thread-3   )-Level 1000: 
C:\Python27\lib\sched.py.run:80                                                                                                           22        0.11    0.05
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\pyAheadRpcSrv\xmlRpc.py.iterFnc:293                                                22        0.11    0.0
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\serverMain.py.makeIteration:515                                                    22        0.11    0.0
M:\02_documents\_repos\09_aheadRepos\apps\ahdModbusSrv\pyAheadRpcSrv\PicklingXMLRPC.py._dispatch:66                                       1         0.0     0.0
C:\Python27\lib\BaseHTTPServer.py.date_time_string:464                                                                                    1         0.0     0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\_psmswindows.py._get_raw_meminfo:243     4         0.0     0.0
C:\Python27\lib\SimpleXMLRPCServer.py.decode_request_content:537                                                                          1         0.0     0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\_psmswindows.py.get_system_cpu_times:148 4         0.0     0.0
<string>.__new__:8                                                                                                                        220       0.0     0.0
C:\Python27\lib\socket.py.close:276                                                                                                       4         0.0     0.0
C:\Python27\lib\threading.py.__init__:558                                                                                                 1         0.0     0.0
<string>.__new__:8                                                                                                                        4         0.0     0.0
C:\Python27\lib\threading.py.notify:372                                                                                                   1         0.0     0.0
C:\Python27\lib\rfc822.py.getheader:285                                                                                                   4         0.0     0.0
C:\Python27\lib\BaseHTTPServer.py.handle_one_request:301                                                                                  1         0.0     0.0
C:\Python27\lib\xmlrpclib.py.end:816                                                                                                      3         0.0     0.0
C:\Python27\lib\SimpleXMLRPCServer.py.do_POST:467                                                                                         1         0.0     0.0
C:\Python27\lib\SimpleXMLRPCServer.py.is_rpc_path_valid:460                                                                               1         0.0     0.0
C:\Python27\lib\SocketServer.py.close_request:475                                                                                         1         0.0     0.0
c:\users\zasiec~1\appdata\local\temp\easy_install-hwcsr1\psutil-1.1.2-py2.7-win32.egg.tmp\psutil\__init__.py.cpu_times:1066               4         0.0     0.0 

यह लघु लिपियों के लिए बहुत उपयोगी नहीं हो सकता है, लेकिन सर्वर-प्रकार की प्रक्रियाओं को अनुकूलित करने में मदद करता है, विशेष रूप से दी गई printProfilerविधि को प्रोफ़ाइल के लिए समय-समय पर कई बार कहा जा सकता है और उदाहरण के लिए विभिन्न प्रोग्राम उपयोग परिदृश्यों की तुलना करें।

यप्पी के नए संस्करणों में, निम्न कोड काम करेगा:

@staticmethod
def printProfile():
    yappi.get_func_stats().print_all()

Comments

क्या इसे स्टुपेंडस यप्पी नाम नहीं दिया जाना चाहिए?

— थेरालिस्टबॉट

दुर्भाग्य से ऊपर दिया गया कोड केवल 0.62 संस्करण के साथ काम करता है जो कि pypy पर उपलब्ध नहीं है। मॉड्यूल जरूरतों 0.62 यहाँ उपलब्ध स्रोतों से संकलित करने के लिए: github.com/nirs/yappi/releases या उपयोग निर्माण मैं रेपो में खिड़कियों उस उद्देश्य के लिए काँटेदार के लिए बने github.com/Girgitt/yappi/releases

— श्री Girgitt

1.0 संस्करण के साथ संगतता आसानी से प्रदान की जा सकती है - कम से कम प्रिंट आउटपुट के लिए - प्रिंटप्रोफ़ाइलर फ़ंक्शन को संशोधित करके: def printProfiler(): if not yappi_available: return stats = yappi.get_func_stats() stats.print_all(columns={0:("name",90), 1:("ncall", 5), 2:("tsub", 8), 3:("ttot", 8), 4:("tavg",8)}) (ठीक है कि मैंने जो टिप्पणी दी थी, उसमें कोड ब्लॉक डालने के लिए दो बार प्रयास करने के बाद। यह प्रोग्रामिंग-उन्मुख क्यू एंड साइट के लिए अविश्वसनीय रूप से कठिन है। )

— श्री गिरगिट

Answer 20

पायथन में प्रोफाइलिंग को संभालने के लिए एक नया उपकरण PyVmMonitor है: http://www.pyvmmonitor.com/

इसकी कुछ अनूठी विशेषताएं हैं जैसे कि

• एक चल रहे (CPython) कार्यक्रम के लिए प्रोफाइलर संलग्न करें
• यप्पी एकीकरण के साथ मांग पर रूपरेखा
• एक अलग मशीन पर प्रोफाइल
• मल्टीपल प्रोसेस सपोर्ट (मल्टीप्रोसेसिंग, डीजेंगो ...)
• लाइव नमूना / सीपीयू दृश्य (समय सीमा चयन के साथ)
• CProfile / प्रोफ़ाइल एकीकरण के माध्यम से नियतात्मक रूपरेखा
• मौजूदा PStats परिणामों का विश्लेषण करें
• डीओटी फाइलें खोलें
• प्रोग्रामेटिक एपीआई एक्सेस
• विधि या पंक्ति द्वारा समूह के नमूने
• PyDev एकीकरण
• PyCharm एकीकरण

नोट: यह वाणिज्यिक है, लेकिन खुले स्रोत के लिए मुफ़्त है।

Answer 21

gprof2dot_magic

gprof2dotJupyterLab या Jupyter नोटबुक में डॉट ग्राफ़ के रूप में किसी भी पायथन स्टेटमेंट को प्रोफाइल करने के लिए मैजिक फ़ंक्शन ।

गिटहब रेपो: https://github.com/mattijn/gprof2dot_magic

स्थापना

सुनिश्चित करें कि आप पायथन पैकेज हैं gprof2dot_magic।

pip install gprof2dot_magic

इसकी निर्भरता gprof2dotऔर graphvizभी स्थापित किया जाएगा

प्रयोग

जादू फ़ंक्शन को सक्षम करने के लिए, पहले gprof2dot_magicमॉड्यूल लोड करें

%load_ext gprof2dot_magic

और फिर किसी रेखा विवरण को डॉट ग्राफ़ के रूप में प्रोफाइल करें:

%gprof2dot print('hello world')

Answer 22

कभी जानना चाहते हैं कि वह अजगर किस लिपि का काम कर रहा है? निरीक्षण खोल दर्ज करें। शेल का निरीक्षण करें आप ग्लोबल्स को प्रिंट / बदल सकते हैं और रनिंग स्क्रिप्ट को बाधित किए बिना फ़ंक्शन चला सकते हैं। अब ऑटो-कम्प्लीट और कमांड हिस्ट्री (केवल लिनक्स पर) के साथ।

निरीक्षण शैल एक pdb शैली डिबगर नहीं है।

https://github.com/amoffat/Inspect-Shell

आप (और आपकी कलाई घड़ी) का उपयोग कर सकते हैं।

Answer 23

Https://stackoverflow.com/a/582337/1070617 पर जोड़ने के लिए ,

मैंने यह मॉड्यूल लिखा है जो आपको cProfile का उपयोग करने और इसके आउटपुट को आसानी से देखने की अनुमति देता है। यहाँ और अधिक: https://github.com/ymichael/cprofilev

$ python -m cprofilev /your/python/program
# Go to http://localhost:4000 to view collected statistics.

यह भी देखें: एकत्रित आंकड़ों की समझ बनाने के लिए http://ymichael.com/2014/03/08/profiling-python-with-cprofile.html ।

Answer 24

यह इस बात पर निर्भर करेगा कि आप क्या रूपरेखा देखना चाहते हैं। सरल समय मैट्रिक्स (बैश) द्वारा दिया जा सकता है।

time python python_prog.py

यहां तक ​​कि '/ usr / bin / time' '--verbose' झंडे का उपयोग करके विस्तृत मैट्रिक्स का उत्पादन कर सकता है।

प्रत्येक फ़ंक्शन द्वारा दिए गए समय मैट्रिक्स की जांच करने और यह समझने के लिए कि कार्यों पर कितना समय व्यतीत होता है, आप अजगर में इनबिल्ट सीप्रोफाइल का उपयोग कर सकते हैं।

प्रदर्शन जैसे अधिक विस्तृत मैट्रिक्स में जाना, समय केवल मीट्रिक नहीं है। आप मेमोरी, थ्रेड्स आदि के बारे में चिंता कर सकते हैं।
प्रोफाइलिंग विकल्प:
1. लाइन_प्रिफ़ाइलर एक और प्रोफाइलर है जिसका इस्तेमाल आमतौर पर टाइमिंग मेट्रिक्स लाइन-बाय-लाइन का पता लगाने के लिए किया जाता है।
2. मेमरी_प्रिफ़ाइलर एक मेमोरी मेमोरी यूज़ करने का टूल है।
3. heapy (प्रोजेक्ट गप्पी से) प्रोफ़ाइल कैसे ढेर में वस्तुओं का उपयोग किया जाता है।

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

Answer 25

ऑस्टिन की तरह एक सांख्यिकीय प्रोफाइलर के साथ , कोई इंस्ट्रूमेंटेशन की आवश्यकता नहीं होती है, जिसका अर्थ है कि आप केवल पायथन एप्लिकेशन से प्रोफाइलिंग डेटा प्राप्त कर सकते हैं

austin python3 my_script.py

कच्चा आउटपुट बहुत उपयोगी नहीं होता है, लेकिन आप उस डेटा को लौ ग्राफ़िकल प्रतिनिधित्व प्राप्त करने के लिए उसे लौ कर सकते हैं । यह आपको उस समय का ब्रेकडाउन देता है, जहाँ समय (वास्तविक समय के माइक्रोसेकंड में मापा गया) खर्च किया जा रहा है।

austin python3 my_script.py | flamegraph.pl > my_script_profile.svg

Answer 26

एक सांख्यिकीय प्रोफाइलर भी कहा जाता है statprof । यह एक नमूना प्रोफाइलर है, इसलिए यह आपके कोड में न्यूनतम ओवरहेड जोड़ता है और लाइन-आधारित (केवल फ़ंक्शन-आधारित नहीं) समय देता है। यह खेलों की तरह नरम वास्तविक समय अनुप्रयोगों के लिए अधिक अनुकूल है, लेकिन cProfile की तुलना में कम सटीक हो सकता है।

Pypi में संस्करण थोड़ा पुराना है, इसलिए साथ स्थापित कर सकते हैं pipनिर्दिष्ट द्वारा Git भंडार :

pip install git+git://github.com/bos/statprof.py@1a33eba91899afe17a8b752c6dfdec6f05dd0c01

आप इसे इस तरह से चला सकते हैं:

import statprof

with statprof.profile():
    my_questionable_function()

यह भी देखें https://stackoverflow.com/a/10333592/320036

Answer 27

मैंने सिर्फ pypref_time से प्रेरित अपना स्वयं का प्रोफाइलर विकसित किया है:

https://github.com/modaresimr/auto_profiler

डेकोरेटर को जोड़ने से यह समय लेने वाले कार्यों का एक पेड़ दिखाएगा

@Profiler(depth=4, on_disable=show)

Install by: pip install auto_profiler

उदाहरण

import time # line number 1
import random

from auto_profiler import Profiler, Tree

def f1():
    mysleep(.6+random.random())

def mysleep(t):
    time.sleep(t)

def fact(i):
    f1()
    if(i==1):
        return 1
    return i*fact(i-1)


def show(p):
    print('Time   [Hits * PerHit] Function name [Called from] [Function Location]\n'+\
          '-----------------------------------------------------------------------')
    print(Tree(p.root, threshold=0.5))

@Profiler(depth=4, on_disable=show)
def main():
    for i in range(5):
        f1()

    fact(3)


if __name__ == '__main__':
    main()

उदाहरण आउटपुट

Time   [Hits * PerHit] Function name [Called from] [function location]
-----------------------------------------------------------------------
8.974s [1 * 8.974]  main  [auto-profiler/profiler.py:267]  [/test/t2.py:30]
├── 5.954s [5 * 1.191]  f1  [/test/t2.py:34]  [/test/t2.py:14]
│   └── 5.954s [5 * 1.191]  mysleep  [/test/t2.py:15]  [/test/t2.py:17]
│       └── 5.954s [5 * 1.191]  <time.sleep>
|
|
|   # The rest is for the example recursive function call fact
└── 3.020s [1 * 3.020]  fact  [/test/t2.py:36]  [/test/t2.py:20]
    ├── 0.849s [1 * 0.849]  f1  [/test/t2.py:21]  [/test/t2.py:14]
    │   └── 0.849s [1 * 0.849]  mysleep  [/test/t2.py:15]  [/test/t2.py:17]
    │       └── 0.849s [1 * 0.849]  <time.sleep>
    └── 2.171s [1 * 2.171]  fact  [/test/t2.py:24]  [/test/t2.py:20]
        ├── 1.552s [1 * 1.552]  f1  [/test/t2.py:21]  [/test/t2.py:14]
        │   └── 1.552s [1 * 1.552]  mysleep  [/test/t2.py:15]  [/test/t2.py:17]
        └── 0.619s [1 * 0.619]  fact  [/test/t2.py:24]  [/test/t2.py:20]
            └── 0.619s [1 * 0.619]  f1  [/test/t2.py:21]  [/test/t2.py:14]

Answer 28

जब मैं सर्वर पर रूट नहीं करता हूं, तो मैं lsprofcalltree.py का उपयोग करता हूं और अपना प्रोग्राम इस तरह से चलाता हूं:

python lsprofcalltree.py -o callgrind.1 test.py

फिर मैं qcachegrind की तरह किसी भी कॉलग्रिंड-संगत सॉफ़्टवेयर के साथ रिपोर्ट खोल सकता हूं

Answer 29

IPython नोटबुक पर अपने कोड स्निपेट के लिए त्वरित प्रोफ़ाइल आँकड़े प्राप्त करने के लिए। एक सीधे अपने नोटबुक में लाइन_प्रोफ़ाइलर और मेमोरी_प्रिफ़ाइलर एम्बेड कर सकते हैं।

उसे ले लो!

!pip install line_profiler
!pip install memory_profiler

इसे लोड करें!

%load_ext line_profiler
%load_ext memory_profiler

इसका इस्तेमाल करें!

---

%समय

%time print('Outputs CPU time,Wall Clock time') 
#CPU times: user 2 µs, sys: 0 ns, total: 2 µs Wall time: 5.96 µs

देता है:

• CPU समय: CPU स्तर निष्पादन समय
• sys बार: सिस्टम स्तर निष्पादन समय
• कुल: CPU समय + सिस्टम समय
• दीवार समय: दीवार घड़ी समय

---

% timeit

%timeit -r 7 -n 1000 print('Outputs execution time of the snippet') 
#1000 loops, best of 7: 7.46 ns per loop

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

---

% prun

%prun -s cumulative 'Code to profile' 

देता है:

• फ़ंक्शन कॉल की संख्या (ncalls)
• फ़ंक्शन कॉल के लिए प्रविष्टियाँ हैं (अलग)
• प्रति कॉल समय (percall)
• उस फ़ंक्शन कॉल (सह समय) तक का समय समाप्त
• फंक / मॉड्यूल का नाम आदि ...

---

% memit

%memit 'Code to profile'
#peak memory: 199.45 MiB, increment: 0.00 MiB

देता है:

• स्मृति उपयोग

---

% lprun

#Example function
def fun():
  for i in range(10):
    print(i)

#Usage: %lprun <name_of_the_function> function
%lprun -f fun fun()

देता है:

• लाइन वार आँकड़े