நிரல்களில் தொடர்ந்து a, b, age, total என்றெல்லாம் பயன்படுத்துகிறோமே, இவற்றின் நோக்கம்தான் என்ன?
நிரலாக்க மொழியில் அடையாளங்காட்டிகளின் (Identifiers) பங்கு மிக முக்கியமானது. நாம் எழுதிக்கொண்டிருக்கும் நிரலைப் பயன்படுத்த இருப்பவர் ஒரு மாணவர் என்றால், அவரிடமிருந்து தோராயமாக ஐந்து பாடங்களின் மதிப்பெண்களைப் பெற்று, தேவைப்படும் போதெல்லாம் எடுத்துப் பயன்படுத்திக் கொள்ளும் வகையில் அவை கணினியின் மெமரியில் சேமிக்கப்பட்டு (தற்காலிகமாக) இருக்கும்.
ஒரு புத்தகம், அலமாரியின் எந்த அடுக்கில் இருக்கிறது என்ற விவரம் தெரிந்தால்தானே தேவை வரும்போதெல்லாம் அதை எடுத்துப் பயன்படுத்த வசதியாக இருக்கும். போலவே, நிரலில் பயன்படுத்தப்படும் தரவுகள் கணினியின் மெமரியில் எங்கே சேமிக்கப்படுகின்றன என்று தெரிந்து வைத்திருப்பதும் ஒரு நிரலாளருக்கு அவசியமாகிறதுதானே?
இங்கேதான் அடையாளங்காட்டிகளின் தேவை ஏற்படுகிறது. நிரலில் பயன்படுத்தப்படும் தரவுகளைக் குறிக்க நாமே குறிப்பிட்ட ஒரு எழுத்தையோ (a,b,c) அல்லது ஒரு சொல்லையோ (age, total, salary, average) உருவாக்குகிறோம். குறிப்பிட்ட ஒரு அடையாளங்காட்டி, நிரல் முழுவதும் குறிப்பிட்ட ஒரு தரவுக்கான பொறுப்பை ஏற்கிறது. உதாரணத்துக்கு, ஒரு நிரலில் பயனரின் சம்பளம் எத்தனை முறை மாற்றத்துக்கு உண்டானாலும் சரி, அவற்றைக் குறிக்க salary என்னும் அடையாளங்காட்டியே பயன்படுத்தப்படும்.
ஒரு உதாரணத்தை ஊடாடும் முறையில் பார்த்துவிட்டு வருவோம்.
சரி, அடையாளங்காட்டிகளின் பெயரை நம் விருப்பத்துக்கு வைத்துக்கொள்ளலாமா?
ஆம். ஆனால் அதற்கு முன்பு முக்கியமான நான்கு நிபந்தனைகளைப் பின்பற்ற வேண்டும்.
1) அடையாளங்காட்டியின் பெயர் ஒரு இலக்கத்தோடு ஆரம்பிக்கக் கூடாது, ஆனால் ஒரு இலக்கத்தைக் கொண்டிருக்கலாம்.
>>>age123=0
>>>123age=1
முதலாவது சரி, இரண்டாவதில் நிரலாக்க மொழியின் இலக்கணம் மீறப்படுகிறது.
2) அடையாளங்காட்டியின் பெயருக்கு நடுவே இடைவெளி இருக்கக்கூடாது.
>>>usersalary=10000
>>>user salary=10000
முதல்வரி மட்டும் சரியானது.
3) அடையாளங்காட்டியின் பெயரில் _ (underscore) என்ற அனுமதிக்கப்பட்ட ஒரு சிறப்புச் சின்னத்தை மட்டும்தான் பயன்படுத்தவேண்டும்.
4) ஒரு அடையாளங்காட்டி ஒதுக்கப்பட்ட வார்த்தைகளுள் (keywords) ஒன்றாக இருக்கக்கூடாது.
அது என்ன ஒதுக்கப்பட்ட வார்த்தைகள்?
ஒரு நிரலாக்க மொழி தனக்கென சில வார்த்தைகளைப் பிடிவாதமாகப் பதிவு செய்துவைத்திருக்கும். அவற்றை ஒரு நிரலாளராக நாம் பயன்படுத்திக்கொள்ளலாமே ஒழிய, அதன் பெயரிலேயே புதிதாக ஒன்றை உருவாக்க இயலாது. ஒரு இரயிலில் இருக்கைகள் முன்பதிவு செய்து வைக்கப்படுவது போல.
ஏன் இப்படி ஒரு ஏற்பாடு?
பைத்தானில் குறிப்பிட்ட வார்த்தைகள் ஒதுக்கப்பட்ட பட்டியலுக்குக் கீழே வருகின்றன. ‘ஒதுக்கப்பட்ட’ என்பதை reserved என்ற அர்த்தத்தில் பயன்படுத்தி இருக்கிறேன். “உங்களுக்கான இருக்கை ஒதுக்கப்பட்டு விட்டது” என்ற பொருளில்.
ஒரு நிரலாக்க மொழிக்கு எதற்காக ஒதுக்கப்பட்ட வார்த்தைகள்? அந்த வார்த்தைகளை அதுதரும் பொருளுக்காக மட்டுமே ஒரு நிரலில் நாம் பயன்படுத்த முடியும்.
பைத்தானில் மொத்தம் 35 ஒதுக்கப்பட்ட வார்த்தைகள் இருக்கின்றன. ஒரேயடியாக ஒருவர் அவற்றை மனனம் செய்வது தேவையற்ற ஒன்று. ஆனால் அவற்றின்மீது ஒருகண் வைத்திருப்பது அவசியம்.
and
as
assert
break
class
continue
def
del
elif
else
except
False
finally
for
from
global
if
import
in
is
lambda
None
nonlocal
not
or
pass
raise
return
True
try
while
with
yield
இந்தப் பட்டியலில் True, False, None ஆகியவற்றின் முதல் எழுத்து மட்டும் கேப்பிட்டலாக இருப்பதைக் குறித்து வையுங்கள். காரணம் பைத்தான் நிரலாக்க மொழி case sensitive. அதாவது a என்பதும் A என்பதும் இருவேறு அடையாளங்காட்டிகள்.
>>> a=true
>>> a=True
இரண்டாவது வரியில்தான் சிக்கல். காரணம், ஒரு ஒதுக்கப்பட்ட வார்த்தை அது தரவிரும்பும் பொருளிலிருந்து மாறுபட்டு ஒரு நிரலாளரால் பயன்படுத்தப்படுகிறது. இது நிரலாக்க மொழியின் இலக்கண மீறல்.
அடையாளங்காட்டிக்கும், ஒதுக்கப்பட்ட வார்த்தைகளுக்கும் என்ன வேறுபாடு?
ஒரு நிரலாளர் உருவாக்கும் அடையாளங்காட்டிக்கு எனக் குறிப்பிட்ட எந்த பொருளும் இல்லை. அவர் அதற்கு ஒதுக்கும் தரவின் தன்மையினாலே அறியப்படுகிறது.
>>> x=25000
25000 என்பது xக்கு ஒதுக்கப்பட்டுள்ளது. அவ்வளவுதான் இதில் மேலும் யோசிக்க ஒன்றுமில்லை.
>> x=False
False என்பது ஒதுக்கப்பட்ட வார்த்தை. இந்தவரி எழுதப்படும் பொழுதே அதற்கு ஒரு பொருள் உண்டாகிறது.
இப்போது கீழே கொடுக்கப்பட்டுள்ள நிரல் வரிகளை ஒவ்வொன்றாக ஊடாடும் முறையில் எழுதி, எவையெல்லாம் சரியான அடையாளங்காட்டிகள் என்பதைக் கண்டுபிடியுங்கள் பார்ப்போம்.
>>> a=10
>>> _a=10
>>> a_=10
>>> a_b=10
>>> _=10
>>> hello sys=5.0
>>> hello_sys=5.0
>>> hello@sys=5.0
>>> hello123=65000
>>> h123ello=75000
>>> 123hello=85000
>>> true=1
>>> True=1
மேலே நாம் பார்த்த அடையாளங்காட்டிக்கு பெயர் வைக்கும் நான்கு விதிகளையும் இந்த நிரல் வரிகளை எழுதிப்பார்ப்பதன் மூலம் சோதனை செய்து பார்த்துக்கொள்ளலாம்.
அப்படிச் செய்யும்பொழுது, பைத்தான் சொல்லும் பிழைகளைத் தொடர்ச்சியாகக் கவனிப்பது ஒரு நல்ல பயிற்சி. உதாரணத்துக்கு,
>>> True=1
என்று எழுதும்போது பைத்தான் என்ன சொல்கிறது பாருங்கள்.
பொதுவாக நிரலாக்க மொழியில் வெளிப்படும் பிழைகளை(Errors) மூன்றாக பிரிக்கலாம்.
1) நிரல் எழுதும்போது மேற்கொள்ளப்படும் பிழைகள்(Compile time Error)
மிக எளிதாகக் கண்டறியப்பட்டு நீக்கப்பட வாய்ப்பிருக்கும் பிழைகள். காரணம், இலக்கணத்தை மீறிவிட்டீர்கள் என்பதை நிரலாக்க மொழியே உங்களுக்குச் சுட்டிக்காட்டுகிறது.
2) நிரலுக்குத் தரவுகள் தரும்பொழுது எழும் பிழைகள்(Runtime Error)
நிரலில் சிக்கல் இல்லை. பயனரிடம் அவரது அலைபேசி எண்ணைக் கேட்கிறீர்கள், அவர் தனது முகவரியை அங்கே உள்ளீடு செய்கிறார். நிச்சயம், இது ஒரு பிழை. ஆனால் சிறப்பாக எழுதப்பட்ட ஒரு நிரல், சரியான தரவினை உள்ளீடு செய்யும்படி பயனருக்கு வழிகாட்டும்.
3) தர்க்க பிழை(Logical Error)
இருப்பதிலேயே கண்டறிந்து நீக்குவதற்குச் சவாலான பிழை. காரணம் இலக்கண மீறல் எதுவும் நிகழவில்லை, சரியான தரவுகள் கொடுக்கப்பட்டு விட்டன. இருந்தாலும் தேவைப்படும் முடிவை நிரலால் தர இயலவில்லை.
ஒரே காரணம் தான், தீர்க்கப்படவேண்டிய சிக்கலை நிரலானார் சரியாக விளங்கிக் கொள்ளவில்லை.
0
போனவராம் சினிமா டிக்கெட் பதிவுசெய்வது குறித்துப் பேசியிருந்தோம்.
(தொடரும்)