ஒரு எண் ஒற்றைப்படையா அல்லது இரட்டைப்படையா என்பதைக் கண்டறிய அல்காரிதம் எழுதச்சொல்லிக் கேட்டிருந்தோம். பின்வரும் இரண்டும் வாசகர்கள் எழுதியவை (சரியானதும் கூட).
1) இதை எழுதியவர் தர்ஷன், பொறியியல் பட்டதாரி, சிடிஎஸ் நிறுவனத்தில் பணியில் இருக்கிறார்.
க. எண் 1: தொடக்கம்
க. எண் 2: ஒரு எண்ணைப் பயனரிடமிருந்து பெற்றுக்கொண்டு அதை a என்ற எழுத்தில் பொருத்திக் கொள்வோம்.
க. எண் 3: aவை இரண்டால் வகுக்க வேண்டும்(a/2)
க. எண் 4: வகுத்த பின்னர், பெறப்படும் மிச்சம் 0வாக இருந்தால் ஒற்றைப்படை, இல்லையென்றால் இரட்டைப்படை என்று அச்சிடவும்
க. எண் 5: முற்றும்
0
2) ஆர்.அபினேஷ் என்ற வாசகர் நாகர்கோவிலிலிருந்து இதை எழுதி அனுப்பியிருக்கிறார். அபினேஷ் பொறியியல் படித்துக்கொண்டிருக்கிறார்.
க. எண் 1: தொடக்கம்
க. எண் 2: 7 என்ற எண்ணை உள்ளீடாகப் பெற்று அதை x என்ற எழுத்தால் குறிக்கவும்
க. எண் 3: xஐ இரண்டால் வகுக்கும் பொழுது கிடைக்கும் மிச்சத்தை r என்ற எழுத்துக்கு ஒதுக்கீடு செய்யவும்
க. எண் 4: rன் மதிப்பு 0வாக இருந்தால் ஒற்றைப்படை, இல்லையென்றால் இரட்டைப்படை என்று அச்சிடவும்
க. எண் 5: முற்றும்
தர்ஷன், .அபினேஷ் இருவருக்கும் கிழக்கு டுடே மனமார்ந்த நன்றிகளைத் தெரிவித்துக் கொள்கிறது.
0
பைத்தானை உங்கள் கணினியில் பதிவிறக்கி பத்து நாட்களுக்கும் மேலாகிறது. ஒரு வேலையும் இல்லாமல் இப்படி உறங்குகிறதே என்ற கவலை வேண்டாம், இன்று அதன் காதில் நிரல் பாடி உலுப்பி விடுவோம்.
முன்பெல்லாம் நிரலைத் தட்டச்சு செய்ய ஒரு இடம் (text editor), பின்பு அதன் பிழைகளை நீக்கி கணினிக்குப் புரியும்படி மாற்ற (Compiled (or) Interpreted) மற்றுமொரு இடம் என எழுதிய நிரலைத் தூக்கிக்கொண்டு கணினிக்குள் அலைய வேண்டும். பைத்தானை பொறுத்தவரையில் அந்த அவஸ்தை இல்லை.
நிரல் எழுதுவது-> பிழைநீக்கி கணினிக்குப் புரிய வைப்பது-> நிரலுக்கான வெளியீட்டைச் (Output) சரிபார்ப்பது என அனைத்துமே நீங்கள் தரவிறக்கிய ஒருங்கிணைந்த உருவாக்கம் மற்றும் கற்றல் சூழலிலேயே (Integrated Development and Learning Environment (IDLE)) செய்துகொள்ளலாம். ஸ்பைடர், ஜூபிடர், பைச்சார்ம் (PyCharm) என நிறைய IDLEக்கள் உள்ளன. கற்றலில் ஆரம்பநிலையில் உள்ளவர்களுக்கு நாம் தரவிறக்கிய பைத்தான் IDLEயே போதுமானது.
சரி இதில் எப்படி விளையாடுவது?
இரண்டு வாய்ப்புகளை பைத்தான் வழங்குகிறது.
1) ஊடாடும் முறை (Interactive Mode)
2) ஸ்க்ரிப்ட் முறை (Script Mode)
ஸ்டார்ட் மெனுவில் இருந்து பைத்தானை தேர்ந்தெடுத்ததும் உங்களுக்குப் பின்வருமாறு ஒரு திரை தோன்றும். அதுவே ஊடாடும் முறை எனப்படும்.
அதாவது நீங்கள் ஒரு வரி எழுதினால் அதற்கு உண்டான வெளியீடு, அல்லது அதில் இருக்கும் பிழை உடனடியாக அடுத்த வரியிலேயே வெளிப்படுத்தப்படும். சாண்ட்விச்சை ஒரு நிமிடம் யோசித்துப் பாருங்களேன், இரண்டு ரொட்டி துண்டுகளுக்கு இடையே பண்டம் இருக்கும் அல்லவா? அதைப் போலத்தான் ஊடாடும் முறையில் ஒரு நிரல் வரி, அதன் வெளியீடு (அ) பிழை, மீண்டுமொரு நிரல் வரி என்ற தோற்றத்தில் இருக்கும். கற்றலின் ஆரம்பநிலையில் இருப்பவர்களுக்கு ஏற்றதாக ஊடாடும் முறை அமைந்திருக்கிறது. காரணம் ஒரு நிரல் வரி, உடனடியாக அதற்குண்டான எதிர்வினை என்ற அடிப்படையில் கற்கத் தொடங்குகிறோம்.
ஸ்க்ரிப்ட் முறை எதற்கு? எப்படிப் பயன்படுத்துவது? என்று கற்பதற்கு முன்பாக, ஊடாடும் முறையில் போதுமான தேர்ச்சியைப் பெற்றுக்கொள்வோம். அதற்காக சில உதாரணங்கள்.
நாம் எழுதிய அந்தக் கடைசி வரியில் பிழை இருப்பதாகச் சொல்கிறது. அந்தப் பிழையை விடுங்கள், அது பிழையென்று கண்டுபிடிப்பது எது?
உலக மொழிகளுக்கு இருப்பதைப் போலவே, நிரலாக்க மொழிகளுக்கும் உறுதியான இலக்கணம் உண்டு. அதைத்தான் Syntax என்கிறோம். அதாவது கட்டளைகளை எழுதினால் மட்டும் போதாது, அதைக் குறிப்பிட்ட இலக்கணத்துக்கு உட்பட்டு எழுத வேண்டும். ஒவ்வொரு நிரலாக்க மொழிக்கு ஏற்றவாறு இலக்கணங்கள் மாறும். நீங்கள் ஜாவாவில் கற்றுக்கொண்டதை அப்படியே ரூபிக்குப் பொருத்திப் பார்க்கக்கூடாது.
ஆகவே பைத்தானுக்கு என்று உருவாக்கப்பட்டிருக்கும் இலக்கணத்தை அறிந்து வைத்திருப்பது அவசியம்.
ஒருமுறை நிரல் எழுதத் தேவையான தர்க்கத்தை நீங்கள் கற்றுக்கொண்டால் போதும், அநேகமாக அனைத்து நிரலாக்க மொழிகளுக்கும் தர்க்கம் ஒன்றுதான், 1 தொடங்கி 100 வரை உள்ள எண்களில் 5ஆல் வகுப்படுபவை எவை என்று கண்டறியத் தேவைப்படும் தர்க்கம் ஒன்றுதான். அதை நிரலாக மாற்றுவதற்கு உண்டான இலக்கணம் மட்டும்தான் மாறுபடும். இந்தக் காரணத்தால்தான் ஏற்கனவே ஒரு நிரலாக்க மொழியை கற்றவர், மேலுமொன்றை புதிதாக கற்கும் பொழுது அது அவருக்கு எளிதான ஒன்றாக அமைகிறது. ஏற்கனவே ஒன்றை அறிந்தவர் என்ற தகுதியால் அல்ல, தர்க்கத்தை அறிந்தவர் என்பதால் எளிதாகிறது. ஆக நிரலாக்க மொழியை வேகமாகக் கற்றுக்கொள்ள ஒரு சூத்திரம் இருக்கிறதா என்றால், இப்படி எழுதலாம்:
நிரலாக்க மொழி = தர்க்கம் + இலக்கணம்
ஆனால் மொழியைப் போல முதலில் இலக்கணம் பிறகு மற்றவை என்ற செயல்முறை நிரலாக்கத்துக்கு ஒத்துவராது, அல்லது அதுவொரு சலிப்பான வழிமுறை. குறிப்பிட்ட தலைப்புக்கு ஏற்றவாறு, அந்தந்த நேரத்துக்குத் தேவைப்படும் இலக்கணத்தை அவ்வப்போது கற்றுக்கொள்வோம்.
சரி மீண்டும் நமது கேள்விக்கு வருவோம். இலக்கணம் மீறப்படுவதை, பிழையாக நிரல் எழுதப்படுவதை எது கண்டறிகிறது? இன்றைய காலகட்டத்தில் அதற்கென்று பிரத்தியேகமாக இரண்டு நிரல்கள் பயன்படுகின்றன.
1) Compiler (இதை இனிமேல் சி என்ற எழுத்தால் குறிப்பிடுவேன்)
2) Interpreter (இதைக் குறிக்க ஐ என்ற எழுத்து பயன்படும்)
இந்த சியும், ஐயும் யார்? இவற்றின் பணி என்ன?
சியும், ஐயும் நிரல்கள்தாம். அவற்றின் பணி மனிதர்களுக்குப் புரியும் வடிவில் எழுதப்பட்ட நிரலை ஓர் இயந்திரத்திற்குப் புரியும் வகையில் மாற்றிக்கொடுப்பது.
‘இதே கைதானடா போனவாரம் இயந்திரத்திற்குப் புரியாது, அதனால் நிரலாக்க மொழியில் சொல்லுங்க என்று எழுதினது. ஏன்டா இப்படி மாறி மாறி பேசற?’ என்று நீங்கள் கேட்பது புரிகிறது.
இந்தக் குழப்பத்தைத் தீர்க்க ஒரே வழிதான் இருக்கிறது. ஒரு இயந்திரத்திற்கு என்ன புரியும் என்று விளங்கிக்கொள்வது. ஒரு கணினியால் 0 அல்லது 1ஐ(பைனரி) மட்டுமே புரிந்துகொள்ள முடியும். குறைந்த மின்னழுத்தத்தைக் குறிக்க 0, உயர்ந்த மின்னழுத்தத்தைக் குறிக்க 1. கணினியை விடுங்கள், கீழேயிருப்பது உங்களுக்குப் புரிகிறதா என்று பாருங்கள்.
01101000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100
ஒன்றுமில்லை ‘hello world’ என்பதைத்தான் கணினிக்குப் புரியும் வகையில் பைனரியாக எழுதியிருக்கிறேன். இதை நாம் கற்றுக்கொண்டு, இயந்திரத்திற்குப் புரிவது போலச் சொல்வதற்குப் பதிலாக, ஒரு நிரலாக்க மொழியைக் கற்றுக்கொண்டு அதில் கட்டளைகள் எழுதி, அதை அந்த இயந்திரத்திற்குப் புரிவது மாதிரி மாற்றுவது இன்னும் சுலபமானது இல்லையா?
>>print(“Hello World”)
நிரலாக்க மொழியில் ஹலோ சொல்லியாயிற்று. இதை இயந்திரத்திற்குப் புரிவது போல மாற்றுவது எது? ஒன்று சி அல்லது ஐ.
இரண்டுக்குமான வேறுபாடு என்ன?
இந்தக் கேள்வியைக் குறித்து வைத்துக்கொள்ளுங்கள். தமிழ் சினிமாக்களில் ஐடி துறை சார்ந்த நேர்காணல் காட்சிகள் அனைத்திலும் தவறாமல் கேட்கப்படும் அளவுக்கு மிக முக்கியமான ஒரு கேள்வி என்றால் பார்த்துக்கொள்ளுங்கள்.
10 வரிகள் கொண்ட ஒரு நிரலை எழுதி முடித்துவிட்டீர்கள், இப்போது அதைப் பிழை திருத்தி ஓர் இயந்திரத்திற்குப் புரிவது போல பைனரியாக மாற்ற வேண்டும். அடிப்படையில் ஒரே பணியைத்தான் செய்கின்றன எனினும், எங்கே மாறுபடுகின்றன சியும், ஐயும்.
1) சி என்றால் -> ஒட்டுமொத்தமாக (ஒரே மூச்சில்) பத்து வரிகளையும் எடுத்துக்கொண்டு பிழைகளைச் சுட்டிக்காட்டி, அதைச் செயல்படுத்தப்படக் கூடிய (உங்களது ஆப்பரேட்டிங் சிஸ்டம் அங்கீகரிக்கும் விதத்தில்) ஒரே பைலாக மாற்றித்தரும்.
ஐ என்றால் -> ஒவ்வொரு வரியாக (தனித்தனியாக) எடுத்துக்கொண்டு, அதை இயந்திர மொழிக்கு மாற்றித்தரும். இதன் காரணமாக, செயல்படுத்தப்படக் கூடிய பைல் எதையும் ஐ உருவாக்குவதில்லை.
வடநாட்டுத் தலைவர் ஒருவர் சற்றுமுன் இந்தியில் பேசியதை, உள்நாட்டுக் கட்சி நிர்வாகி ஒரே மூச்சில் தமிழில் மொழிபெயர்த்தால் அது சி. தலைவர் இந்தியில் ஒரு வாக்கியத்தை அளந்துவிட்டு பெருமிதமாகக் கட்சி நிர்வாகியைத் திரும்பிப் பார்த்ததும், தலைவர் சொன்ன அந்த ஒற்றை வரியை மட்டும் மொழிபெயர்த்தால் அது ஐ.
2) சியால் மாற்றப்படும் நிரல், ஐயை காட்டிலும் மிக வேகமாக முடிவுகளைத் தரும். காரணம், கணினி செயலிக்கு (Computer Processor) உகந்த/எளிமையான ஒன்றையே சி உருவாக்குகிறது.
3) பிழை நீக்கும் முறையில் முன்னே இருப்பது ‘ஐ’தான். அதற்கு உண்டான காரணத்தை ஏற்கனவே பார்த்தோம். ஒரு வரியில் பிழை இருக்கும் பட்சத்தில் அதன் எதிர்வினை உடனடியாகக் காணக்கிடைக்கும். 500 வரிகள் கொண்ட நிரலை சியை வைத்து பிழை திருத்துவது நேரத்தையும், பொறுமையையும் கோரும் ஒன்று.
4) ஒரு கணினியிலிருந்து இன்னொன்றுக்கு மாற்றப்படும் பொழுது, சியால் உருவாக்கப்பட்டது புதிய கணினிக்கு ஏற்றவாறு மீண்டுமொருமுறை தன்னைத் தகவமைத்துக்கொள்ள வேண்டும். ஆனால் ஐயில் இந்த சிக்கல் இல்லை. பெயர்வுத்திறனில் (Portability) ஐதான் மிஞ்சி நிற்கிறது.
5) வரி வரியாக மட்டுமே எடுத்துக்கொள்வதால் கணினியின் மெமரியை மிச்சப்படுத்துகிறது ஐ, இதற்கு நேரெதிர் சி.
ஆக ஒரு நிரலாக்க மொழி சியை பயன்படுத்துகிறதா? அல்லது ஐயை பின்பற்றுகிறதா என்பதெல்லாம் அதன் வடிவமைப்பாளர்களைப் பொறுத்தது. பைத்தான் நிரலாக்க மொழி ஐயையே பின்பற்றுகிறது.
Interactive Mode என்பதையும் Interpreter என்பதையும் குழப்பிக் கொள்ளாதிருங்கள்.
0
‘வேலைன்னு வந்துட்டா நாங்க வெள்ளைக்காரங்க’ என்று பீல் பண்ணும் வாசகர்களுக்கான இந்த வாரக் கேள்வி.
1) 20ஐ குறிக்க a என்னும் எழுத்தைப் பயன்படுத்தவும்.
2) 10ஐ குறிக்க b.
a மற்றும் bஐ மட்டுமே பயன்படுத்திக் கூட்டல், கழித்தல், வகுத்தல், பெருக்கல் ஆகிய எண்கணித செயல்பாடுகளைக் (Arithmetic Operations) கணக்கிட்டு அச்சிடவும்.
2) aயின் மதிப்பான 20ஐ bக்கும், bயின் மதிப்பான 10ஐ aவிற்கும் பரிமாற்றம் செய்து அச்சிடவும். கீழே இருக்கும் படம் உங்களுக்கு இக்கேள்வியை மேலும் புரிந்துகொள்ள உதவலாம்.
இந்தச் செயல்பாட்டுக்குப் பிறகு aவை அச்சிட்டுப் பார்த்தால் 10ம், bயை அச்சிட்டுப் பார்த்தால் 20ம் கிடைக்கவேண்டும். அவ்வளவுதான்.
போனவராம் போலவே நீங்கள் எழுதியதை புகைப்படமாகவோ, அல்லது கணினியில் செய்து பார்த்ததை திரைச் சொட்டாகவோ (Screenshot) 9789855667 என்ற வாட்சப் எண்ணுக்குப் பகிர்ந்துகொள்ளுங்கள்.
(தொடரும்)
