ඔබට පයිතන් පිටපතක් පැතිකඩ කළ හැක්කේ කෙසේද?


1299

ව්‍යාපෘති අයිලර් සහ වෙනත් කේතීකරණ තරඟ සඳහා බොහෝ විට ධාවනය කිරීමට උපරිම කාලයක් තිබේ හෝ ඔවුන්ගේ විශේෂිත විසඳුම කොතරම් වේගයෙන් ක්‍රියාත්මක වේදැයි පුරසාරම් දොඩයි. පයිතන් සමඟ, සමහර විට ප්‍රවේශයන් තරමක් ක්ලඩ්ජි වේ - එනම්, කාල කේතය එකතු කිරීම __main__.

පයිතන් වැඩසටහනක් ක්‍රියාත්මක වීමට කොපමණ කාලයක් ගතවේද යන්න පැතිකඩ කිරීමට හොඳ ක්‍රමයක් කුමක්ද?


115
ව්‍යාපෘති අයිලර් වැඩසටහන් සඳහා පැතිකඩ අවශ්‍ය නොවේ. එක්කෝ ඔබට විනාඩියකට අඩු කාලයක් තුළ ක්‍රියාත්මක වන ඇල්ගොරිතමයක් තිබේ, නැතහොත් ඔබට සම්පූර්ණයෙන්ම වැරදි ඇල්ගොරිතමයක් ඇත. "සුසර කිරීම" කලාතුරකින් සුදුසු නොවේ. ඔබ සාමාන්‍යයෙන් නැවුම් ප්‍රවේශයක් ගත යුතුය.
එස්.ලොට්

107
එස්. ලොට්: පැතිකඩ බොහෝ විට කුමන සබ්මැරීන මන්දගාමීද යන්න තීරණය කිරීමට උපකාරී වේ. දිගු කාලයක් ගතවන සබ්ට්‍රවුටින් ඇල්ගොරිතම වැඩිදියුණු කිරීම සඳහා විශිෂ්ට අපේක්ෂකයින් වේ.
stalepretzel

Answers:


1390

පයිතන්ට 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}

සංස්කරණය කරන්න: PyCon 2013 වෙතින් Python Profiling
ද යූ ටියුබ් හරහා හොඳ වීඩියෝ සම්පතක් සඳහා සබැඳිය යාවත්කාලීන කරන ලදි .


254
ප්‍රති results ල වර්ග කිරීම ප්‍රයෝජනවත් වේ, එය -s ස්විචය මඟින් කළ හැකිය, උදාහරණයක් ලෙස: '-s time'. ඔබට සමුච්චිත / නම / වේලාව / ගොනු වර්ග කිරීමේ විකල්ප භාවිතා කළ හැකිය.
ජිරි

20
% Prun (පැතිකඩ ධාවනය) යන මැජික් ශ්‍රිතය භාවිතයෙන් ඔබට ipython වෙතින් cProfile මොඩියුලය භාවිතා කළ හැකි බව ද සඳහන් කිරීම වටී. පළමුව ඔබේ මොඩියුලය ආයාත කරන්න, ඉන්පසු% prun සමඟ ප්‍රධාන කාර්යය අමතන්න: ආනයනය euler048; % prun euler048.main ()
රසල් ස්ටුවර්ට්

54
CProfile ඩම්ප් දෘශ්‍ය කිරීම සඳහා (විසින් නිර්මාණය කරන ලදි python -m cProfile -o <out.profile> <script>), RunSnakeRun , runsnake <out.profile>මිල කළ නොහැකි ලෙස ආයාචනය කරයි .
ලිලී චුන්

15
පයිතන් 3 සඳහා පවා නීල්ග් cprofileතවමත් නිර්දේශ කර ඇත profile.
ට්‍රයිකොප්ලැක්ස්

21
CProfile ඩම්ප් දර්ශනය කිරීම සඳහා, RunSnakeRun 2011 සිට යාවත්කාලීන කර නොමැති අතර python3 සඳහා සහය නොදක්වයි. ඒ වෙනුවට ඔබ සර්ප විවිස් භාවිතා කළ යුතුය
ජියාකොමෝ ටෙසියා පිගානි

432

ටික වේලාවකට පෙර මම 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පහත රූපයට සමාන ගොනුවක් ජනනය කරනු ඇත:

රූප විස්තරය මෙහි ඇතුළත් කරන්න


44
ඇමතුම් ප්‍රමාණය මත පදනම්ව ඔබ වර්ණ ගන්වනවාද? එසේ නම්, ඔබ කාලය මත පදනම්ව වර්ණ ගැන්විය යුත්තේ බොහෝ ඇමතුම් සහිත ශ්‍රිතය සැමවිටම වැඩි කාලයක් ගත නොවන බැවිනි.
රතු

21
@red ඔබට කැමති ආකාරයට වර්ණ අභිරුචිකරණය කළ හැකි අතර එක් එක් මිනුම් සඳහා ස්වාධීනව පවා. උදාහරණයක් ලෙස ඇමතුම් සඳහා රතු, වේලාවට නිල්, මතක භාවිතය සඳහා කොළ.
ගක්

2
මෙම දෝෂය ලැබීම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
Ciasto piekarz

3
විස්තර කර ඇති පරිදි වැඩ කිරීමට දේවල් සඳහා ඔබ ග්‍රැෆ්විස් ස්ථාපනය කළ යුතු බව සඳහන් කිරීමට මම මෙය යාවත්කාලීන කළෙමි. උබුන්ටු වල මෙය සාධාරණයි sudo apt-get install graphviz.
මිලිස්නර්

2
මෙහි ස්ථාපනය කිරීම සඳහා සුළු වැඩ ප්‍රමාණයක් අවශ්‍ය වේ. 1. පයිප්ප හරහා ස්ථාපනය කරන්න, 2. exe හරහා GraphViz ස්ථාපනය කරන්න 3. GraphViz නාමාවලියට මාර්ග විචල්‍යයන් සකසන්න 4. අනෙක් සියලුම දෝෂ නිවැරදි කරන්නේ කෙසේදැයි සොයා බලන්න. 5. එය png ගොනුව සුරකින ස්ථානය කුමක්දැයි සොයා බලන්න?
මාර්ෂ්

200

පැතිකඩ භාවිතා කිරීම ප්‍රධාන ත්‍රෙඩ් එකේ (පෙරනිමියෙන්) පමණක් ක්‍රියාත්මක වන බව පෙන්වා දීම වටී, ඔබ ඒවා භාවිතා කරන්නේ නම් වෙනත් නූල් වලින් ඔබට කිසිදු තොරතුරක් නොලැබෙනු ඇත. පැතිකඩ ලේඛනයේ එය සම්පූර්ණයෙන්ම සඳහන් කර නොමැති බැවින් මෙය ටිකක් ගොචා විය හැකිය .

ඔබට නූල් පැතිකඩ කිරීමට අවශ්‍ය නම්, ඔබට ලේඛනයේ 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සම්මත පන්තිය වෙනුවට එම පන්තිය භාවිතා කරන්න . එය ඔබට වඩාත් නම්‍යශීලී බවක් ලබා දෙනු ඇත, නමුත් එය වටී යැයි මට විශ්වාස නැත, විශේෂයෙන් ඔබ තෙවන පාර්ශවීය කේතයක් භාවිතා කරන්නේ නම් එය ඔබේ පන්තිය භාවිතා නොකරයි.


1
ප්‍රලේඛනය තුළ runcall පිළිබඳ කිසිදු සඳහනක් මා දකින්නේ නැත. CProfile.py දෙස බැලීමෙන්, ඔබ නූල් භාවිතා කරන්නේ ඇයිදැයි මට විශ්වාස නැත. Thread.run ශ්‍රිතය හෝ ස්වයං තර්කයක් ලෙස. වෙනත් නූල් ධාවනය කිරීමේ ක්‍රමයක් පිළිබඳ සඳහනක් මෙහි දැකීමට මම බලාපොරොත්තු වෙමි .
පයිප්බ්‍රොස්

එය ප්‍රලේඛනයේ නැත, නමුත් එය මොඩියුලයේ ඇත. Hg.python.org/cpython/file/6bf07db23445/Lib/cProfile.py#l140 බලන්න . එමඟින් ඔබට විශේෂිත ශ්‍රිත ඇමතුමක් පැතිකඩ කිරීමට ඉඩ ලබා දෙන අතර, අපගේ නඩුවේදී අපට අවශ්‍ය වන්නේ ත්‍රෙඩ් එකේ targetක්‍රියාකාරිත්වය පැතිකඩ කිරීමයි , එය threading.Thread.run()ඇමතුම ක්‍රියාත්මක කරයි. නමුත් මම පිළිතුරෙහි සඳහන් කළ පරිදි, ඕනෑම තෙවන පාර්ශවීය කේතයක් එය භාවිතා නොකරන බැවින් ඒ වෙනුවට භාවිතා කිරීම සඳහා නූල් උප කාණ්ඩයට ගැනීම වටින්නේ නැත threading.setprofile().
ජෝ ෂෝ

9
Profiler.enable () සහ profiler.disable () සමඟ කේතය එතීමද හොඳින් ක්‍රියාත්මක වන බව පෙනේ. එය මූලිකවම runcall කරන අතර එය කිසිදු තර්කයක් හෝ ඒ හා සමාන දේවල් බලාත්මක නොකරයි.
පයිප්බ්‍රොස්

1
මම මගේම stackoverflow.com/questions/10748118/… ddaa.net/blog/python/lsprof-calltree සමඟ ඒකාබද්ධ කළ අතර එය කාරුණිකව ක්‍රියා කරයි;! -)
Dima Tisnek

1
ජෝ, පයිතන් 3.4 හි පැතිකඩ අසින්සියෝ සමඟ ක්‍රියා කරන්නේ කෙසේදැයි ඔබ දන්නවාද?
නික් චම්මාස්

149

පයිතන් විකිය යනු සම්පත් පැතිකඩ සඳහා කදිම පිටුවකි: http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code

python docs මෙන්ම: 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

ධාවනය:

 pycallgraph mine.py args

දැක්ම:

 gimp pycallgraph.png

ඔබට png ගොනුව බැලීමට කැමති ඕනෑම දෙයක් භාවිතා කළ හැකිය, මම gimp භාවිතා
කළෙමි අවාසනාවකට මට බොහෝ විට ලැබේ

dot: කයිරෝ-රෙන්ඩරර් බිට්මැප් සඳහා ප්‍රස්ථාරය ඉතා විශාලය. ගැලපෙන පරිදි 0.257079 කින් පරිමාණය කිරීම

එමඟින් මගේ රූප අසාමාන්‍ය ලෙස කුඩා කරයි. එබැවින් මම සාමාන්‍යයෙන් svg ගොනු සාදමි:

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

PS> ග්‍රැෆ්විස් ස්ථාපනය කිරීමට වග බලා ගන්න (එය තිත් වැඩසටහන සපයයි):

pip install graphviz

Gramaxy / odquodlibetor හරහා gprof2dot භාවිතා කරමින් විකල්ප ප්‍රස්ථාර:

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

12
gprof2dot හට එම ප්‍රස්ථාර ද කළ හැකිය. මම හිතන්නේ ප්‍රතිදානය ටිකක් හොඳයි ( උදාහරණ ).
මැක්සි

2
ඔබ OSX භාවිතා කරන්නේ නම් graphviz ද අවශ්‍ය වේ
වෛභව් මිශ්‍ර

134

Answer මෙම පිළිතුර පිළිබඳ මැක්සිගේ ප්‍රකාශය මට එයට ප්‍රමාණවත් පිළිතුරක් ලැබිය යුතු යැයි සිතීමට ප්‍රමාණවත් විය: මා සතුව දැනටමත් cProfile- ජනනය කරන ලද .pstats ලිපිගොනු ඇති අතර පයිකාල්ග්‍රැෆ් සමඟ නැවත ධාවනය කිරීමට මට අවශ්‍ය නොවීය, එබැවින් මම gprof2dot භාවිතා කළෙමි . 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

සහ බ්ලාම්!

එය තිතක් භාවිතා කරයි (පයිකාල්ග්‍රාෆ් භාවිතා කරන එකම දෙය) එබැවින් ප්‍රතිදානය සමාන වේ. Gprof2dot හි අඩු තොරතුරු අහිමි වුවද මට හැඟේ:

gprof2dot උදාහරණ ප්‍රතිදානය


1
හොඳ ප්‍රවේශයක්, ඔබට ක්‍රෝම් යනාදී SVG නැරඹිය හැකි අතර එය ඉහළට / පහළට පරිමාණය කළ හැකිය. තෙවන පේළියේ pwdඅක්ෂර වින්‍යාසය ඇත, විය යුත්තේ: ln -s /gprof2dot/gprof2dot.py $ HOME / bin (හෝ ln -s $ PWD / gprof2dot / gprof2dot.py ~ / bin බොහෝ ෂෙල් වෙඩි භාවිතා කරන්න - සොහොන් උච්චාරණය පළමු හැඩතල ගැන්වීමේදී ගනු ලැබේ පිටපත).
රිච්වෙල්

2
අහ්, හොඳ කරුණක්. lnසෑම විටම පාහේ මට තර්ක-ඇණවුම වැරදිය.
quodlibetor

7
උපක්‍රමය නම් ln සහ cp එකම තර්ක අනුපිළිවෙලක් ඇති බව මතක තබා ගැනීමයි - එය 'file1 හෝ file2 වෙත file1 පිටපත් කිරීම, නමුත් සබැඳියක් සෑදීම' ලෙස
සිතන්න

එය අර්ථවත් කරයි, මාන්පේජ් හි "TARGET" භාවිතය මා විසි කරයි.
quodlibetor

කරුණාකර, ඔබ වටකුරු කොන් ලබාගත්තේ කෙසේද? එය කියවීමේ හැකියාව වැඩි දියුණු කරන බව මට හැඟේ. පෙට්ටි වටා බොහෝ දාර තිබියදී සිසිල් නොවන කැත තියුණු කොනක් මට ලැබේ.
Hibou57

82

මෙම මාතෘකාව පිළිබඳ පර්යේෂණ කරන විට මම ස්නේක්විස් නම් පහසු මෙවලමක් වෙතට දිව ගියෙමි . SnakeViz යනු වෙබ් පාදක පැතිකඩ දෘශ්‍යකරණ මෙවලමකි. ස්ථාපනය කිරීම සහ භාවිතා කිරීම ඉතා පහසුය. මම එය භාවිතා කරන සුපුරුදු ක්‍රමය %prunනම් ස්නැක්විස් හි සංඛ්‍යාන ගොනුවක් ජනනය කර විශ්ලේෂණය කිරීමයි.

පහත දැක්වෙන පරිදි භාවිතා කරන ප්‍රධාන වීස් තාක්‍ෂණය සන්බර්ස්ට් ප්‍රස්ථාරය වන අතර, එහි ක්‍රියාකාරී ඇමතුම් වල ධූරාවලිය චාප ස්ථර ලෙස සකසා ඇති අතර ඒවායේ තොරතුරු කෝණික පළලෙහි කේතනය කර ඇත.

හොඳම දේ නම් ඔබට ප්‍රස්ථාරය සමඟ අන්තර් ක්‍රියා කළ හැකිය. නිදසුනක් ලෙස, විශාලනය කිරීම සඳහා චාපයක් මත ක්ලික් කළ හැකි අතර, වැඩි විස්තර පෙන්වීම සඳහා චාපය සහ එහි පැවත එන්නන් නව හිරු රශ්මියක් ලෙස විශාල වනු ඇත.

රූප විස්තරය මෙහි ඇතුළත් කරන්න


2
CodeCabbie හි පිළිතුරට (කෙටි) ස්ථාපන උපදෙස් ඇතුළත් වන අතර SnakeViz භාවිතා කරන්නේ කෙසේද යන්න (පහසුවෙන්) පෙන්වයි.
ඔරෙන් මිල්මන්

ජුපිටර් නෝට්බුක් හි පයිතන් සඳහා පැතිකඩ භාවිතා කරන්නේ කෙසේදැයි මම IMHO හොඳ මාර්ගෝපදේශය කියවා ඇත්තෙමි: towardsdatascience.com/speed-up-jupyter-notebooks-20716cbe2025
ඇලෙක්සි

77

සෑම විටම යන්නේ කොතැනදැයි සොයා ගැනීමට සරලම හා ඉක්මන්ම ක්‍රමය.

1. pip install snakeviz

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

3. snakeviz temp.dat

බ්‍රව්සරයක පයි ප්‍රස්ථාරයක් අඳින්න. විශාලතම කොටස වන්නේ ගැටළු ක්‍රියාකාරිත්වයයි. හරිම සරලයි.


1
මෙය ඉතා ප්‍රයෝජනවත් විය. ඔබට ස්තුතියි.
jippyjoe4

මෙවලම සහ උදාහරණ ප්‍රතිදානය වෙත සබැඳියක් සපයන සැක්ස්ලියුගේ පිළිතුර ද බලන්න .
මෙලෙබියස්

55

මම හිතන්නේ 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

ප්රතිඵලය:

ප්‍රති .ලයේ තිර රුව


9
මැක් පරිශීලකයන් ස්ථාපනය brew install qcachegrindඑක් එක් හා substitude kcachegrind සමග qcachegrind සාර්ථක පැතිකඩ සඳහා විස්තරයක්.
කෙවින් කැට්ස්කේ

එය ක්‍රියාත්මක කිරීම සඳහා මට මෙය කිරීමට සිදු විය:export QT_X11_NO_MITSHM=1
යොනාටන් සිම්සන්

41

GUI cProfile ඩම්ප් නරඹන්නා RunSnakeRun ද සඳහන් කිරීම වටී . එය ඔබට වර්ග කිරීමට සහ තෝරා ගැනීමට ඉඩ සලසයි, එමඟින් වැඩසටහනේ අදාළ කොටස් විශාලනය කරයි. පින්තූරයේ ඇති සෘජුකෝණාස්රා වල ප්‍රමාණයන් ගතවන කාලයට සමානුපාතික වේ. ඔබ සෘජුකෝණාස්රයක් හරහා මූසිකය තැබුවහොත් එය වගුවේ සහ සිතියමේ සෑම තැනකම එම ඇමතුම ඉස්මතු කරයි. ඔබ සෘජුකෝණාස්රයක් මත දෙවරක් ක්ලික් කළ විට එය එම කොටස විශාලනය කරයි. එම කොටස අමතන්නේ කවුද සහ එම කොටස අමතන්නේ කුමක්ද යන්න එයින් පෙන්වනු ඇත.

විස්තරාත්මක තොරතුරු ඉතා ප්රයෝජනවත් වේ. ඔබ බිල්ට් පුස්තකාල ඇමතුම් සමඟ කටයුතු කරන විට ප්‍රයෝජනවත් විය හැකි එම බිට් කේතය එය ඔබට පෙන්වයි. කේතය සොයාගත යුත්තේ කුමන ගොනුව සහ කුමන රේඛාවද යන්න එය ඔබට කියයි.

OP 'පැතිකඩ' යැයි පැවසූ නමුත් ඔහු අදහස් කළේ 'වේලාව' යන්නයි. පැතිකඩ කරන විට වැඩසටහන් මන්දගාමී වන බව මතක තබා ගන්න.

රූප විස්තරය මෙහි ඇතුළත් කරන්න


37

මම මෑතකදී පයිතන් ධාවන කාලය දෘශ්‍යකරණය කිරීම සහ පැතිකඩ ආනයනය කිරීම සඳහා ටූනා නිර්මාණය කළෙමි ; මෙය මෙහි ප්‍රයෝජනවත් විය හැකිය.

රූප විස්තරය මෙහි ඇතුළත් කරන්න

සමඟ ස්ථාපනය කරන්න

pip install tuna

ධාවන කාල පැතිකඩක් සාදන්න

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

හෝ ආයාත පැතිකඩක් (පයිතන් 3.7+ අවශ්‍යයි)

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

ඉන්පසු ගොනුවේ ටූනා ධාවනය කරන්න

tuna program.prof

34

pprofile

line_profiler(දැනටමත් මෙහි ඉදිරිපත් කර ඇත) ද දේවානුභාවයෙන් pprofile, එය විස්තර කර ඇත්තේ:

රේඛීය-කැටිතිතාව, නූල්-දැනුවත් නිර්ණායක සහ සංඛ්‍යාන පිරිසිදු-පයිතන් පැතිකඩ

එය line_profilerපිරිසිදු පයිතන් මෙන් රේඛීය-කැටිති බව සපයයි, එය ස්වාධීන විධානයක් හෝ මොඩියුලයක් ලෙස භාවිතා කළ හැකි අතර පහසුවෙන් විශ්ලේෂණය කළ හැකි ඇමතුම් ග්‍රෑන්ඩ් හැඩතල ගොනු පවා ජනනය කළ හැකිය [k|q]cachegrind.

vprof

පයිතන් පැකේජයක් ලෙස විස්තර කර ඇති vprof ද ඇත:

[...] ධාවන කාලය සහ මතක භාවිතය වැනි විවිධ පයිතන් වැඩසටහන් ලක්ෂණ සඳහා පොහොසත් හා අන්තර්ක්‍රියාකාරී දෘශ්‍යකරණයන් සැපයීම.

තාපය සිතියම


33

ලස්සන පැතිකඩ මොඩියුලයක් වන්නේ line_profiler (kernprof.py ස්ක්‍රිප්ට් භාවිතයෙන් හැඳින්වේ). එය මෙතැනින් බාගත හැකිය .

මගේ අවබෝධය නම් cProfile ලබා දෙන්නේ එක් එක් ශ්‍රිතය සඳහා ගත කළ මුළු කාලය පිළිබඳ තොරතුරු පමණි. එබැවින් කේතයේ තනි රේඛා කාලානුරූපී නොවේ. බොහෝ විට එක් පේළියකට බොහෝ කාලයක් ගත වන බැවින් මෙය විද්‍යාත්මක පරිගණනයේ ගැටළුවක් වේ. එසේම, මට මතක ඇති පරිදි, මම ප්‍රොම්පයිල් විසින් අංකපී.ඩොට් යැයි කියමින් ගත කළ කාලය අල්ලා ගත්තේ නැත.


16

හොඳ පිළිතුරු රාශියක් ඇතත් ඒවා විධාන රේඛාව හෝ බාහිර වැඩසටහනක් පැතිකඩ සහ / හෝ ප්‍රති .ල වර්ග කිරීම සඳහා භාවිතා කරයි.

විධාන රේඛාව ස්පර්ශ නොකර හෝ කිසිවක් ස්ථාපනය නොකර මගේ IDE (eclipse-PyDev) හි භාවිතා කළ හැකි ක්‍රමයක් මට මග හැරුණි. ඉතින් මෙන්න එයයි.

විධාන රේඛාවකින් තොරව පැතිකඩ

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)

වැඩි විස්තර සඳහා ලියකියවිලි හෝ වෙනත් පිළිතුරු බලන්න .


උදාහරණයක් ලෙස, පැතිකඩ {සිතියම} හෝ {xxx print මුද්‍රණය කරයි. F xxx method ක්‍රමය හඳුන්වන්නේ කුමන ගොනුවෙන්ද? මගේ පැතිකඩ මුද්‍රණ {zlib.Compress 'වස්තූන්ගේ' සම්පීඩනය 'බොහෝ වේලාවක් ගත වේ, නමුත් මම කිසිදු zlib භාවිතා නොකරමි, එබැවින් සමහර ඇමතුම් අංකිත ශ්‍රිතය එය භාවිතා කරනු ඇතැයි මම සිතමි. හරියටම ගොනුව සහ රේඛාව කුමක්දැයි මා දැන ගන්නේ කෙසේද?
මචෙන්

මෙය සාධාරණ නැත ... මෙම ශ්‍රේෂ් answer පිළිතුරට එතරම් ඉහළ නැගීම් කිහිපයක් ඇත්තේ මන්දැයි මම නොදනිමි ... අනෙක් ඉහළ පෙළේ ඒවාට වඩා බොහෝ ප්‍රයෝජනවත්: /
බීපීඑල්

12

බහු-නූල් කේතය අපේක්ෂිත පරිදි ක්‍රියාත්මක නොවීම පිළිබඳ ජෝ ෂෝගේ පිළිතුර අනුගමනය කිරීමෙන් පසුව, runcallcProfile හි ක්‍රමය හුදෙක්ම කරන self.enable()බවත් self.disable(), පැතිකඩ සහිත ක්‍රියාකාරී ඇමතුම වටා ඇමතුම් ලබා ගන්නා බවත් මම තේරුම් ගතිමි , එබැවින් ඔබට එය තනිවම කළ හැකි අතර ඔබට අවශ්‍ය ඕනෑම කේතයක් තිබිය හැකිය. පවතින කේතය සමඟ අවම ඇඟිලි ගැසීම්.


3
විශිෂ්ට ඉඟිය! cprofile.pyමූලාශ්‍ර කේතය ඉක්මණින් බැලීමෙන් හෙළි වන්නේ එය හරියටම කරන්නේ කුමක්ද යන්නයි runcall(). වඩාත් නිශ්චිත වීම, සමග නරඹන්න උදාහරණයක් නිර්මාණය පසු prof = cprofile.Profile(), වහාම අමතන්න prof.disable(), ඉන්පසු පමණක් එකතු prof.enable()සහ prof.disable()ඔබ profiled අවශ්ය කේත කොටස වටා ඇමතුම්.
මාර්ටිනෝ

මෙය ඉතා ප්‍රයෝජනවත් වේ, නමුත් ඇත්ත වශයෙන්ම සක්‍රීය හා අක්‍රීය අතර ඇති කේතය පැතිකඩ කර නැති බව පෙනේ - එය අමතන්නේ ශ්‍රිත පමණි. මට මේ අයිතිය තිබේද? Print_stats () හි ඇති ඕනෑම සංඛ්‍යාවක් වෙත ගණනය කිරීම සඳහා මට එම කේතය ශ්‍රිත ඇමතුමකින් ඔතා තැබිය යුතුය.
බොබ් ස්ටයින්

10

වර්ටාල්ගේ ප්‍රභවයේ පැතිකඩ (විශේෂිත ක්‍රම / කාර්යයන් සඳහා පවා) ඉතා පහසු කළ හැකි ඉතා ප්‍රයෝජනවත් පන්තියක් සහ සැරසිලි කරුවෙකු සිටී. එවිට ප්‍රතිදානය KCacheGrind හි ඉතා සුවපහසු ලෙස දැකිය හැකිය.


1
මෙම මැණිකට ස්තූතියි. FYI: මෙය ඕනෑම කේතයක් සහිත ස්වාධීන මොඩියුලයක් ලෙස භාවිතා කළ හැකිය, Virtaal කේත පදනම අවශ්‍ය නොවේ. ගොනුව profiling.py වෙත සුරකින්න සහ profile_func () ආයාත කරන්න. ඔබට පැතිකඩ සහ වයල අවශ්‍ය ඕනෑම කාර්යයක් සඳහා සැරසිලි කරුවෙකු ලෙස @profile_func () භාවිතා කරන්න. :)
අම්ජිත්

9

cProfile ඉක්මන් පැතිකඩ සඳහා විශිෂ්ටයි නමුත් බොහෝ විට එය දෝෂ සහිතව අවසන් විය. පරිසරය සහ විචල්‍යයන් නිවැරදිව ආරම්භ කිරීමෙන් runctx ක්‍රියාකාරීත්වය මෙම ගැටළුව විසඳයි, එය යමෙකුට ප්‍රයෝජනවත් වේ යැයි සිතමු:

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

7

ඔබට සමුච්චිත පැතිකඩක් සෑදීමට අවශ්‍ය නම්, එයින් අදහස් වන්නේ ශ්‍රිතය එකවර කිහිප වතාවක් ධාවනය කර ප්‍රති .ලවල එකතුව නැරඹීමයි.

ඔබට මෙම cumulative_profilerසැරසිලි යන්ත්‍රය භාවිතා කළ හැකිය :

එය python> = 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():
    ...

7

ටර්මිනල්-පමණක් (සහ සරලම) විසඳුම, එම විසිතුරු යූඅයි ස්ථාපනය කිරීමට හෝ ක්‍රියාත්මක කිරීමට අපොහොසත් වුවහොත්: සම්පූර්ණයෙන්ම
නොසලකා හැර cProfileඑය ප්‍රතිස්ථාපනය කරන්න, එය pyinstrumentක්‍රියාත්මක වූ වහාම ඇමතුම් ගස එකතු කර ප්‍රදර්ශනය කරනු ඇත.

ස්ථාපනය කරන්න:

$ pip install pyinstrument

පැතිකඩ සහ දර්ශන ප්‍රති result ලය:

$ python -m pyinstrument ./prog.py

Python2 සහ 3 සමඟ ක්‍රියා කරයි.

[සංස්කරණය කරන්න] කේතයේ කොටසක් පමණක් පැතිකඩ කිරීම සඳහා API හි ප්‍රලේඛනය මෙහි සොයාගත හැකිය .


6

මගේ ක්‍රමය yappi ( https://github.com/sumerc/yappi ) භාවිතා කිරීමයි . RPC සේවාදායකයක් සමඟ ඒකාබද්ධව එය විශේෂයෙන් ප්‍රයෝජනවත් වේ (නිදොස්කරණය සඳහා පවා) ඔබ පැතිකඩ තොරතුරු ආරම්භ කිරීමට, නැවැත්වීමට සහ මුද්‍රණය කිරීමට ක්‍රමයක් ලියාපදිංචි කරයි, උදා:

@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()

එය ස්ටූපෙන්ඩස් යාපි ලෙස නම් කළ යුතු නොවේද?
තෙරල්ස්ටූබට්

අවාසනාවට ඉහත කේතය ක්‍රියාත්මක වන්නේ 0.62 අනුවාදය සමඟ පමණි. මෙහි ඇති ප්‍රභවයන් 0.62 කින් මොඩියුලය සම්පාදනය කළ යුතුය: github.com/nirs/yappi/releases හෝ භාවිතා කිරීම සඳහා ජනේල සඳහා මා විසින් සාදන ලද රෙපෝ ෆෝක්
ගිර්ගිට් මහතා

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)}) (හරි, මම අත්හැර දැමූ අදහස් දැක්වීමට කේත වාරණයක් ඇතුළු කිරීමට දෙවරක් උත්සාහ කිරීමෙන් පසුව මෙය ක්‍රමලේඛන-නැඹුරු ප්‍රශ්න හා පිළිතුරු වෙබ් අඩවියකට විශ්වාස කළ නොහැකි තරම් දුෂ්කර ය. )
ගිර්ගිට් මහතා

4

Python හි පැතිකඩ හැසිරවීමට නව මෙවලමක් වන්නේ PyVmMonitor: http://www.pyvmmonitor.com/

එය වැනි සුවිශේෂී ලක්ෂණ ඇත

  • ධාවනය වන (CPython) වැඩසටහනකට පැතිකඩ අමුණන්න
  • යාපි ඒකාබද්ධ කිරීම සමඟ ඉල්ලුම පැතිකඩ මත
  • වෙනත් යන්ත්‍රයක පැතිකඩ
  • බහුවිධ ක්‍රියාවලි සඳහා සහය දක්වයි (බහු සැකසුම්, ජැන්ගෝ ...)
  • සජීවී නියැදි / CPU දර්ශනය (කාල පරාසය තේරීම සමඟ)
  • CProfile / පැතිකඩ ඒකාබද්ධ කිරීම හරහා නිර්ණායක පැතිකඩ
  • පවතින PStats ප්‍රති .ල විශ්ලේෂණය කරන්න
  • DOT ගොනු විවෘත කරන්න
  • ක්‍රමලේඛ API ප්‍රවේශය
  • ක්‍රමවේදය හෝ රේඛාව අනුව කණ්ඩායම් සාම්පල
  • පයිඩෙව් ඒකාබද්ධ කිරීම
  • PyCharm ඒකාබද්ධ කිරීම

සටහන: එය වාණිජ, නමුත් විවෘත මූලාශ්‍ර සඳහා නොමිලේ.


4

gprof2dot_magic

gprof2dotඕනෑම පයිතන් ප්‍රකාශයක් ජුපිටර්ලැබ් හෝ ජුපිටර් නෝට්බුක් හි ඩොට් ප්‍රස්ථාරයක් ලෙස පැතිකඩ කිරීම සඳහා මැජික් ශ්‍රිතය .

රූප විස්තරය මෙහි ඇතුළත් කරන්න

GitHub repo: https://github.com/mattijn/gprof2dot_magic

ස්ථාපන

ඔබ පයිතන් පැකේජය ඇති බවට වග බලා ගන්න gprof2dot_magic.

pip install gprof2dot_magic

එහි පරායත්තතාවයන් gprof2dotgraphvizස්ථාපනය කෙරේ

භාවිතය

මැජික් ශ්‍රිතය සක්‍රීය කිරීම සඳහා, පළමුව gprof2dot_magicමොඩියුලය පටවන්න

%load_ext gprof2dot_magic

ඉන්පසු ඕනෑම රේඛීය ප්‍රකාශයක් ඩොට් ප්‍රස්ථාරයක් ලෙස පැතිකඩ කරන්න:

%gprof2dot print('hello world')

රූප විස්තරය මෙහි ඇතුළත් කරන්න


3

පයිතන් පිටපත කරන්නේ කුමක්දැයි දැන ගැනීමට කවදා හෝ අවශ්‍යද? පරීක්ෂණ කවචය ඇතුළත් කරන්න. පරීක්‍ෂා කිරීමේ ෂෙල් මඟින් ධාවනය වන ස්ක්‍රිප්ටයට බාධා නොකර ගෝලීය මුද්‍රණය / වෙනස් කිරීම සහ ක්‍රියාකාරකම් ක්‍රියාත්මක කිරීමට ඉඩ ලබා දේ. දැන් ස්වයංක්‍රීය-සම්පූර්ණ සහ විධාන ඉතිහාසය සමඟ (ලිනක්ස් මත පමණි).

පරීක්ෂාව ෂෙල් යනු පීඩීබී විලාසිතාවේ නිදොස් කිරීමක් නොවේ.

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

ඔබට එය භාවිතා කළ හැකිය (සහ ඔබේ අත් ඔරලෝසුව).


3

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 ද බලන්න .


3

එය පැතිකඩෙන් ඔබ දැකීමට අවශ්‍ය දේ මත රඳා පවතී. සරල කාල මිනුම් (bash) මගින් ලබා දිය හැකිය.

time python python_prog.py

'/ Usr / bin / time' ට පවා '--verbose' ධජය භාවිතා කරමින් සවිස්තරාත්මක ප්‍රමිතික ප්‍රතිදානය කළ හැකිය.

එක් එක් ශ්‍රිතය මඟින් ලබා දී ඇති කාල ප්‍රමිතික පරීක්ෂා කිරීම සහ කාර්යයන් සඳහා කොපමණ කාලයක් වැය කරනවාද යන්න වඩා හොඳින් අවබෝධ කර ගැනීම සඳහා, ඔබට පයිතන් තුළ ඇති ඉන්බිල්ට් සී ප්‍රොෆයිල් භාවිතා කළ හැකිය.

කාර්ය සාධනය වැනි වඩාත් සවිස්තරාත්මක ප්‍රමිතික වෙත යාම, කාලය එකම මෙට්‍රික් නොවේ. මතකය, නූල් ආදිය ගැන ඔබට කරදර විය හැකිය.
පැතිකඩ විකල්ප:
1. රේඛීය_ රේඛා මඟින් කාල ප්‍රමිතික සොයා ගැනීමට පොදුවේ භාවිතා කරන තවත් පැතිකඩකි .
2. memory_profiler යනු මතක භාවිතය පැතිකඩ කිරීම සඳහා වූ මෙවලමකි.
3. ගොඩ (ව්‍යාපෘති ගප්පි වෙතින්) ගොඩවල ඇති වස්තූන් භාවිතා කරන ආකාරය පිළිබඳ පැතිකඩ.

මේවා මම භාවිතා කිරීමට නැඹුරු වන පොදු ඒවා වේ. නමුත් ඔබට තවත් තොරතුරු සොයා ගැනීමට අවශ්‍ය නම්, මෙම පොත කියවීමට උත්සාහ කරන්න එය කාර්ය සාධනය මනසින් ආරම්භ කිරීම පිළිබඳ හොඳ පොතකි. ඔබට සයිතන් සහ ජේඅයිටී (යන්තම්) සම්පාදනය කරන ලද පයිතන් භාවිතා කිරීම පිළිබඳ උසස් මාතෘකා වෙත ගමන් කළ හැකිය.


2

වැනි සංඛ්යාන profiler සමග ඔස්ටින් , කිසිදු උපකරණ ඔබ සමඟ හුදෙක් Python අයදුම් පිටතට දත්ත ලක්කිරීම ලබා ගත හැකි බව එහි අර්ථය, අවශ්ය වේ

austin python3 my_script.py

අමු නිමැවුම එතරම් ප්‍රයෝජනවත් නොවේ, නමුත් එම දත්තවල දැවෙන ප්‍රස්ථාර නිරූපණයක් ලබා ගැනීම සඳහා ඔබට එය flamegraph.pl වෙත නළා ගත හැකි අතර එමඟින් කාලය (තථ්‍ය කාලයේ මයික්‍රෝ තත්පර වලින් මනිනු ලැබේ) බිඳ වැටෙනු ඇත.

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

2

IPython නෝට්බුක් එකක ඉක්මන් පැතිකඩ සංඛ්‍යාන ලබා ගැනීම සඳහා. කෙනෙකුට line_profiler සහ memory_profiler කෙලින්ම ඔවුන්ගේ සටහන් පොත් වලට ඇතුළත් කළ හැකිය .

තවත් ප්‍රයෝජනවත් පැකේජයක් වන්නේ පිම්ප්ලර් ය . එය පංති, වස්තූන්, කාර්යයන්, මතක කාන්දුවීම් ආදිය නිරීක්ෂණය කළ හැකි ප්‍රබල පැතිකඩ පැකේජයකි. පහත උදාහරණ, ලියකියවිලි අමුණා ඇත.

එය ලබා ගන්න!

!pip install line_profiler
!pip install memory_profiler
!pip install pympler

එය පටවන්න!

%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 times: පද්ධති මට්ටමේ ක්‍රියාත්මක කිරීමේ කාලය
  • එකතුව: 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 -s cumulative 'Code to profile' 

ලබා දෙයි:

  • ශ්‍රිත ඇමතුම් ගණන (ncalls)
  • එක් ශ්‍රිත ඇමතුමකට ඇතුළත් කිරීම් ඇත (වෙනස්)
  • ඇමතුමකට ගතවන කාලය (percall)
  • එම ශ්‍රිත ඇමතුම දක්වා කාලය ගතවී ඇත (සමුපකාරය)
  • යනාදිය නමින් හැඳින්වෙන ෆන්ක් / මොඩියුලයේ නම ...

සමුච්චිත පැතිකඩ


% මතක

%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()

ලබා දෙයි:

  • රේඛීය වශයෙන් සංඛ්‍යාන

ලයින් ප්‍රොෆයිල්


sys.getsizeof

sys.getsizeof('code to profile')
# 64 bytes

වස්තුවක ප්‍රමාණය බයිට් වලින් ලබා දෙයි.


pizepler වෙතින් asizeof ()

from pympler import asizeof
obj = [1,2,("hey","ha"),3]
print(asizeof.asizeof(obj,stats=4))

සමහර පයිතන් වස්තූන් කොපමණ මතකයක් පරිභෝජනය කරනවාද යන්න සොයා බැලීමට pympler.asizeof භාවිතා කළ හැකිය. Sys.getsizeof ට ප්‍රතිවිරුද්ධව, asizeof ප්‍රමාණයේ වස්තූන් පුනරාවර්තනය වේ

pympler.asizeof


pimpler වෙතින් ට්රැකර්

from pympler import tracker
tr = tracker.SummaryTracker()
def fun():
  li = [1,2,3]
  di = {"ha":"haha","duh":"Umm"}
fun()
tr.print_diff()

ශ්‍රිතයක ආයු කාලය නිරීක්ෂණය කරයි.

ට්රැකර් ප්රතිදානය

Pympler පැකේජය පැතිකඩ කේතයට ඉහළ උපයෝගීතා කාර්යයන් විශාල ගණනකින් සමන්විත වේ. මේ සියල්ල මෙහි ආවරණය කළ නොහැක. වාචික පැතිකඩ ක්‍රියාත්මක කිරීම සඳහා අමුණා ඇති ප්‍රලේඛනය බලන්න.

Pympler doc


1

සංඛ්‍යානමය පැතිකඩක් ද ඇත statprof . එය නියැදි පැතිකඩකි, එබැවින් එය ඔබගේ කේතයට අවම පොදු කාර්යයක් එකතු කරන අතර රේඛා පාදක (ක්‍රියාකාරීත්වය මත පමණක් නොව) වේලාවන් ලබා දෙයි. ක්‍රීඩා වැනි මෘදු තත්‍ය කාලීන යෙදුම් සඳහා එය වඩාත් ගැලපේ, නමුත් cProfile වලට වඩා අඩු නිරවද්‍යතාවයක් තිබිය හැකිය.

පයිපී හි අනුවාදය ටිකක් පැරණි බැවින් git ගබඩාවpip නියම කිරීමෙන් එය ස්ථාපනය කළ හැකිය :

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

ඔබට එය මේ ආකාරයෙන් ධාවනය කළ හැකිය:

import statprof

with statprof.profile():
    my_questionable_function()

Https://stackoverflow.com/a/10333592/320036 ද බලන්න


1

මම දැන් මගේම පැතිකඩක් සකස් කර ඇත්තේ 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]

0

මම සේවාදායකයේ root නොවන විට, මම lsprofcalltree.py භාවිතා කර මගේ වැඩසටහන මේ ආකාරයට ක්‍රියාත්මක කරමි:

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

එවිට මම වගේ, ඕනෑම callgrind-අනුකූල මෘදුකාංග සමඟ වාර්තාව විවෘත කළ හැක qcachegrind

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.