பைத்தான் எனும் கணினிமொழியில் மாறிகளை அதிக கண்காணிப்புடன் பிழைத்திருத்தம் செய்திடும்போது நமக்கு உதவுவதற்காக ஒரு எளிய ஆனால் சக்தி வாய்ந்த கருவியாக Watchpointsஎன்பது அமைந்துள்ளது
பைத்தான் எனும் கணினிமொழியில் எழுதப்பட்ட நிரலாக்கங்களை பிழைதிருத்தம் செய்திடும்போது, அக்குறிமுறைவரிகளின் மாறிகள் ஏராளமான வகையில் மாறியமைவதை எதிர்கொள்ளும் சூழலிற்கு நாம் தள்ளப்படுவதை அடிக்கடி காண்போம். எந்தவொரு மேம்பட்ட கருவிகளும் இல்லாமல், மாறிகள் மாறிடும் என நாம் எதிர்பார்க்கும்போது அவற்றை நமக்கு அறிவிப்பதற்காக அச்சிடப்பட்ட அறிக்கைகளைப் பயன்படுத்து வதற்கான வாய்ப்புகூட நமக்கு உள்ளது. இருப்பினும், அது ஒருமிகவும் பயனற்ற வழிமுறையாகும், ஏனெனில் மாறிகள் பல்வேறு இடங்களில் மாறக்கூடும், மேலும் அவற்றை ஒரு முனைமத்தில் தொடர்ந்து அச்சிடுமாறு செய்வது ஒரேசத்தமாக இருக்கும், அதே நேரத்தில் அவற்றை ஒரு பதிவு கோப்பில் அச்சிடுவது திறனற்றதாகிவிடும். இது ஒரு பொதுவான பிரச்சினையாகும், இவ்வாறான பிரச்சினையை சரிசெய்வதற்காக தற்போது மாறிகள் மாறுவதை கண்காணிப்பு செய்வதற்காக நமக்கு உதவ ஒரு எளிய ஆனால் சக்திவாய்ந்த கருவியாக Watchpointsஎன்பது உள்ளது: . நினைவகங்களை கண்காணிக்க சி ,சி ++ ஆகியவற்றின் பிழைத்திருத்திகளில் Watchpointsஎனும் கருத்தமைவு பொதுவானதாகும், ஆனால் பைத்தான் எனும் கணினிமொழியில் இதற்கு சமமான கருவிகளின் பற்றாக்குறை உள்ளது. அவ்வாறான பற்றாகுறையான இடைவெளியை இந்த Watchpoints ஆனது இட்டு நிரப்புகின்றன.
Watchpoints ஐ நிறுவுகைசெய்தல்
இந்த Watchpoints ஐப் பயன்படுத்திகொள்வதற்காக , முதலில் பின்வரும் கட்டளைவரியின்வாயிலாக pip எனும் கட்டளையைப் பயன்படுத்தி Watchpoints ஐ நிறுவுகைசெய்திடுக.
$ python3 -m pip install watchpoints
பைத்தானில் Watchpointsஐப் பயன்படுத்துதல்
நாம் கண்காணிக்க விரும்பும் எந்தவொரு மாறிக்கும், அதில் watch எனும்செயலியைப் பயன்படுத்திடுக.
from watchpoints import watch
a = 0
watch(a)
a = 1
மாறிகள் மாறிடும்போது, அதன் மதிப்பு பற்றிய தகவல்கள் stdout க்கு அச்சிடப்படுகின்றன:
====== Watchpoints Triggered ======
Call Stack (most recent call last):
<module> (my_script.py:5):
> a = 1
a:
0
->
1
இத்தகவலில் பின்வருவன அடங்கும்:
மாற்றப்பட்டமாறிகள் தனிவரியாக அமையும்.,
அழைப்பின் அடுக்குகள்.
மாறியின் முந்தைய / தற்போதைய மதிப்பு கள்.
இது மாறியுடன் செயல்படுவது மட்டுமல்லாமல், பொருட்களின் மாற்றங்களுடனும் செயல்படுகிறது:
from watchpoints import watch
a = []
watch(a)
a = {} # Trigger
a[“a”] = 2 # Trigger
aஎனும் மாறியானது மறு ஒதுக்கீடு செய்யப்படும்போது அதில் திரும்பப்பெறுதல் எனும நிகழ்வு தூண்டப்படுகிறது ஆனால் a மாறிக்கு ஒதுக்கப்பட்ட பொருள் மாற்றப்படும் போதும் திரும்பப்பெறுதல் எனும் நிகழ்வு தூண்டப்படுகிறது.
இது இன்னும் சுவாரஸ்யமானது அதாவது, கண்காணித்திடும் நோக்கத்திற்காக இது வரையறுக்கப்படவில்லை . நாம்எங்கு வேண்டுமானாலும் மாறியை(variable) / பொருளைப்( object) பார்க்கலாம், மேலும் நிரலாக்கத்தில் எந்த செயலியை செயல்படுத்தினாலும் callback ஆனது தூண்டப்படுகிறது.
from watchpoints import watch
def func(var):
var[“a”] = 1
a = {}
watch(a)
func(a)
எடுத்துக்காட்டாக, இது குறிமுறைவரிகள் அச்சிடுகிறது:
====== Watchpoints Triggered ======
Call Stack (most recent call last):
<module> (my_script.py:8):
> func(a)
func (my_script.py:4):
> var[“a”] = 1
a:
{}
->
{‘a’: 1}
watch எனும் செயலியை கொண்டு ஒரு மாறியை விட அதிகமாக கண்காணிக்க முடியும். மேலும் இதனைகொண்டு ஒரு அகராதி அல்லது பட்டியலின் பண்புகளையும் ஒரு உறுப்பையும் கண்காணிக்க முடியும்.
rom watchpoints import watch
class MyObj:
def __init__(self):
self.a = 0
obj = MyObj()
d = {“a”: 0}
watch(obj.a, d[“a”]) # Yes you can do this
obj.a = 1 # Trigger
d[“a”] = 1 # Trigger
நமக்கு ஆர்வமுள்ள ஒருசில குறிப்பிட்ட பொருட்களைக் குறைக்க இது உதவும்.
வெளியீட்டின் வடிவமைப்பைப் பற்றி நாம் திருப்தியடையவில்லை எனில், நாம் அதைத் தனிப்பயனாக்கலாம். நம்முடைய சொந்த callback செயலியை வரையறுத்திடுக:
watch(a, callback=my_callback)
# Or set it globally
watch.config(callback=my_callback)
என்றவாறு தூண்டுதலை அழுத்திடும்போது நாம் pdb ஐ கூட கொண்டு வரலாம்:
watch.config(pdb=True)
இது breakpoint()க்கு ஒத்ததாக செயல்படுகின்றது, இது நமக்கு பிழைத்திருத்தி போன்ற அனுபவத்தை அளிக்கின்றது.
ஒவ்வொரு கோப்பிலும் செயலியை பதிவிறக்கம் செய்ய விரும்பவில்லை எனில், நிறுவுகை செயலியைப் பயன்படுத்தி அதை அனைவருக்கும்பயன்படுமாறு உலகளாவியதாக (global) ஆக்கலாம்:
watch.install() # or watch.install(“func_name”) and use it as func_name()
watchpoints ஆனது உள்ளுணர்வுடன் கூடிய மிகச்சிறந்த பயன்பாடாகும் என்பதே இதனை பற்றிய சிறந்த செய்தியாகும்.