பொருளடக்கம்

1. முன்னுரை

பைத்தான் படிக்க வேண்டும் என்பது என்னுடைய நீண்ட நாட்களாகவே என்னுள் இருந்த சிந்தனை. கல்லூரி படித்த காலங்களில் சி++, ஜாவா ஆகிய இரண்டையும் பாடமாகவே படித்திருந்தேன். ஆனாலும் அவை இரண்டும் பெரிய அளவில் மனத்தில் நிற்கவில்லை. செயலிலும் அப்படித்தான் வெளிப்பட்டது. வேலை பார்த்த நாட்களில் ஜாவா மிகப் பெரிய அளவில் எனக்குத் தேவையாக இருந்தது.

வேலையைத் தக்க வைப்பதற்கே ஜாவா வேண்டும் என்னும் நாட்களில் எப்படியாவது ஜாவாவைக் கரைத்துக் குடித்து விட வேண்டும் என்று ஜாவா கம்ப்ளீட் ரெஃபரென்ஸ் புத்தகங்களை வாங்கி, ஜாவா சான்றிதழ் படிப்புகளுக்குள் என் தலையை விட்டுக் கொண்டிருந்தேன். என்ன தான் பல்வேறு புத்தகங்களைப் படித்தாலும் ஒவ்வொரு கருத்தையும்(Concept) திட்டப்பணி(Project)களில் செயல்படுத்திக் காட்டுவதில் எனக்கு அளவுகடந்த சிக்கல்கள் இருந்தன.

அந்தச் சிக்கல்கள் என்னை ஜாவாவின் மேல் ஒருவித அச்சத்தை ஏற்படுத்தத் தொடங்கியிருந்தன. யாராவது ஒருவர் எனக்கு ஜாவா தெரியும் என்று சொன்னால் ‘அவர் மிகப்பெரியவர் என்றும் நான் ஒன்றுக்கும் ஆகாதவன்‘ என்றும் என்னை நானே மட்டம் தொட்டத் தொடங்கியிருந்தேன். இந்த மட்டம் தட்டும் மனநிலை பல ஆண்டுகளுக்கு என்னுள் தொடர்ந்து கொண்டிருந்தது. எனக்கு வந்த வெளிநாட்டு வாய்ப்புகளை எல்லாம் இந்த மனநிலையைக் கொண்டு தட்டி விட்டுக் கொண்டிருந்தேன்.

பின்னாட்களில் ‘பயிலகத்தை‘த் தொடங்கியிருந்த காலங்களில் மிகக் கவனமாக மென்பொருள் சோதனைகள் (Software Testing) பாடத்தைத் தான் நான் தேர்ந்து கொண்டேன். கணினி மொழி எனக்கே வராது, அதை நான் இன்னொருவருக்குச் சொல்லிக் கொடுத்து, பாடம் என்னிடம் இருந்து கடத்தப்படுவதற்குப் பதிலாக, பயம் கடத்தப்பட்டு விடக் கூடாது என்பதில் இருந்த என்னுடைய உறுதி தான் அதற்குக் காரணம்.

‘கோடி ரூபாய் கொடுத்தாலும் நிரல்மொழி எனக்கு வேண்டாம்‘ என்று நினைத்துக் கொண்டேன். ஆனால் காலம் என்னை வேறு விதமாக இட்டுச் சென்றது. நிரல் மொழியைப் பாடமாக எடுக்க வேண்டிய நெருக்கடி என்னிடம் வந்தது. முன்பு போல நெருக்கடியைத் தட்டிக் கழிக்கும் இடத்தில் நான் இல்லை. இந்த முறை – ஜாவாவைப் படித்துச் சொல்லியே ஆக வேண்டிய நெருக்கடியை நேரடியாகவே எதிர்கொண்டேன்.

ஜாவா எனக்கு வருமா? வராதா? இந்த முறை ஒரு முடிவு கட்டிவிட வேண்டும் என்று முடிவு செய்து கொண்டேன். மணிக்கணக்கான நேரத்தை நிரல் கருத்துருக்களை(concepts)ப் புரிந்து கொள்ள செலவு செய்யத் தொடங்கினேன். நிற்க. அதன் பிறகு எனக்கு நடந்தவை எல்லாம் இணையத்தில் யூடியூப் தளத்தில் படைப்பாக்கப் பொது உரிமத்தில் தமிழிலேயே காணக் கிடைக்கின்றன.

இந்தக் காலக்கட்டத்தில் தான் நண்பர் கணியம் சீனிவாசனின் அறிமுகம் கிடைத்திருந்தது. மாணவர்கள் ஜாவா படிக்கக் கொஞ்சம் கஷ்டப்படுகிறார்கள் என்பது உண்மை தான்! என்று அவரிடம் பேசிக் கொண்டிருந்தேன். ‘நீங்கள் ஏன் பைத்தான் முயலக்கூடாது?’ என்று கேட்டார். ‘ஜாவாவிற்கும் பைத்தானுக்கும் என்ன பெரிய வித்தியாசம் இருந்து விடப் போகிறது? இரண்டுமே பொருள்நோக்கு நிரலாக்க மொழிகள்(Object Oriented Programming) தானே! என்று மனத்துக்குள் நினைத்துக் கொண்டேன்.

அப்படி நினைத்தாலும் பைத்தான் படிக்கலாமே என்னும் சிந்தனை என்னுள் இருந்து கொண்டே இருந்தது. பைத்தானுக்குரிய புத்தகங்களைத் தேடத் தொடங்கினேன். ஜாவாவின் பின்னணியில் இருந்து வந்த நான், பைத்தானை, ஜாவாவைப் போலவே அணுகத் தொடங்கினேன். ஆனால், அப்படிப்பட்ட தேவைகள் இல்லை என்பதும் பெரிய பெரிய வேலைகளை எல்லாம் மிக எளிதாகப் பைத்தானில் செய்து விட முடியும் என்பதை அனுபவத்தில் உணர்ந்த போது – “இதை யாரிடமாவது சொல்ல வேண்டுமே! சொல்லாமல் இருக்க முடியவில்லையே!” என்று பார்க்கும் நண்பர்களிடம் எல்லாம் பைத்தானைப் பற்றிப் பேசத் தொடங்கினேன்.

எளிதில் பெயரக்கூடிய(Portable), உயர் நிலை(High level), பொருள் நோக்கு நிரல்(Object Oriented Programming) என்று எத்தனையோ நன்மைகள் பைத்தானில் இருந்தாலும் என்னை ஈர்த்தது என்ன? என்னை ஈர்த்தது, உங்களையும் ஈர்க்குமா? ‘உன் விழி ஈர்ப்பு விசையினிலே அன்பே அன்பே! நான் வந்து விழுந்து விட்டேன் அன்பே! அன்பே!’ என்று நீங்களும் பைத்தானைப் பார்த்துப் பாட முடியுமா? தொடர்ந்து பேசுவோம்.

2. தந்திரமே மந்திரமாய்!

போன அத்தியாயத்தில் பாட்டோடு முடித்திருந்தீர்களே! அப்படிப் பைத்தானிடம் என்ன இருக்கிறது என்று மயங்கினீர்கள் என்று கேட்கிறீர்களா? சொல்கிறேன். அண்மையில் மாநாடு என்றொரு படம் பார்த்தேன். நீங்களும் பார்த்திருக்கலாம். அந்தப் படத்தில் ஒரு காட்சி. படத்தின் நாயகன் அப்துல் காலிக்கைப் (சிம்புவைப்) பார்த்து, ‘என்ன இப்படி மெலிந்து போய்விட்டாய்? என்னப்பா செய்தாய்?’ என்று அவருடைய நண்பர் கேட்பார். அதற்குச் சிம்பு, ‘எதுவுமே செய்யவில்லை, அதனால் தான் மெலிந்து போய்விட்டேன்‘ என்று பதில் சொல்வார். இதே தான் பைத்தானிலும் என்னை ஈர்த்தது. ‘என்ன உளறுகிறாய்?’ என்கிறீர்களா?

ஒரு நிரல் மொழி (அதாங்க புரோகிராமிங் லாங்குவேஜ்) படிக்க வேண்டும் என்றால்.

• தரவு வகை (datatype) தெரிந்திருக்க வேண்டும்.
• இலக்கணம் (syntax) தெரிந்திருக்க வேண்டும்.
• `{`, `[`, `;` என்று பல உருவங்கள் கண் முன்னேயும் கனவிலும் வந்து போக வேண்டும்

இப்படி எண்ணில் அடங்கா வேலைகளைத் தெரிந்திருக்க வேண்டும். இப்படித்தான், பைத்தானைத் தொட்டுப் பார்க்கும் வரை நானும் நினைத்துக் கொண்டிருந்தேன். ஆனால், பிறகு தான் தெரிந்தது – ‘இவை எவையுமே தெரியாமல், பயன்படுத்தாமல் பைத்தானைப் படிக்க முடியும்‘ என்பது! மாநாடு படத்தின் நாயகனைப் போல, எதுவுமே செய்யாமல், மேல் சொல்ல எதுவுமே தெரியாமல் பைத்தான் படிக்க முடியும். அந்த எளிமை தான் என்னைப் பைத்தானை நோக்கி ஈர்த்தது.

பைத்தானின் எளிமை

தமிழைப் போல, ஆங்கிலத்தைப் போல – இயல்பாக அமைந்திருப்பது பைத்தானின் மிகப்பெரிய சிறப்பு. சி, சி++, ஜாவா, சிஷார்ப் ஆகிய மொழிகளில் இரண்டு எண்களைக் கூட்டுவதற்கு நிரல் எழுத வேண்டும் என்றால் முதலில் அந்த மொழிகளில் உள்ள தரவுவகைகள்(Datatypes) முழுவதையும் படித்திருக்க வேண்டும்.

அதன் பிறகு தான் இரண்டு எண்களைக் கூட்டும் எளிய நிரலைக் கூட எழுத முடியும். இப்போது தரவுவகைகளைப் படிப்பது என்றால் – தரவு என்றால் என்ன?, தரவில் ஏன் இத்தனை வகைகள்? இவை ஒவ்வொன்றையும் எழுத அதன் எழுத்துவகையை (சிறிய எழுத்தில் எழுத வேண்டுமா? பெரிய எழுத்தில் எழுத வேண்டுமா? என்பதை) நினைவில் கொள்ள வேண்டும். அந்தத் தரவுவகைகளின்(Datatypes) எல்லையை (byte இன் எல்லை 256 எண்கள், shortக்கு இவ்வளவு எண்கள் என) ஒரு நிரலர் நினைவில் கொள்ள வேண்டும். இதையெல்லாம் படித்த பின்னர் தான் – இரண்டு எண்களைக் கூட்டும் நிரலையே எழுத முடியும்.

ஒரு தேர்ந்த அனுபவம் வாய்ந்த நிரலருக்கு – இவையெல்லாம் சிக்கல்களே இல்லை என்றாலும் – விடுதலை அடைந்து மூன்று தலைமுறைக்காலம் ஆன பிறகும் கூட முதல் தலை பட்டதாரிகளே இப்போது தான் உருவாகி வரும் தமிழகம் போன்ற நிலப்பரப்பில் உள்ள இளைஞர்கள் இந்த அளவு முதல் நிரலிலேயே எக்கச்சக்க செய்திகளை உள்வாங்கி எழுதுவது என்பது நடைமுறைக்கு ஒவ்வாத ஒன்றாகவே இருக்கிறது.

இதை ஒட்டி வரும் இன்னொரு சிக்கல், ஒரு புதிய (அதுவும் பின்தங்கிய நிலைக் குடும்பங்களில் இருந்து வரும்) நிரலர்க்கு

• நிரல்மொழியின் இலக்கணம்(Syntax) முக்கியமா? (ஏனென்றால் தேர்வு மதிப்பெண்ணுக்கு இது தான் முக்கியம்)
• நிரலுக்குரிய ஏரணத்தை(logic)ச் சிந்திப்பது முக்கியமா? (ஏரணத்தைச் சிந்திப்பது எப்படி என்று தெரியவில்லையே, ஏரணம்(logic) வரமாட்டேன்கிறதே என்னும் தயக்கம்)

என்னும் கேள்விகளில் வரும் குழப்பங்களே அவர்களைச் சிறந்த நிரலராக மாற்றுவதில் தடைக்கற்களாக மாறி விடுகின்றன.

இந்தத் தடைக்கற்கள் எவையும் பைத்தானில் இல்லை. ‘இலக்கணம்(syntax) பிறமொழி தடைக்கல்லப்பா! தடைக்கல்லும் பைத்தானில் படிக்கல்லப்பா!’ என்று நாமும் பாடலாம். பைத்தான் போன்ற எளிய இலக்கண முறையைக் கொண்ட ஒரு நிரல்மொழியை மக்களுக்கு அறிமுகப்படுத்துவது என்பது – கணினி நிரலாக்கத்தில் பலரையும் உள்ளிழுக்கும் மிகச்சிறந்த தந்திரம். இந்தத் தந்திரமே பைத்தானின் தாரக மந்திரமாகவும் இருந்தால்? – இருந்தால் என்று ஏன் இழுக்க வேண்டும். இந்தத் தந்திரமே பைத்தானின் தாரக மந்திரம். மந்திரவாதிகள் ஆவோமா?

3. எளிமையே இனிமை!

“பைத்தானைப் பற்றிய உங்களுடைய முந்தைய இரண்டு பதிவுகளைப் பார்த்தேன். உண்மையில் பைத்தான் அவ்வளவு எளிதான மொழியா? புதியவர்களைப் பைத்தான் பக்கம் இழுக்க நீங்கள் செய்யும் விளம்பர உத்தி தானே அது?” என்று ஒரு நண்பர் கேட்டார். “விளம்பரங்களைக் கண்டு அப்படியே நம்பும் காலம் எல்லாம் மலையேறிப் போச்சு நண்பரே! நம்முடைய காலத்தில் ஒரு நடிகர் நடித்தாலே படத்திற்குப் போவோம்.

இப்போதுள்ள இளைஞர்கள் அப்படியா? நடிகர் யார்? இயக்குநர் யார்? ஒளிப்பதிவு யார்? என்று அக்கு வேறு ஆணிவேறாக அலசித் தான் (இவர்கள் அலசலுக்கு உதவியாக புளூ சட்டை மாறன் வேறு!) ஒரு திரைப்படத்தையே முடிவு செய்கிறார்கள். அவர்களை எப்படி நாம் விளம்பரத்தைக் காட்டி இழுக்க முடியும்?” என்றேன்.

“ஒரு வாளித் தண்ணீர் வைத்துக் கொள்ளுங்கள். அதில் ஒரே ஒரு சொட்டு எண்ணெய் விடுங்கள். அந்த ஒரு சொட்டு எண்ணெய் தான் மேலே மிதக்கும்! அப்படித்தான் உண்மையும்! எத்தனை பொய்கள் இருந்தாலும் தனியே மேலே தெரியும்” என்று மொழிஞாயிறு தேவநேயப் பாவாணர் சொல்வார். அதுவே நம்முடைய பைத்தான் அறிமுகத்திற்கும் பொருந்தும். பைத்தான் தனியே மேலே மிதக்கும்.

“தேன் இனிக்கும், தேன் இனிக்கும் என்கிறீர்கள். ஆனால் கையில் ஒரு சொட்டுக் கூடத் தர மாட்டேன் என்கிறீர்களே! பைத்தான் இவ்வளவு எளிமையான மொழி என்றால், நிறுவிக் காட்டுங்கள். அப்போது தான் நம்புவோம்!” என்கிறீர்களா? வாருங்கள்! தேனினிமையிலும் பைத்தானின் பாடம் திகட்டும் என்பதை நிறுவுவோம்.

இரண்டு எண்களைக் கூட்ட வேண்டும். இது தான் நம்முடைய முதல் வேலை என்று வைத்துக் கொள்ளுங்கள். எப்படிச் செய்வது? முதலில் இரண்டு எண்களின் மதிப்பைச் சொல்லி விடுங்கள்.

எண்1, எண்2 = 100, 90

என்றும் சொல்லலாம்.

எண்1 = 100
எண்2 = 90

என்று தனித்தனியாகவும் சொல்லலாம். புதியவர்கள் மிக எளிதாக நிரலைப் புரிந்து கொள்வார்கள். இப்போது வரும் விடையை அச்சிட்டுப் பார்க்க,

print(எண்1 + எண்2)

என்று கொடுத்தால் போதுமானது. (இதே நிரலை, சி, சி++, சி#, ஜாவா போன்ற தரவுவகை கொடுத்து அச்சிடும் மொழிகளில் கொஞ்சம் நினைத்துப் பார்க்கிறேன். ஒரு புதியவர் படும் பாடும் அவர்கள் உள்ளிருக்கும் கேள்விகளும் கண் முன்னே வந்து போகின்றன.)

அது சரி! மேல் உள்ள இந்தக் கணக்கை நான் எங்கே போய் செய்து பார்ப்பது? என்னுடைய கணினியில் பைத்தானை இன்னும் நிறுவவில்லையே என்கிறீர்களா? இந்தச் செய்முறையைச் செய்வதற்கு இணையத்திலேயே (நிறுவல் இல்லாமல்செய்ய) பல வழிகள் இருக்கின்றன. இப்போதைக்கு (www.w3schools.com/python/trypython.asp?filename=demo\_compiler) இணைப்பில் மேல் உள்ளதைச் செய்து பாருங்கள். பிறகு, பைத்தானை நிறுவிக் கொள்ளலாம்.

கணக்கீடுகளுக்கு ஏற்ற மொழியாக, கணக்கீடுகளை எளியவர்கள், புதியவர்கள் எளிதில் செய்யக்கூடிய பல வழிகளைப் பைத்தான் தன்னிடம் கொண்டிருக்கிறது. எ. காட்டாக, 15 என்னும் ஓர் பத்தடிமான எண்ணை, ஈரடிமான எண்ணாக மாற்ற வேண்டும் என்றால்,

print(bin(15))

அவ்வளவு தான்! அதே போல, இதே எண்ணை எட்டடிமான எண்ணாக மாற்ற வேண்டும் என்றால்,

print(oct(15)) என்று கொடுத்தால் போதும். இப்படிக் கணக்கீடுகளுக்கு மட்டும் என்று இல்லை. இயற்கை மொழிக் கணிப்புகள்(Natural Language Processing) பெருகி வரும் இக்காலத்தில் வார்த்தைகளைப் பைத்தான் கையாளும் முறையே அலாதியானது.

name = "Free Software"

என்று கொடுத்து விட்டு,

print(name[5:])

என்று கொடுத்தால் Software என்பதைத் தனியே வெளியே எடுத்துவிடலாம். அதாவது முதல் ஐந்து எழுத்துகளை(இடைவெளியும் ஓர் எழுத்து – இங்கே) விட்டு விட்டு பிற எழுத்துகளைத் தரும். இதில் ஒரு படி மேலே போய்,

print(name[::2])

என்று கொடுத்தால், Fe otae என்று ஓரெழுத்து விட்டு ஓரெழுத்து (அதற்குத் தான் 2 என்று கொடுத்திருக்கிறோம்!) அச்சாகி வந்து விடும்.

ஒரு வார்த்தையின் முதல் எழுத்தை மட்டும் பெரிய(capital) எழுத்தாக மாற்றுங்கள்.

அதாவது, ‘muthu’ எனக் கொடுத்தால் ‘Muthu’ என மாற்ற வேண்டும். எப்படிச் செய்வது?

name = 'muthu'
output = name[0].upper()+name[1:]
print(output) # ‘Muthu’

`upper()` என்பது கொடுக்கப்பட்ட எழுத்தைப் பெரிய எழுத்தாக(upper/capital) மாற்றுகிறது என்பது, இந்த நிரலைப் படித்த உடன் புரிந்து விடுகிறது அல்லவா! இந்த எளிமை தான் பைத்தானின் வெற்றி!

ஒரு வரி(வாக்கியத்தில்)யில் உள்ள ஒவ்வொரு வார்த்தையின் முதல் எழுத்தை மட்டும் பெரிய(capital) எழுத்தாக மாற்றுங்கள்.

name = 'richard stallman'
print(name.title())

இதன் வெளியீடு Richard Stallman என்று ஒவ்வொரு வார்த்தையின் முதல் எழுத்தும் பெரிய எழுத்தாகி விடை தரும்.

“சலசலசலசல இரட்டைக் கிளவி” என்பது தமிழ் தெரிந்த எல்லோருக்கும் தெரிந்த ஒன்று தான்! (தெரியாவிட்டாலும் ஒன்றும் சிக்கல் இல்லை!) இப்போது இப்படி சலசலசலசல என்று ஒரு நிரலர் எழுத விரும்பினால்,

• ஒரு முறை சல என்று எழுதட்டும்.
• எத்தனை சல தேவையோ பெருக்கிக் கொள்ளட்டும். இவ்வளவு தான் பைத்தான்.

இப்போது நிரலைப் பாருங்கள்.

வார்த்தை = 'சல'
print(வார்த்தை * 4)

இப்போது விடை – சலசலசலசல என்று வந்து விடும்.

ஒரு வார்த்தையில் ஒரு குறிப்பிட்ட எழுத்து இருக்கிறதா என்று பார்க்க வேண்டுமா?

• வார்த்தை என்ன என்று கேட்டுக் குறித்து வைத்துக் கொள்ளுங்கள்.

word = 'ezhil language'

இப்போது ‘a’ என்னும் எழுத்து இருக்கிறதா என்று பார்க்க,

print('a' in word)

என்று கொடுத்தால் போதும். நிரலர் தேடும் எழுத்து இருந்தால், `True` என்றும் இல்லை என்றால் – `False` என்றும் பளிச்சென்று பதில் தந்துவிடும் பைத்தான்.

இந்த எளிமை தான் பலரையும் பைத்தான் பக்கம் இழுத்திருக்கிறது. அந்தக் காந்தத்தில் இப்போது கட்டுண்டு போன இரும்பாக மெல்ல நானும் மாறிக் கொண்டிருக்கிறேன். தேன் இனிக்கும் என்பதைப் போல, பைத்தானும் இனிக்கும் என்பதைச் சுவைத்து விட்டீர்கள் அல்லவா? இனி, துணிச்சலாக நம்முடைய கணினியில் பைத்தானை நிறுவலாம் அல்லவா? நிறுவுவோம் வாருங்கள்!

4. லினக்சில் பைத்தான் நிறுவல்

பைத்தானின் எளிமையையும் இனிமையையும் எவ்வளவு நாள் தான் எட்ட நின்றே சுவைத்துக் கொண்டிருப்பது? நம்முடைய கணினியில் பைத்தானை நிறுவினால் தானே, “கண்ணே கலைமானே” என்று பைத்தானைப் பார்த்துப் பாட முடியும்!

பைத்தான் நிறுவலை லினக்சில் இருந்து தொடங்குவோம். “எடுத்த எடுப்பிலேயே லினக்ஸ் இயங்குதளத்திற்குப் போய் விட்டீர்கள். நாங்கள் எல்லோரும் விண்டோஸ் அல்லவா வைத்திருக்கிறோம்” என்கிறீர்களா? நிரலர் (டெவலப்பர்)க்குரிய ஒரு பால பாடம் சொல்லி விடுகிறேன் – நல்ல கணினியாளராக மாற விரும்பும் ஒவ்வொருவரும் கட்டற்ற மென்பொருளாகிய லினக்ஸ் பயன்படுத்துவது தான் சாலச் சிறந்தது.

விண்டோஸ், மேக் போன்ற இயங்குதளங்களில் பல நன்மைகள் இருக்கலாம், மறுப்பதற்கில்லை. ஆனால், அவற்றின் மூடிய பண்பே(Closed Source) ஒரு நிரலரை ஒரு கட்டத்திற்கு மேல் இயங்க விடாமல் தடுத்து விடும். ‘யோக்கியனுக்கு இருட்டுல என்ன வேலை?’ என்று கைப்புள்ள கேட்பது போல, ‘நிரலர்க்கு மூடிய மென்பொருளில் என்ன வேலை?’ என்று நாமும் கேட்கலாம்.

எனவே, பைத்தான் படிக்க விரும்புகிறீர்கள் என்றால், இரட்டை இயங்குதள நிறுவல் (Dual Boot Linux) முறையிலாவது லினக்சை நிறுவிக் கொள்ளுங்கள். லினக்சில் பல வகைகள் இருக்கின்றனவே! எதை நிறுவுவது? என்பது உங்களுடைய கேள்வியாக இருந்தால்,

• தமிழ்நாட்டு அரசு கொடுக்கும் இலவச மடிக்கணினிகளில் பாஸ்(BOSS) என்னும் பெயரில் லினக்ஸ் ஏற்கெனவே இருக்கிறது. அரசு மடிக்கணினிகள் வைத்திருப்போர் அதையே பயன்படுத்திக் கொள்ளலாம்.
• மற்றவர்கள் லினக்ஸ் மின்ட்(https://linuxmint.com/) சின்னமான்(Cinnamon) அல்லது உபுண்டு (ubuntu.com/) டெஸ்க்டாப் நிறுவிக் கொள்ளலாம்.

(இப்படி இரட்டை நிறுவலை மேற்கொள்ள விலை உயர்வான மடிக்கணினி தான் தேவை என்பதில்லை. அரசு மடிக்கணினியே தாராளமாகப் போதுமானது.)

லினக்சில் பைத்தான் நிறுவல்

• டெர்மினலைத் திறந்து கொள்ளுங்கள்.
• அதில் `python --version` என்று முதலில் அச்சிட்டுப் பாருங்கள். லினக்சில் ஏற்கெனவே நிறுவப்பட்டிருக்கும் பைத்தான் 2 பற்றிய விவரங்களை அப்போது பார்க்கலாம். நமக்குத் தேவையானது பைத்தான் 2 இல்லை, பைத்தான் 3 என்பதை நினைவில் வைத்துக் கொள்ளுங்கள். எனவே, உங்கள் கணினியில் பைத்தான் 2 இருந்தாலும் இல்லாவிட்டாலும் நாம் அதைக் கருத்தில் கொள்ள வேண்டிய தேவையில்லை.
• பைத்தான் 3, உங்கள் கணினியில் இருக்கிறதா என்று பார்க்க, `python3 --version` என்று அச்சிடுங்கள்.
• பைத்தான் இருந்தால், கீழ் உள்ளது போல, பைத்தானின் பதிப்பு என்ன என்று காட்டும்.

$ python --version
Python 3.10.1

இப்படிப் பைத்தான் உங்கள் கணினியில் இருந்தால், கீழ் உள்ள வரிகளை நீங்கள் விட்டு விடலாம்.

• ஒரு வேளை பைத்தான் உங்கள் கணினியில் இல்லை என்றால் மட்டும் கீழ் உள்ள வேலைகளைச் செய்யுங்கள்.
• பைத்தானின் தளத்தில் எந்தப் பதிப்பை அண்மைய பதிப்பாகக் கொடுத்திருக்கிறார்களோ, அந்த எண்ணைக் குறித்துக் கொள்ளுங்கள்.(இப்போது அந்தப் பதிப்பு 3.10.1)

• `sudo apt-get install python3.10.1` என்று டெர்மினலில் கொடுங்கள்.

$ sudo apt-get install python3.10.1

அவ்வளவு தான்! பைத்தானை நம்முடைய கணினியில் நிறுவிவிட்டோம். இப்போது பைத்தான் நம்முடைய கணினியில் இருக்கிறது என்பதை எப்படி உறுதிப்படுத்துவது? ஏற்கெனவே சொன்னது போல, `python –version` என்று டெர்மினலில் கொடுத்து உறுதிப்படுத்திக் கொள்ளலாம்.

நான், விண்டோஸ் இயங்குதளத்தில் வேலை செய்கிறேனே, மேக் இயங்குதளத்தில் வேலை செய்கிறேனே என்பவர்கள் அடுத்தடுத்த பதிவுகளைப் பாருங்களேன்.

5. விண்டோசில் பைத்தான் நிறுவல்

முதலில் www.python.org/downloads/ தளத்திற்குப் போய் அண்மைய பதிப்பைச் சொடுக்கித் தரவிறக்கிக் கொள்ளுங்கள். (இப்போதைக்கு 3.10.1)

தரவிறக்கிய கோப்பைச் சொடுக்கி, “Install Now” என்பதைக் கொடுப்பதற்கு முன், கடைசியில் இருக்கும் “Add Python 3.10 to Path” என்பதைத் தேர்ந்து கொள்ளுங்கள்.

குறிப்பு: மேல் உள்ள படத்தில் "Add Python 3.10 to Path" தேர்ந்திருக்க வேண்டும். விடுபட்டிருக்கிறது

பிறகு, **“Install Now”** என்பதைச் சொடுக்கினால் போதும். இப்படியாகப் பைத்தான் நிறுவல் தொடங்கி விடும்.

கடைசியில் **“Setup was successful”** என்று வந்தால் போதும். நீங்கள் பைத்தானை நிறுவி விட்டீர்கள் என்று புரிந்து கொள்ளலாம்.

பைத்தான் நிறுவலை எப்படி உறுதிப்படுத்துவது?

cmd என்று தட்டினால் Command Prompt வரும். அதில் `python --version` என்று அச்சிட்டுப் பாருங்கள். நீங்கள் நிறுவிய பைத்தானின் பதிப்பைப் பார்க்கலாம்.

C:\Users\91759>python --version
Python 3.10.1

Pip நிறுவல்

பைத்தானுடன் சேர்ந்து Pip (Pip Installs Packages) உம் கணினியில் நிறுவப்பட்டிருக்கும். Pip என்பது பைத்தான் நிரல்தொகுப்புகளை(Packages) நிறுவ உதவும் மென்பொருளாகும். மேலே திறக்கப்பட்ட அதே Command Promptஇல் `pip -V` என்று தட்டச்சிட்டால் pip எங்கே நிறுவப்பட்டிருக்கிறது என்று தெரிந்து கொள்ளலாம்.

C:\Users\91759>pip -V
pip 21.2.4 from C:\Users\91759\AppData\Local\Programs\Python\Python310\lib\site-packages\pip (python 3.10)

6. முதல் முதலாய் நிரல்!

பைத்தானை நிறுவி விட்டோம். சரி! இப்போது நிரல் எழுதத் தொடங்குவோமா! நிரல் எழுதுவது என்றால்

• முன்னேற்பாடுகள் என்னென்ன செய்ய வேண்டும்?
• என்னென்ன தெரிந்திருக்க வேண்டும்?
• உண்மையிலேயே பைத்தான் எளிதான மொழி தானா? இப்படிப் பல கேள்விகள் உங்கள் மனத்தில் ஓடிக் கொண்டிருக்கலாம். இந்தக் கேள்விகள், குழப்பங்கள் எல்லாமே துளியும் தேவையில்லாதவை. ஆமாம்! பைத்தானைப் படிப்பது என்பது தமிழ் படிப்பது போன்றது. செந்தமிழும் நாப்பழக்கம்! பைத்தானும் அதே பழக்கம் தான்!

விண்டோசில் பைத்தான்

விண்டோசில் IDLE என்று தட்டச்சிடுங்கள். IDLE கீழ் உள்ளது போல் திறக்கும்.

அதில் நாம் விரும்பும் வகையில் கணக்கீடுகள், பெயர்களை அச்சிடுவது என்று நிரலைத் தொடங்கி விட வேண்டியது தான்.

`>` என்று இருக்கும் இடத்தில் `5+5` என்று தட்டச்சிட்டு Enter பொத்தானைத் தட்டுங்கள். பத்து என்று பதில் படக்கென்று வரும்.

மாணவர் ஒருவரின் ஐந்து மதிப்பெண்களின் கூடுதலைக் கண்டுபிடிக்க விரும்பினால், பின்வருமாறு கொடுங்கள்.

>>> தமிழ் = 90
>>> ஆங்கிலம் = 89
>>> கணக்கு = 78
>>> அறிவியல் = 92
>>> சமூக_அறிவியல் = 95
>>> மொத்தம் = தமிழ் + ஆங்கிலம் + கணக்கு + அறிவியல் + சமூக_அறிவியல்
>>> மொத்தம்
444

இப்போது விடை **444** என்று வந்து விடும். இங்கே, சமூக அறிவியல் என்பதில் சமூக என்பதற்கும் அறிவியல் என்பதற்கும் இடையில் உள்ள இடைவெளியை அடிக்கோடிட்டு வைத்திருக்கிறோம் என்பதை மறந்து விடாதீர்கள். பைத்தான் உள்பட, எந்த நிரல்மொழியும் இப்படிப்பட்ட இடைவெளிகளை ஆதரிப்பதில்லை. பெயர்களுக்கு இடையே இப்படிப்பட்ட இடைவெளி கொடுக்க வேண்டிய தேவையிருந்தால் இடைவெளிக்கு மாற்றாக அடிக்கோடு இடுங்கள்.

IDLEஇல் பைத்தான் கோப்பு உருவாக்குதல்

பைத்தான் IDLEஇல் மேல் உள்ளது போல் பைத்தான் வரிகள் எழுதி விடைகளைப் பார்க்கலாம். ஆனால் அதைச் செய்வது விரும்பத்தக்கதன்று. ஏனென்றால், ஒவ்வொரு முறை IDLEஐ மூடும் போதும் நாம் எழுதிய பைத்தான் நிரல் அழிந்து விடும். எனவே பைத்தான் நிரல் எழுதிச் சேமிக்க (Save) நாம் கற்றுக்கொள்ள வேண்டும்.

எப்படிச் செய்வது?

• IDLEஐத் திறந்து வைத்துக் கொள்ளுங்கள்.
• File –> New என்று சொடுக்குங்கள்.
• இதில் பைத்தான் நிரலைத் தட்டச்சிடலாம். இப்போதைக்கு மேல் உள்ள வரிகளைக் கொஞ்சமாகக் கீழே இருப்பது போல் மாற்றி ஒட்டி விடுங்கள்.

தமிழ் = 90
ஆங்கிலம் = 89
கணக்கு = 78
அறிவியல் = 92
சமூக_அறிவியல் = 95
மொத்தம் = தமிழ் + ஆங்கிலம் + கணக்கு + அறிவியல் + சமூக_அறிவியல்
மொத்தம்
print(மொத்தம்)

• இப்போது File –> Save வழியிலோ ctrl+s கொடுத்தோ இந்த நிரலைச் சேமிக்க வேண்டும்.
• நிரலை first.py என்று சேமிக்கிறேன். நீங்களும் அப்படியே சேமித்துக் கொள்ளலாம். வேறு பெயர் வேண்டுமானாலும் கொடுக்கலாம்.
• இனிமேல் இந்த நிரலை நீங்கள் எப்போது வேண்டுமானாலும் File –> Open என்று தேர்ந்தெடுத்தோ, Ctrl+o கொடுத்தோ திறந்து கொள்ளலாம்.

எப்படி இயக்குவது?

இப்போது பைத்தான் நிரலை எப்படி இயக்குவது என்று பார்ப்போமா?

• F5 ஐ அழுத்துங்கள்.

• இப்போது **444** எனத் திரையில் வெளியீட்டை நீங்கள் பார்க்கலாம்.

இப்போது விண்டோஸ் இயங்கு தளத்தில் பைத்தான் நிரல் எழுதத் தெரிந்து விட்டது. அடுத்து என்ன? லினக்ஸ் தான்! லினக்சில் எப்படிப் பைத்தான் நிரல் எழுதுவது என்று பார்த்து விடுவோம்.

7. லினக்சில் நிரல் எழுதுவோம்!

முந்தைய அத்தியாயத்தில் விண்டோசில் எப்படி லினக்ஸ் நிரல் எழுதுவது என்று பார்த்தோம். இப்போது லினக்சில் எப்படி எழுதுவது என்று பார்ப்போம்.

லினக்ஸ் இயங்குதளத்தில் பைத்தான் நிரல் எழுதுவதற்கு முன், நோட்பேட்++(Notepad++), நோட்பேட்கியூகியூ(Notepadqq) போன்ற மென்பொருட்களை நிறுவிக் கொள்வது சிறந்தது. இம்மென்பொருட்கள் கட்டாயமாகத் தேவையா எனக் கேட்டால் இல்லை தான்! இருந்தாலும் இவற்றைப் பயன்படுத்துவதில் சில நன்மைகள் இருக்கின்றன என்பதால் இவற்றைப் பயன்படுத்தச் சொல்கிறேன், அவ்வளவே!

நோட்பேட்கியூகியூ தரவிறக்கம்

லினக்ஸ் மின்டின் சாப்ட்வேர் மேனேஜரைத் திறந்து வைத்துக் கொள்ளுங்கள். அதில் நோட்பேட்கியூகியூ(Notepadqq) என்று தட்டச்சிட்டு அதை நிறுவிக் கொள்ளுங்கள்.

இப்போது கீழ் உள்ள நிரலை அதில் அச்சிடுங்கள்.

தமிழ் = 90  
ஆங்கிலம் = 89  
கணக்கு = 78  
அறிவியல் = 92  
சமூகஅறிவியல் = 95 
மொத்தம் = தமிழ் + ஆங்கிலம் + கணக்கு + அறிவியல் + சமூகஅறிவியல்
print(சமூகஅறிவியல்)

எப்படிச் சேமிப்பது?

• முதலில் ஏதாவது ஒரு அடைவை(Folder)த் தேர்ந்து கொள்ளுங்கள். (நான் /home/muthu/Documents/Python10 தேர்ந்து கொண்டேன்).
• File –> Save என்றோ `ctrl+s` என்றோ கொடுங்கள்.
• வரும் மேல்மீட்புப் பட்டியில் (Popup) உங்களுக்கு விருப்பமான பெயர் கொடுத்து (நான் total என்று பெயர் கொடுத்திருக்கிறேன்), மறக்காமல் கடைசியில் .py என்று கொடுத்துச் சேமியுங்கள்.

எப்படி நிரலை இயக்குவது?

• டெர்மினலைத் திறந்து உங்கள் பைத்தான் நிரல் இருக்கும் அடைவுக்குச் செல்லுங்கள்.

குறிப்பு: டெர்மினலை Ctrl+Alt+T எனக் குறுக்கு வழியில் திறக்கலாம்.

• திறந்து கீழ் உள்ளது போலக் கொடுத்து, பைத்தான் அடைவுக்குப் போகலாம். cd /home/muthu/Documents/Python10
• இப்போது கீழ் உள்ள கட்டளையைக் கொடுங்கள்.

python3 total.py

இது தான் பைத்தான் நிரலை இயக்கும் கட்டளை. python3 எனக் கொடுத்து ஓர் இடைவெளி விட்டு, நம்முடைய பைத்தான் கோப்பின் பெயரைக் கொடுக்க வேண்டும்.

இப்போது நமக்குப் பைத்தான் நிரலை இயக்கி வெளியீட்டைப் பார்க்கத் தெரிந்து விட்டது. அப்படியானால் முதன்மையான கட்டத்தை வெற்றியோடு தொடங்கி விட்டோம் என்று பொருள்! வாருங்கள்! தொடர்ந்து பைத்தானில் பயணிப்போம்.

8. பைத்தான் உங்களை வரவேற்கட்டும்!

இதுவரை பார்த்த பதிவுகள் வழியே விண்டோஸ், லினக்ஸ் ஆகிய இயங்குதளங்களில் எப்படிப் பைத்தான் நிரலை எழுதி, இயக்கி, வெளியீட்டையும் பார்க்கத் தெரிந்து கொண்டோம். அந்தப் படியை இன்னும் ஏறாதவர்கள் ஒரு முறைக்கு இருமுறை அந்தப் படியை ஏறப் பழகிக் கொள்ளுங்கள். அந்தப் படியில் முறையாக ஏறியவர்களுக்கு இனி நிரல் எழுதுவது என்பது எட்டாக்கனி இல்லை, முழுமையாக எட்டும் கனி தான்!

இப்போது ஒரு நிரல் எழுதப் போகிறோம். பைத்தான் நிரல், ‘உங்கள் பெயர் என்ன?’ என்று கேட்கப் போகிறது. அதற்கு நீங்கள் உங்கள் பெயரைச் சொல்லப் போகிறீர்கள். (உங்கள் பெயர் திருவள்ளுவர் என்று வைத்துக் கொள்ளுங்களேன், அப்படியானால்) பைத்தான், “வாருங்கள் திருவள்ளுவர் வணக்கம்” என்று சொல்லப் போகிறது.

குறிப்பு: இந்தப் பதிவிலும் இனி வரும் பதிவுகளிலும் நான் லினக்ஸ் இயங்குதளத்தில் நிரலை எழுதி வெளியீட்டைக் காட்டப் போகிறேன். விண்டோஸ் இயங்குதளத்தில் வேலை செய்பவர்கள், ஆறாம் பதிவைப் பின்பற்றி இதைச் செய்யலாம், நூறு விழுக்காடு உங்கள் நிரல் இயங்கும்.

• கீழ் உள்ள நிரல் வரிகளை நோட்பேட்கியூகியூவில் எழுதுகிறோம்.

name = input("What is your name?")
print("Welcome ", name, "Vanakkam")

• இந்நிரலை second.py என்னும் பெயரில் /home/muthu/Documents/Python10 அடைவில் சேமிக்கிறோம். (நீங்கள் எங்கே சேமிக்கிறீர்கள் என்று பார்த்துக் கொள்ளுங்கள்).
• டெர்மினலைத் திறந்து அந்த அடைவை அடைந்து கொள்ளுங்கள். (cd /home/muthu/Documents/Python10)
• `python3 second.py` என்று இயக்கிப் பாருங்கள்.
• நிரல் இப்போது, “What is your name?” என்று கேட்கும்.
• மறுமொழியாக, Thiruvalluvar என்று உள்ளிட்டு என்டர்(Enter) பொத்தானைத் தட்டிப் பாருங்கள்.
• Welcome Thiruvalluvar Vanakkam என்று பைத்தான் உங்களை வரவேற்கும்.

விருந்தோம்பல் என்பது தமிழர் மரபு. அந்த மரபுப்படி, இப்போது பைத்தான் உங்களை வரவேற்று விருந்தோம்பியிருக்கிறது. நாமும் பைத்தானில் இருந்தோம்பி விரும்பியதை அடைய முடியும்.

“விருந்தோம்புவது, இருந்தோம்புவது எல்லாம் சரி, மேல் உள்ள நிரலில் என்ன நடக்கிறது என்று நீங்கள் சொல்லவே இல்லையே!” என்கிறீர்களா? இந்த நிரலில் இரண்டு செயல்கூறுகளைப் பயன்படுத்தியிருக்கிறோம். “செயல்கூறா” அப்படியென்றால் என்னவென்று சொல்லுங்கள். எங்களுக்குப் பைத்தான் மட்டுமில்லை, அதைத் தனித்தமிழில் படிப்பதும் புதிதுதான்! எங்கள் இயலாமையைப் புரிந்து சொல்லிக் கொடுங்கள் என்று சொல்வது எனக்கும் நன்றாகக் கேட்கிறது.

கவலைப்படாதீர்கள். செயல்கூறு என்றால் என்ன? அதை எப்படிப் புரிந்து கொள்ள வேண்டும் என்பதை எல்லாம் அடுத்த அத்தியாயத்தில் சொல்கிறேன்.

9. செயல்கூறு ஆராய்வோம்!

செயல்கூறு என்றால் என்னவென்று பார்ப்போம் என்று முந்தைய அத்தியாயத்தில் சொல்லியிருந்தேன் அல்லவா?

செயல் என்றால் என்ன? ஏதாவது ஒரு வேலையைச் செய்வது! அதே தான் செயல்கூறும்! ஒருவரைக் கூப்பிட்டு, சாப்பிடு என்று சொல்கிறோம். சாப்பிட அவர் என்னென்ன செய்வார்?

சாப்பிடுதல்:

• தட்டு / இலை எடுப்பார்.
• சோற்றை அதில் வைப்பார்.
• கறி / குழம்பு சேர்ப்பார்.
• குழப்பி உண்பார்.
• கையைக் கழுவுவார்.

இவ்வளவு செயல்களும் சாப்பிடுதல் என்னும் ஒற்றைச் சொல்லுக்குள் அடங்கி விடுகிறது அல்லவா! இங்கே, சாப்பிடுதல் என்பது தான் செயல்கூறு. பல செயல்களைத் தன்னுள் அடக்கி வைத்திருக்கும் சாப்பிடுதல் என்பதைத் தான் செயல்கூறு என்கிறோம். செயல்கூறு என்பதை ஆங்கிலத்தில் Function (செயல்பாடு) என்று சொல்வார்கள். பைத்தானில் Function என்றோ Method என்றோ சொல்வார்கள். சில நிரல் மொழிகளில் செயல்கூற்றை Method என்றும் வேறு சில மொழிகளில் procedure என்றும் சொல்வார்கள்.

சாப்பிடுதல் என்பதைப் போல, எழுதுதல் (எழுதுகோல் எடுத்தல், தாள் எடுத்தல், எழுதத் தொடங்குதல்), படித்தல்(புத்தகம் எடுத்தல், திறத்தல், வாசித்தல்) என நாம் செய்யும் பல செயல்கூறுகளைச் சொல்ல முடியும். நீங்களும் ஒரு தாளையும் எழுதுகோலையும் எடுத்து, உங்களுக்குத் தெரிந்த சில செயற்கூறுகளை எழுதிப் பாருங்களேன்.

இப்படிப்பட்ட இரண்டு செயல்கூறுகளைத் தான் முந்தைய அத்தியாயத்தில் பார்த்தோம் – `input()`, `print()` ஆகியவையே அவை! input() என்பதன் பின்னால் பல்வேறு செயல்கள் ஒருங்கிணைக்கப்பட்டிருக்கும். `print()` என்பதன் பின்னாலும் பல்வேறு செயல்கள் ஒருங்கிணைக்கப்பட்டிருக்கும். `input()` என்றால் இந்த வேலையைச் செய்ய வேண்டும், print() என்றால் இந்த வேலையைச் செய்ய வேண்டும் என்று பைத்தானுக்கு எப்படித் தெரியும்? இந்தச் செயல்கூறுகள் மட்டுமல்ல, இதே போலப் பல செயல்கூறுகளைப் பைத்தானில் பொதிந்து வைத்திருக்கிறார்கள். பைத்தான் நம்முடைய கணினியில் நிறுவப்பட்ட போதே அந்தச் செயல்கூறுகளைப் பைத்தான் தெரிந்து வைத்திருக்கும்.

`input()`, `print()` ஆகியவற்றைப் பைத்தான் தெரிந்து வைத்திருக்கும், சரி! input, print ஆகியவற்றின் பின்னால் சேர்க்கப்படும் அடைப்புக்குறி() எதற்கு என்று நீங்கள் கேட்கலாம். ஒரு வேலையைச் செய்கிறோம் என்றால், அந்த வேலைக்கு உள்ளீடு தேவைப்படும் அல்லவா? ‘கடைக்குப் போய் தேங்காய் வாங்கி வா’ என்கிறார் அப்பா. தேங்காய் வாங்குதல் என்பது இங்கு செயல்கூறு. அந்தத் தேங்காய்க்கு அவர் கொடுக்கும் காசு தான், இந்தச் செயல்கூற்றிற்கான உள்ளீடு. இதைப் பைத்தானில் எப்படி எழுத வேண்டும்?

தேங்காய்_வாங்கு(20)

என்று எழுத வேண்டும். இங்கு 20 என்பது `தேங்காய்_வாங்கு` என்னும் செயல்கூற்றைச் செய்யப் பயன்படும் உள்ளீடு. இதே போல, வேறு சில செயல்கூறுகளை உள்ளீட்டுடன் எழுதுகிறேன். உங்களால் புரிந்து கொள்ள முடிகிறதா என்று பாருங்கள்.

வாசி(செய்தித்தாள்)
எழுது(தாள், எழுதுகோல்) # ஒன்றுக்கு மேற்பட்ட உள்ளீடுகளை இப்படி எழுதலாம்.
அருந்து(பழச்சாறு)
கணினியைத்_தொடங்கு(மின்சாரம்)

இப்போது, பைத்தானில் நாம் பயன்படுத்திய இரண்டு செயல்கூறுகளை மீண்டும் எழுதுவோம், எழுதிப் புரிந்து கொள்ள முயல்வோம் வாருங்கள்.

name = input("What is your name?")
print("Welcome ", name, "Vanakkam")

இங்கு `input()` என்பதற்கு உள்ளீடாக, “What is your name?” என்று கொடுத்தால், அது அப்படியே அச்சிட்டுக் காட்டப்படும். அப்போது நாம் என்ன தட்டச்சிடுகிறோமோ, அது name என்பதில் சேமித்து வைக்கப்படும். print() என்னும் செயல்கூறு, “Welcome “, name, “Vanakkam” ஆகியவற்றை உள்ளீடுகளாக எடுத்துக் கொள்ளும்.

அவற்றை எடுத்துக் கொண்டு, அச்சிட்டு(print)க் கொடுக்கும். இரட்டை மேற்கோள் குறிக்குள் கொடுக்கப்படும் வார்த்தைகள் அப்படியே அச்சிடப்படும். இரட்டை மேற்கோள் குறி இல்லை (இங்கே name) எனில் அதில் சேமிக்கப்பட்டிருக்கும் (நீங்கள் தட்டச்சிட்ட) பெயர் அச்சிடப்படும்.

இப்போது ஓர் ஐயம்! `input()` என்பதன் முன்பு name = என்று கொடுத்து இருந்திருக்கிறீர்கள். ஆனால், print() என்பதன் முன் எதையுமே கொடுக்கவில்லை ஏன்? இந்த ஐயம் உங்களுக்கு இருந்தால் நீங்களும் என் தோழரே! தொடர்ந்து பேசுவோம், புரிந்து கொள்வோம் தோழர்!

10. செயல்கூற்றின் வெளியீடு, மாறிகள்

input() என்பதன் முன்பு `name =` என்று கொடுத்து இருந்திருக்கிறீர்கள். ஆனால், `print()` என்பதன் முன் எதையுமே கொடுக்கவில்லை ஏன்? என்னும் கேள்வியுடன் முந்தைய பதிவை முடித்திருந்தேன். இந்தப் பதிவு புரிய முந்தைய பதிவின் முன்னோட்டம் தேவையான ஒன்று. இன்னும் நீங்கள் அதைப் படிக்கவில்லை என்றால், கொஞ்சம் படித்து விட்டு இந்தப் பதிவைத் தொடருங்களேன்.

கேள்வி இது தான்!

name = input("What is your name?")
print("Welcome ", name, "Vanakkam")

என்பதில் `name =` என்பது எதைக் குறிக்கிறது? இதற்கான விடையைத் தேடுவதற்கு, பைத்தானைக் கொஞ்சம் விலக்கி வைப்போம். நம்முடைய அன்றாட வாழ்க்கையைக் கொஞ்சம் சிந்திப்போம். நம்முடைய வாழ்க்கையில் நாளும் பல செயல்களை நாம் செய்கிறோம். தூங்குகிறோம், விளையாடுகிறோம், கடைக்குப் போய்ப் பொருட்கள் வாங்குகிறோம், இப்படிப் பல செயல்களைச் சொல்லலாம்.

இந்த வேலைகளில் சில வேலைகளில் நமக்கு வெளியீடாக ஏதாவது ஒரு பொருள் கிடைக்கும். சான்றுக்கு, நீங்கள் சமைக்கிறீர்கள் என்று வைத்துக் கொள்வோம். சமையலின் வெளியீடாக உணவு கிடைக்கும். ஆனால், நாம் செய்யும் எல்லா வேலைகளுக்கும் இப்படிப்பட்ட வெளியீடுகள் கிடைக்கும் என்று சொல்லி விட முடியுமா? பொழுது போகவில்லை என்று நண்பர்களுடன் கொஞ்ச நேரம் அரட்டை அடிக்கிறோம் என்று வைத்துக் கொள்ளுங்கள். அரட்டை அடித்தல் என்னும் வேலையின் வெளியீடு என்ன? ஒன்றுமில்லை அல்லவா!

இப்படியாக, நாம் செய்யும் சில வேலைகளில் வெளியீடு கிடைக்கும், சில வேலைகளுக்கு வெளியீடு கிடைக்காது. எந்த வேலைகளில் வெளியீடு கிடைக்கிறதோ, அவ்வெளியீடுகளை எதிர்காலத்திற்குத் தேவைப்பட்டால் நாம் சேமித்து வைப்போம் அல்லவா? (உணவை எடுத்து, பாத்திரத்தில் வைப்பது போல)

அப்படித்தான், input() என்னும் செயல்கூற்றிலும் நடந்திருக்கிறது. `input(“What is your name? “)` என்று கேட்டதும் நாம் என்ன உள்ளீடு கொடுக்கிறோமோ அது, name என்னும் பெயரில் பைத்தானில் சேமிக்கப்படுகிறது. சேமிக்கப்பட்ட பெயரை, print() செயல்கூற்றிற்கு உள்ளீடாகக் கொடுத்து அச்சிட்டுப் பார்க்கிறோம் (print என்றால் அச்சிடுவது தானே!)

இப்போது, செயல்கூடி(Function) என்றால் என்ன, அதற்கு உள்ளீடு(Input) கொடுப்பது எப்படி, வெளியீட்டைச் (output) சேமிப்பது எப்படி என்பதெல்லாம் உங்களுக்குப் புரிந்திருக்கும் என்று நம்புகிறேன்.

இப்போதைக்கு, input(), print() என்று ஏற்கெனவே பைத்தானில் இருக்கும் செயல்கூறுகளைப் (Built In Functions) பார்த்திருக்கிறோம். இப்போது ஒரு கேள்வி! இதே போலச் செயல்கூறுகளை நாமும் நம் விருப்பப்படி உருவாக்க முடியுமா? உருவாக்க முடிய வேண்டுமா? முடியும், வேண்டும் என்பது தான் விடை! ஆனால், இப்போதே வேண்டாம். இன்னும் கொஞ்சம் பதிவுகளுக்குப் பிறகு அவற்றைத் தனியே பார்ப்போம்.

மாறிகள் அறிவோமா?

இரண்டு எண்களை num1, num2 என்று இரண்டு ‘மாறி‘களில் சேமித்து வைத்துக் கொள்வோம். அதென்ன திடீரென ‘மாறி‘ என்கிறீர்கள்? ‘மாறி‘ என்றால் என்னவென்று சொல்லவே இல்லையே! என்கிறீர்களா! நீங்கள் கேட்பது சரிதான்!

இதற்கு முன்பு `input()` செயல்கூற்றில் name என்று ஒரு பெயரில் நாம் கொடுத்த பெயரைப் பதிந்து வைத்தோம் அல்லவா! அந்த name தான் மாறி!

ஒருவரிடம் போய் உங்கள் வயது என்ன என்று கேட்கிறோம். இருபது என்று அவர் சொல்கிறார் என்றால்,

age = 20

என்று பதிந்து வைத்துக் கொள்ளலாம். இப்போது பைத்தானைக் கூப்பிட்டு,

print(age) என்று சொன்னீர்கள் என்றால், age என்னும் மாறியில் இருக்கும் 20ஐ அச்சிட்டுக் கொடுக்கும். இந்த ஆண்டு, இருபதாக இருக்கும் அவர் வயது, போன ஆண்டு – பத்தொன்பதாகவும், அடுத்த ஆண்டு – இருபத்து ஒன்றாகவும் மாறி மாறி இருந்திருக்கும் அல்லவா! அதனால் தான் `age` என்பதை மாறி(Variable) என்று சொல்கிறோம். [ஆங்கிலத்தில் Variable, Reference Variable, Identifier என்று பல்வேறு சொற்களில் சொல்வார்கள். எப்படிச் சொன்னாலும் மாறி என்று புரிந்து கொண்டால் போதும்.]

இந்த மாறிகளில் நாம் என்ன வேண்டுமானாலும் பதிந்து வைத்துக் கொள்ளலாம். ஒருவரின் விவரங்களை வாங்கிப் பைத்தானிடம் கொடுத்துச் சேமித்து வைக்கச் சொல்வோமா?

name = 'Perarivalan'
age = 50
height = 5.2
indian = True

இங்கே, name என்பதன் எதிரில் மட்டும் மேற்கோள் குறிகள் கொடுத்து (”) பதிந்திருக்கிறோம் பார்த்தீர்களா? வார்த்தைகளைப் பதிந்து வைக்கும் போது, இப்படி ஒற்றை மேற்கோள் குறியோ, இரட்டை மேற்கோள் குறியோ (`'` அல்லது `"`) கொடுத்துப் பதிய வேண்டும்.

`indian` என்னும் மாறிக்கு நேரே `True` என்று கொடுத்திருக்கிறோம். அதில் T ஐப் பெரிய எழுத்தாகக்(capital letter) கொடுத்திருக்கிறோம் பார்த்தீர்களா? True / False ஐ இப்படிப் பெரிய எழுத்தாகக் கொடுப்பது பைத்தானின் மரபு.

இப்படிக் கொடுத்திருப்பதை அச்சிட்டுப் பார்க்க விரும்பினால்,

print(name)
print(age)
print(height)
print(indian)

என்று கொடுக்கலாம். சரி, ஒரு வீட்டுப்பாடம் கொடுக்கட்டுமா? மேல் உள்ள மாறிகள் நான்கையும் அவற்றை அச்சிடும் நான்கு வரிகளையும் சேர்த்து, third.py என்னும் பைத்தான் நிரலில் சேமித்து வெளியீட்டைப் பார்க்க வேண்டும். செய்வீர்களா? நீங்கள் செய்வீர்களா? செய்து முடியுங்கள். அடுத்த அத்தியாயத்தில் பார்க்கலாம்.

11. வாங்க பழகலாம்!

இது வரை பார்த்த பதிவுகளில் பைத்தான் நிரலை எப்படி எழுதுவது? உள்ளீடு எப்படிக் கொடுப்பது? அச்சிடுவது எப்படி? என்று பார்த்திருக்கிறோம்.

ஆனாலும் பைத்தானின் எளிமையை, இனிமையை இன்னும் முழுமையாக நாம் சுவைக்கவில்லை. அதைத் தான் இந்தப் அத்தியாயத்தில் சுவைக்கப் போகிறோம்.

இரண்டு எண்களில் பெரிய எண் எது? இரண்டு எண்களில் பெரிய எண்ணை எப்படிக் கண்டுபிடிப்பது?

• முதல் எண்ணை வாங்குங்கள்.
• இரண்டாவது எண்ணை வாங்குங்கள்.
• முதல் எண், இரண்டாவது எண்ணை விடப் பெரியது என்றால், முதல் எண்ணை அச்சிடுங்கள்.
• இல்லையென்றால், இரண்டாவது எண்ணை அச்சிடுங்கள்.

இவ்வளவு தானே படிநிலைகள். இதைப் படமாக வரைந்து பார்ப்போமா?

இந்தப் படம் புரிந்து விட்டது அல்லவா? இதைவிடப் பைத்தான் எளிது.

no1 = 100
no2 = 200
if no1 > no2:
    print(no1)
else:
    print(no2)

இதில் நினைவில் கொள்ள வேண்டிய சில கருத்துகள் இருக்கின்றன.

• பெரியது என்றால், சிறியது என்றால் என்று தமிழில் சொல்கிறோம் அல்லவா? இந்த “என்றால்” தான், பைத்தானில் if.
• `if`ஐத் தொடர்ந்து நாம் கொடுக்க வேண்டிய ஒப்பீட்டைக் கொடுக்க வேண்டும்.
• மறக்காமல் ஒப்பீட்டுக்குப் பிறகு, `:` கொடுக்க வேண்டும்.
• இல்லையென்றால் என்று தமிழில் சொல்வதை, else என்று சொல்ல வேண்டும்.
• மறக்காமல் `:` (colon) கொடுக்க வேண்டும்.

இவ்வளவையும் நினைவில் கொள்ள வேண்டுமா என்று நீங்கள் கேட்கலாம். ஆனால் இவற்றை நினைவில் கொள்வது, மிக எளிது தான்!

தமிழிலோ ஆங்கிலத்திலோ எழுதும் போது காற்புள்ளி(Comma) கொடுக்க வேண்டிய இடத்தில் எல்லாம், பைத்தானில் முக்கால்புள்ளி(`:`) கொடுக்க வேண்டும். முக்கால்புள்ளி(`:`)க்கு அடுத்த வரியை எப்போதும் உள்தள்ளி(Tab) எழுத வேண்டும். தொடக்கத்தில் இந்தக் கட்டுப்பாடுகள் கொஞ்சம் கடினமாகத் தெரிந்தாலும் நாள்படப் பழக்கப்பட்டு விடும். தொடர் பயிற்சி அதை எளிமைப்படுத்தி விடும்.

சரி, இன்றைய வீட்டுப்பாடம் என்ன தெரியுமா? இரண்டு எண்களில் பெரிய எண்ணைக் கண்டுபிடிப்பதற்கான பாய்படத்தை(Flowchart) இப்போதே வரைந்து விட்டோம் அல்லவா? மூன்று எண்களில் பெரிய எண்ணைக் கண்டுபிடிப்பதற்கான பாய்படத்தை வரைந்து வருகிறீர்களா?

12. மூன்று எண்களில் பெரிய எண் எது?

மூன்று எண்களில் பெரிய எண்ணைக் கண்டுபிடிப்பதற்கான பாய்படத்தை(flowchart) வரைந்து வரக் கேட்டிருந்தேன். வரைந்து விட்டீர்களா? நானும் அந்த வீட்டுப்பாடத்தைச் செய்திருக்கிறேன்.

நீங்கள் இது போலவும் செய்திருக்கலாம். மாற்று வழியிலும் செய்திருக்கலாம். உங்கள் பாய்படத்தை github.com தளத்தில் பதிவேற்றி, இணைப்பைக் கருத்துகளில் பதியுங்கள்.

சரி, இப்போது மேல் உள்ள பாய்படத்திற்குப் பைத்தான் நிரல் எழுதுவோமா?

• மூன்று எண்களை வாங்க வேண்டும்.

no1 = 100  
no2 = 200  
no3 = 300

• மூன்று எண்களில் முதல் எண்ணை எடுத்து, மீதி இரண்டு எண்களை விடப் பெரியதாக எனப் பாருங்கள். அப்படியிருந்தால் மட்டும், முதல் எண்ணை அச்சிடுங்கள்.
• இல்லை என்றால், இரண்டாம் எண்ணை எடுங்கள். அதை, முதல் எண்ணோடும் மூன்றாடும் எண்ணோடும் ஒப்பிட்டு, இரண்டாம் எண் பெரியதாக எனப் பாருங்கள். அப்படியிருந்தால் இரண்டாம் எண்ணை அச்சிடுங்கள்.
• அதுவும் இல்லை என்றால், மூன்றாவது எண் தான் பெரியதாக இருக்கும் அல்லவா? அதை அச்சிடுங்கள்.

பைத்தானில் இதை முயன்று பார்ப்போமா?

no1  = 100 # மூன்று எண்களை வாங்க வேண்டும்.
no2  = 200
no3  = 300

if no1>no2 and no1>no3: # மூன்று எண்களில் முதல் எண்ணை எடுத்து, மீதி இரண்டு எண்களை விடப் பெரியதாக எனப் பாருங்கள்
    print("Biggest ", no1) #அப்படியிருந்தால் மட்டும், முதல் எண்ணை அச்சிடுங்கள்.
elif no2>no1 and no2>no3: # இல்லை என்றால், இரண்டாம் எண்ணை எடுங்கள். அதை, முதல் எண்ணோடும் மூன்றாடும் எண்ணோடும் ஒப்பிட்டு, இரண்டாம் எண் பெரியதாக எனப் பாருங்கள்.
    print("Biggest ", no2) # அப்படியிருந்தால் இரண்டாம் எண்ணை அச்சிடுங்கள்.
else: # அதுவும் இல்லை என்றால், மூன்றாவது எண் தான் பெரியதாக இருக்கும் அல்லவா?
    print("Biggest ", no3) # அதை அச்சிடுங்கள்.

இதில் மூன்று எண்களை மாற்றி மாற்றிப் பயன்படுத்தி, நிரல் சரியாக வேலை செய்கிறதா என்று பாருங்கள். இப்போது இந்த நிரலில் புதிதாக, `if, elif, else, and` ஆகியவற்றைப் பயன்படுத்தியிருக்கிறோம். நிரலிலேயே ஒவ்வொரு வரியிலும் அதற்கான விளக்கம் சேர்க்கப்பட்டிருக்கிறது. புரிகிறதா என்று பாருங்கள்.

வீட்டுப்பாடம்:

• `>` குறி இருக்கும் இடத்தில் `<` குறியை மாற்றிப் பாருங்கள். விடை என்ன வருகிறது என்று பார்த்துப் புரிகிறதா எனச் சொல்லுங்கள்.
• `and` இருக்கும் இடத்தில் `or` பயன்படுத்தி, விடை எப்படி வருகிறது என்று பாருங்கள்.

13. if elif else

“நீங்கள் மூன்று எண்களில் பெரிய எண்ணைக் கண்டுபிடிக்க ஒரு பாய்படம் வரைந்திருந்தீர்கள். ஆனால், நான் வேறொரு படம் வரைந்திருந்தேன். இந்தப் படம் சரியென எனக்குப் படுகிறது. இதற்குப் பைத்தான் நிரல் எழுத முடியுமா?” என்று நண்பர் ஒருவர் கேட்டிருந்தார். உறுதியாக முடியும். பைத்தான் படிக்க வேண்டும் என்னும் அவருடைய முயற்சி பாராட்டுதலுக்குரியது. அவர் வரைந்த பாய்படம்(Flowchart), இது தான்!

அந்தப் படத்திற்கு உரிய படிகளை முதலில் எழுதுவோம். பிறகு, பைத்தான் நிரலாக அதை மாற்றலாம்.

• 1 முதலில் மூன்று எண்களை வாங்கிக்கொள்ளுங்கள்.
• 2 முதல் எண்ணை எடுத்து, இரண்டாவது எண்ணை விடப் பெரியதாக எனப் பாருங்கள். அப்படி இருந்தால்,
• 2.1 இப்போது, முதல் எண், மூன்றாவது எண்ணை விடப் பெரியதா எனப் பாருங்கள்.
• 2.2 அப்படியும் இருந்தால், முதல் எண்ணை அச்சிடுங்கள்.
• 2.3 முதல் எண், மூன்றாவது எண்ணைவிடப் பெரியது இல்லை எனில் (படி 2.1)
• 2.4 மூன்றாவது எண், இரண்டாவது எண்ணை விடப் பெரியதாக எனப் பாருங்கள்.
• 2.5 அப்படி இருந்தால், மூன்றாவது எண்ணை அச்சிடுங்கள்.
• 3 முதல் எண், இரண்டாவது எண்ணை விடப் பெரியதாக இல்லை என்றால், (படி இரண்டைப் பாருங்கள்),
• 3.1 இரண்டாவது எண், மூன்றாவது எண்ணை விடப் பெரியதாக இருக்கிறதா எனப் பாருங்கள்.
• 3.2 அப்படியிருந்தால், இரண்டாவது எண்ணை அச்சிடுங்கள்.

இந்தப் படிகள் தாம், மேல் உள்ள பாய்படத்திற்கான படிநிலைகள். இப்போது இதைப் பைத்தான் நிரலை மாற்றாக மாற்றுவோமா?

no1 = 100  #1 முதலில் மூன்று எண்களை வாங்கிக்கொள்ளுங்கள்.
no2 = 200
no3 = 300
if no1>no2: #2 முதல் எண்ணை எடுத்து, இரண்டாவது எண்ணை விடப் பெரியதாக எனப் பாருங்கள். அப்படி இருந்தால்,
    if no1>no3: #2.1 இப்போது, முதல் எண், மூன்றாவது எண்ணை விடப் பெரியதா எனப் பாருங்கள்.
        print("Biggest", no1) #2.2 அப்படியும் இருந்தால், முதல் எண்ணை அச்சிடுங்கள்.
    elif no3>no2: #2.3 முதல் எண், மூன்றாவது எண்ணைவிடப் பெரியது இல்லை எனில் (படி 2.1) 2.4 மூன்றாவது எண், இரண்டாவது எண்ணை விடப் பெரியதாக எனப் பாருங்கள்.
        print("Biggest", no3) #2.5 அப்படி இருந்தால், மூன்றாவது எண்ணை அச்சிடுங்கள்.
else: #3 முதல் எண், இரண்டாவது எண்ணை விடப் பெரியதாக இல்லை என்றால், (படி இரண்டைப் பாருங்கள்),
    if no2>no3:#3.1 இரண்டாவது எண், மூன்றாவது எண்ணை விடப் பெரியதாக இருக்கிறதா எனப் பாருங்கள்.
        print("Biggest", no2) #3.2 அப்படியிருந்தால், இரண்டாவது எண்ணை அச்சிடுங்கள்.

இந்த நிரல் மூலம், ஒரு கட்டளை(condition)க்குள் இன்னொரு கட்டளை(condition)யைக் கொடுப்பதைக் கற்றுக் கொண்டிருக்கிறோம். அதாவது, ifக்குள் ஒரு if கொடுத்திருக்கிறோம். else: என்பதற்குக் கீழ், ஒரு if கொடுத்திருக்கிறோம். தேவைப்படும் இடங்களில் இப்படியும் முயலலாம்.

இந்த நிரல் மூலம் பைத்தானில் என்னென்ன கற்றுக் கொண்டோம் என்று குறித்து வைத்துக் கொள்ளுங்கள். சரி, இப்போது no1, no2, no3 ஆகியவற்றில் புதுப்புது எண்களைக் கொடுத்துப் பாருங்கள். உங்கள் நிரல் சரியா வேலை செய்கிறதா என்று பார்த்து விடுங்கள். ஒரு வேளை சரியாக வேலை செய்யவில்லை என்றாலும் கவலைப்பட வேண்டாம். அதைப் பிறகு பொறுமையாக, வீட்டுப்பாடமாகச் சரி செய்து கொள்ளலாம்.

இப்போது if, elif, else ஆகியன என்ன செய்கின்றன என்று புரிந்து கொண்டீர்கள் என்றால் போதும். இந்தப் புரிதலே அடுத்த அத்தியாயத்தில் வரும் whileஐச் சரியாகப் புரிந்து கொள்ள உதவும்.

while படிக்கப் போவோமா ஊர்கோலம்? பைத்தான் படிக்க, பூலோகம் எங்கெங்கும்?

14. while

இது வரை if elif else பார்த்திருக்கிறோம். இந்தப் அத்தியாயத்தில் while பார்க்கப் போகிறோம். while என்னும் ஆங்கிலச் சொல்லின் பொருள் என்ன? எப்போது என்பது! இதை எதற்கு நிரல் மொழிகளில் பயன்படுத்துகிறார்கள்? ஓர் எடுத்துக்காட்டு சொல்கிறேன் பாருங்களேன். `1` என்று ஐந்து முறை அச்சிட வேண்டும் எப்படி நிரல் எழுதுவது?

print(1)
print(1)
print(1)
print(1)
print(1)

இந்த நிரல் சரியா என்று கேட்டால் மிகச் சரி என்று சொல்ல வேண்டும். இந்த நிரல் தவறா என்று கேட்டால் அப்போதும் ஆமாம் என்று சொல்ல வேண்டும். என்ன உளறுகிறீர்கள் – சரி என்றும் சொல்ல வேண்டும் தவறு என்றும் சொல்ல வேண்டுமா? எப்படி என்கிறீர்களா?

இதற்கான விடையைத் தேடுவதற்கு முன், உங்களிடம் ஒரு கேள்வி – நிரலாக்கம்(Programming) ஏன் படிக்க வேண்டும்?

• துல்லியமான விடையைக் கொடுப்பது.
• துல்லியமான விடையையும் மிக மிகக் குறைந்த நேரத்தில் கொடுக்க வேண்டும்.
• நிரல், சின்ன உள்ளீடுகளுக்கும் பொருந்த வேண்டும், பெரிய உள்ளீடுகளுக்கும் பொருந்த வேண்டும். (இது புரியவில்லை என்றாலும் இப்போதைக்கு விட்டு விடுங்கள். பிறகு கட்டாயம் பேசுவோம்!)

இவை மூன்றையும் தவிர, இன்னும் சில விடைகளை நீங்கள் சொல்லலாம். சரி தான்! இருந்தாலும் இவை மூன்றும் நிரலாக்கம் ஏன் தேவை என்பதற்கான அடிப்படையான கருத்துகள்!

இந்தக் கருத்துகளை இப்போது ஏன் பேச வேண்டும்? காரணம் இருக்கிறதா? இருக்கிறதே! மேல் உள்ள நிரல், இந்த மூன்றையும் நிறைவு செய்கிறதா என்று பாருங்கள். முதல் இரண்டைக் கட்டாயம் நிறைவு செய்யும். எனவே, மேல் உள்ள நிரல் சரியான நிரல் தான்!

ஆனால், மூன்றாவது கருத்தை மேல் உள்ள நிரல் நிறைவு செய்கிறதா? மூன்றாவது கருத்து என்ன? ஒரு நிரல், சின்ன உள்ளீடுகளுக்கும் வேலை செய்ய வேண்டும், பெரிய உள்ளீடுகளுக்கும் வேலை செய்ய வேண்டும்.

மேல் உள்ள நிரல், `1` என்பதை ஐந்து முறை அச்சிட மிகச் சரியாக வேலை செய்யும். அதாவது இங்கு ‘ஐந்து முறை’ என்பது தான் உள்ளீடு. ஐந்தாயிரம் முறை `1` என்பதை அச்சிட வேண்டும் என்றால் என்ன செய்வீர்கள். ஐந்தாயிரம் முறை, `print(1)` என்று கொடுப்பீர்களா? சொல்லுங்களேன். ஐந்தாயிரம் முறை, `print(1)` என்று கொடுத்து அச்சிடுவதைக் காட்டிலும் ஒரு தாளை எடுத்து, மனித முயற்சியில் ஐந்தாயிரம் முறை `1` என்று எழுதுவதே சாலச் சிறந்ததல்லவா?

எனவே, மேல் உள்ள நிரல், சின்ன அளவில் சரியாகவும் பெரிய அளவில் தவறாகவும் இருக்கிறது என்பது இப்போது உங்களுக்குப் புரிந்திருக்கும்.

இதை எப்படிச் சரி செய்வது? ஒன்று செய்யலாம். நம் மனத்திற்குள் ஒவ்வொரு முறை `1` என்று அச்சிடுவதையும் கணக்கிட்டுக் கொள்வோம். எப்போது, கணக்கில் ஐந்து முறை வருகிறதோ அப்போது அச்சிடுவதை நிறுத்தி விடலாம். சரியான தீர்வாகத் தெரிகிறதா? முயன்று பார்ப்போமே!

count = 1
if count<=5:
    print(1)
    count+=1 # மனத்தில் இந்தக் கணக்கை வைத்துக் கொள்வோம்.
if count<=5:
    print(1)
    count+=1
if count<=5:
    print(1)
    count+=1
if count<=5:
    print(1)
    count+=1
if count<=5:
    print(1)
    count+=1

இது தான் நமக்குத் தெரிந்த முறை. இது எளிதாகப் புரிகிறது. ஆனால், இந்த முறையும் சிக்கலைத் தீர்க்கவில்லை. சிக்கலைத் தீர்க்கவில்லை என்பது மட்டுமல்லாமல் சிக்கலைப் பெரிதுபடுத்தி விட்டது பாருங்கள். `1` என்பதை அச்சிட `print(1)` என்று ஐந்து வரிகளில் இருந்த நிரல், இப்போது பதினைந்து வரிகள் வந்து நிற்கிறது. பதினைந்து வரிகள் நிற்பது மட்டுமில்லை, இப்போது ஐந்தாயிரம் முறை `1`என்பதை அச்சிட வேண்டும் என்றால் என்ன செய்வது?

தீர்வை நோக்கிப் போவதாக நினைத்து, எதிர்த்திசையில் பயணிக்கிறோமோ என்னும் உணர்வைக் கொடுத்திருக்கிறது அல்லவா? இதை எப்படித் தீர்ப்பது? தொடக்கப்பள்ளிப் பாடத்தில் இருந்து தான்! தொடக்கப்பள்ளிப் பாடமா? ஆமாம்! தொடக்கப்பள்ளியில் படித்த கணக்கில் இருந்து தான் பாடம் படிக்கப் போகிறோம். ஐந்து முறை இரண்டைக் கூட்டினால் என்ன கிடைக்கும்?

2+2+2+2+2 = 10

இப்படி எழுதுவதைத் தானே, `2\*5 = 10` என்று சுருக்கி எழுதுவோம். அதாவது, கூட்டலின் சுருக்கம் தான் பெருக்கல். இந்தப் பாடம் புரிவது போதும். எப்படிக் கூட்டலின் சுருக்கம் என்பது பெருக்கலோ அதைப் போலவே, if என்பதன் சுருக்கம் while. பலமுறை கூட்டல் குறியீட்டை(`+`) எழுதுவதற்கு மாற்றாக, ஒரு முறை பெருக்கல் குறியீட்டை(`\*`) எழுதுவது போல, பல முறை if எழுதுவதற்கு மாற்றாக, ஒரே ஒரு முறை, `while` எழுதினால் போதும்.

count = 1 #1. முதலில் மனத்தில் இருக்கும் countஇன் மதிப்பு 1
while count<=5: #2. countஇன் மதிப்பு ஐந்துக்குக் கீழ் இருக்கும் வரை:
    print(1) #3. 1 என அச்சிடுக.
    count+=1 #4. countஉடன் ஒன்று கூட்டிக் கொள்க.

என்று எழுதினால் போதும். இப்போது while நன்றாகப் புரிந்திருக்குமே!

இப்போது வீட்டுப்பாடமாக:

• மேல் உள்ள நிரலுக்குப் பாய்வுப்படம்(Flow chart) வரைந்து வாருங்கள்.
• மேல் உள்ள நிரலில் `print(1)` என்பதை மாற்றி print(count) என்று கொடுங்கள். அப்போது வரும் வெளியீடு புரிகிறதா எனப் பாருங்கள்.
• மேல் உள்ள நிரலில் `print(1)` என்பதை மாற்றி `print(count\*2)` என்று கொடுங்கள். அப்போது வரும் வெளியீடு புரிகிறதா எனப் பாருங்கள்.
• மேல் உள்ள நிரலில் `print(1)` என்பதை மாற்றி `print(count\*count)` என்று கொடுங்கள். அப்போது வரும் வெளியீடு புரிகிறதா எனப் பாருங்கள்.
• மேல் உள்ள நிரலில் `print(1)` என்பதை மாற்றி `print(count\*count\*count)` என்று கொடுங்கள். அப்போது வரும் வெளியீடு புரிகிறதா எனப் பாருங்கள்.

15. while 2

முந்தைய அத்தியாயத்தில் வீட்டுப்பாடம் கொடுத்திருந்தோமே! செய்து விட்டீர்களா? முதல் வீட்டுப்பாடம், முந்தைய அத்தியாயத்தில் பார்த்த நிரலுக்குப் பாய்வுப்படம் வரைவது.

முதல் நிரல்:

count = 1 #1. முதலில் மனத்தில் இருக்கும் countஇன் மதிப்பு 1
while count<=5: #2. countஇன் மதிப்பு ஐந்துக்குக் கீழ் இருக்கும் வரை:
    print(1) #3. 1 என அச்சிடுக.
    count+=1 #4. countஉடன் ஒன்று கூட்டிக் கொள்க.

பாய்வுப்படம்:

பாடம் #2:

count = 1 #1. முதலில் மனத்தில் இருக்கும் countஇன் மதிப்பு 1
while count<=5: #2. countஇன் மதிப்பு ஐந்துக்குக் கீழ் இருக்கும் வரை:
    print(count)
    count+=1 #4. countஉடன் ஒன்று கூட்டிக் கொள்க.

பாடம் #3:

count = 1 #1. முதலில் மனத்தில் இருக்கும் countஇன் மதிப்பு 1
while count<=5: #2. countஇன் மதிப்பு ஐந்துக்குக் கீழ் இருக்கும் வரை:
    print(count*2)
    count+=1 #4. countஉடன் ஒன்று கூட்டிக் கொள்க.

பாடம் #4:

count = 1 #1. முதலில் மனத்தில் இருக்கும் countஇன் மதிப்பு 1
while count<=5: #2. countஇன் மதிப்பு ஐந்துக்குக் கீழ் இருக்கும் வரை:
    print(count*count)
    count+=1 #4. countஉடன் ஒன்று கூட்டிக் கொள்க.

சரி, இந்தப் பாடங்களைப் பார்த்து விட்டோம். இப்போது முதல் நிரலை எடுத்துக் கொள்ளுங்கள்; அதன் பாய்வுப் படத்தையும் பார்த்துக் கொள்ளுங்கள். அந்தப் பாய்வுப் படத்தைக் கொஞ்சம் மாற்றிக் கீழ் உள்ளவாறு வரைந்திருக்கிறேன். இதில் இருக்கும் மாற்றம் புரிகிறதா எனப் பாருங்கள்.

நிரல்:

total = 0 # 1. மொத்தம் முதலில் சுழி.
count = 1 # 2. countஇன் தொடக்க மதிப்பு 1
while count<=5: # 3. count, ஐந்தாகும் வரை
    total = total + count # 4. ஒவ்வொரு முறையும் மொத்தத்துடன் countஐக் கூட்டுக
    count = count + 1 # 5. countஐ ஒவ்வொரு முறையும் கூட்டுக
print(total)

இந்த மாற்றம் புரிந்தால், உங்களுக்குப் புரிந்ததைக் குறித்து வைத்துக் கொள்ளுங்கள். உங்கள் புரிதலும் என் புரிதலும் இணைந்து பயணிக்கிறதா? பயணம் தொடரட்டும், பாதை மலரட்டும்.

16. மோகனா? மன்னனா? வென்றது யார்?

பயணம் தொடரட்டும், பாதை மலரட்டும் என்றெல்லாம் போன அத்தியாயத்தில் முடித்திருந்தீர்கள். நாங்களும் நீண்ட நாட்களாகக் காத்திருக்கிறோம், நீங்கள் வேறு பயணத்திற்குள் நுழைந்து விட்டீர்களா? ஆளையே காணோமே என்று நண்பர்கள் சிலர் செல்லமாகக் கடிந்து கொண்டார்கள்.

ஆமாம், உண்மை தான்! கல்வெட்டுப் பயிற்சி ஒன்றைத் தமிழ்நாட்டு அரசின் உலகத் தமிழாராய்ச்சி நிறுவனம் நடத்தி வருகிறது. அந்தப் பயிற்சிக்குள் நுழைந்து தமிழியைப் படித்துக் கொண்டிருந்தேன். தமிழியை எடுத்த போது, தமிழ்க் கணினியைக் கொஞ்சம் விட்டு விட்டேன். முன்னைப் பழமைக்கும் தமிழே துணை, பின்னைப் புதுமைக்கும் தமிழே துணை என்பதாக இருக்கிறது என்னுடைய தற்போதைய நிலை. கல்வெட்டிலும் தமிழ், கணினியிலும் தமிழ் என்று எங்கும் தமிழைப் பார்க்கும் போது மகிழ்ச்சி தானே!

வாருங்கள், இனித் தொடர்ந்து பயணிப்போம். முந்தைய பதிவுகளில் while பற்றிப் பார்த்துக் கொண்டிருந்தோம் அல்லவா? அதையே தொடரலாம். அதற்கு முன்பாக, ஒரு கதை சொல்லட்டுமா?

மன்னருக்கு வந்த கேள்வி

ஓர் ஊரில் ஒரு மன்னர் இருந்தார். மன்னருக்குத் திடீரென மூடி வைக்கப்பட்ட விண்டோஸ் நல்ல மென்பொருளா? கட்டற்ற மென்பொருளாக இருக்கும் லினக்ஸ் நல்ல மென்பொருளா என்று சந்தேகம் வந்து விட்டது. எல்லா மென்பொறியாளர்களையும் கூப்பிட்டுக் கேட்டார். யார் சொன்ன விடையும் அவருக்கு நிறைவைத் தரவில்லை. அப்போது ஒருவர் “மன்னா! ‘தமிழ் லினக்ஸ் கம்யூனிட்டி'(Tamil Linux Community) என்றொரு டெலிகிராம் குழு இருக்கிறது. அங்கே இதைப் பற்றிப் பேசுவார்கள். அந்தக் குழுவை வழிநடத்தும் மோகனைக் கூப்பிட்டால் இதற்கு விடை கிடைத்து விடும்” என்று சொல்ல, மன்னரும் மோகனைக் கூப்பிட்டு விடுகிறார்.

மோகனுக்கோ, ‘இந்தக் கேள்விக்குக் கூட விடை தெரியாமல் இவர் எப்படி மன்னர் ஆனார்?’ என்று மனத்திற்குள் நினைப்பு. இருந்தாலும் சரி, மன்னருக்கு விடை சொல்வோம் என்று நினைத்துக் கொண்டார். ‘மன்னா! கட்டற்ற மென்பொருள் தான் சிறந்தது! உங்கள் கையில் கணினியின் கட்டுப்பாடு இருக்கும்! இல்லையென்றால் உலகத்தையே ஆளும் மன்னராக நீங்கள் இருந்தாலும் உங்கள் கணினி ஓட்டைக் கணினி தான்’ என்று மன்னருக்குப் புரியும் வகையில் மோகன் விடை சொல்லி விடுகிறார்.

மன்னருக்கோ ஒரே மகிழ்ச்சி! ‘உமக்கு என்ன வேண்டுமோ கேளுங்கள்! என் அரசு அதைக் கொடுக்கும்’ என்கிறார். ‘உங்கள் ஆட்சி மன்னர் ஆட்சியாக இல்லாமல் மக்கள் ஆட்சியாக இருக்க வேண்டும்’ என்பது கேட்கத் தான் மோகனுக்கு ஆசை. ஆனால் அதைக் கேட்டுப் புரியும் திறன், மன்னருக்கு இருக்க வேண்டுமே! ‘இல்லை எனக்கு எதுவும் வேண்டாம். நீங்களும் கேரள அரசு செய்திருப்பதைப் போல, லினக்ஸை அரசு அலுவலகங்கள், பள்ளிகள், கல்லூரிகளில் செயல்படுத்தி விடுங்கள்’ என்கிறார் மோகன். ‘அதைப் பின்னர் செய்வோம், உனக்கு என்ன வேண்டும் சொல்! ஒரு கிலோ தங்கமா? பத்துக் கிலோ தங்கமா?’ என்று கேட்கிறார் மன்னர். ‘நாட்டுக்கு நல்லது செய்யுங்கள் என்று கேட்டால், மன்னராக இருந்து கொண்டு, தங்கக் கடை நடத்துபவர் போல் நடந்து கொள்கிறாரே!’ என்று மோகனுக்குக் கொஞ்சம் வருத்தம்.

தங்கம் வேண்டாம்! நெல்மணி போதும்!

‘சரி, இந்த மன்னருக்கு நாம் ஒரு பாடம் கற்பிக்க வேண்டும்’ என்று முடிவு செய்து கொள்கிறார் மோகன். மோகனின் வலப்பக்கத்தில் ஒரு சதுரங்க அட்டை தொங்கிக் கொண்டிருந்தது. அதைப் பார்த்த மோகனுக்குப் பிறந்தது சட்டென ஒரு திட்டம். “மன்னா! எனக்குத் தங்கம் எல்லாம் வேண்டாம்! இந்தச் சதுரங்கப் பலகையில் உள்ள முதல் சதுரத்திற்கு ஒரு நெல்மணியை எனக்குப் பரிசாகத் தாருங்கள் போதும்” என்கிறார்.

“ஒரு நெல்மணியா? அவ்வளவு தானா? போதுமா?” என மன்னருக்கோ அதிர்ச்சி. “ஆம்! மன்னா! இரண்டாவது சதுரத்திற்கு இரண்டு நெல்மணியும் மூன்றாவது சதுரத்திற்கு நான்கும், நான்காவது சதுரத்திற்கு எட்டும், ஐந்தாவது சதுரத்திற்குப் பதினாறும்..”

“போதும் ஐயா! நிறுத்தும்! இப்படியே சதுரங்கப் பலகையில் இருக்கும் அறுபத்து நான்கு கட்டங்களுக்கும் நெல்மணிகளைப் பெற்றுக் கொள்ளுங்கள்! இது அரசரின் கட்டளை” என்றார்.

கிலோ கணக்கில் தங்கம் கிடைத்த போதும் வேண்டாமென மறுத்த மோகன் எடுத்த முடிவு சரியா? வென்றது மோகனா? மன்னரா? சிந்தித்து வையுங்கள். உங்கள் சிந்தனையைப் பைத்தான் நிரலாகச் செயல்படுத்திப் பார்ப்போம், அடுத்த அத்தியாயத்தில்!

17. வென்றது வியனா? அப்பாவா?

மன்னரிடம் நெல்மணிகள் கேட்ட கதையில் வென்றது மோகனா? மன்னரா? கண்டுபிடித்து விட்டீர்களா? மோகன் தான் எனக் கண்டுபிடித்திருப்பீர்கள்.

முதல் சதுரத்திற்கு ஒரு நெல்மணி, இரண்டாவது சதுரத்திற்கு இரண்டு நெல்மணி, மூன்றாவது சதுரத்திற்கு நான்கு நெல்மணி என அறுபத்து நான்குக் கட்டங்களுக்கும் கண்டுபிடித்தால் மொத்தம் 18,446,744,073,709,551,615 நெல்மணிகள் தேவைப்படும். இந்த நெல்மணிகளை எடுத்து வைக்க மட்டுமே மன்னருக்கு சூரியனின் தொலைவு போன்று இரண்டு மடங்கு தேவைப்படும்.(நன்றி: செயல்வழிக் கணிதம், அரவிந்த் குப்தா) இதை எப்படி மன்னரால் கொடுக்க முடியும்? எனவே, மோகனின் கணித அறிவு அவரை வெற்றியாளராக்கியது என்பதை உணர்ந்திருப்பீர்கள். சரி இதை எப்படிப் பைத்தானில் நிரலாகச் செய்வது?

• மொத்தம் எத்தனை கட்டங்கள்? அறுபத்து நான்கு
• ஒவ்வொரு கட்டத்திலும் இருக்கும் நெல்மணிகளின் எண்ணிக்கை என்ன? முதல் கட்டத்தில் ஒன்று, இரண்டாவது கட்டத்தில் இரண்டு, மூன்றாவதில் நான்கு, என இரண்டின் மடங்குகளாகப் பெருகுகின்றன.
• இவற்றின் படி, முதல் கட்டத்தில் தொடங்கி அறுபத்து நான்கு கட்டங்களுக்கு நகர வேண்டும். சரி தானே!

நெல்மணி = 1 #முதல் கட்ட நெல்மணி
கட்டம் = 1 #முதல் கட்டத்தில் இருந்து நெல்மணிகள் கூடத் தொடங்குகின்றன.
while கட்டம்<=64:
    print(கட்டம், " ஆவது கட்டத்திற்கான நெல்மணி ", நெல்மணி)
    நெல்மணி = 2**கட்டம் # ** என்பது பைத்தானில் அடுக்கைக் குறிக்கும்
    கட்டம்+=1
else:
    print("கடைசியில் ", நெல்மணி)

சரி, இப்போது இன்னொரு கதை சொல்லட்டுமா?

வியன் என்றொரு சிறுவன். மூன்றாம் வகுப்பு படித்து வருகிறான். தினமும் பள்ளிக்கூடத்திற்குப் போகும் போது தின்பண்டங்கள் வாங்க வேண்டும் என்பது அவனது நீண்ட நாளைய ஆசை. அவனுடைய அப்பாவிடம் போய், ‘பள்ளிக்கூடத்திற்குப் போகும் போது தின்பண்டங்கள் வாங்கித் தின்ன வேண்டும் என எனக்கு ஆசையாக இருக்கிறது. இன்னும் பத்து நாட்கள் தாம் பள்ளிக்கூடம் இருக்கிறது. எனவே ஒவ்வொரு நாளும் ஐந்து ரூபாய் கொடுப்பீர்களா?” என்று கேட்கிறான்.

‘ஒவ்வொரு நாளும் ஐந்து ரூபாய்க்குத் தின்பண்டமா?’ என்று அவன் அப்பா யோசிக்கிறார். யோசித்து, ‘ஒவ்வொரு நாளும் ஐந்து ரூபாய் என்பது அதிகமாகத் தெரிகிறதே!’ என்கிறார். ‘ஐந்து ரூபாய் அதிகம் என்றால், நான் இன்னொரு வழி சொல்கிறேன் அப்பா! முதல் நாள் ஒரு ரூபாய், இரண்டாவது நாள் இரண்டு ரூபாய், மூன்றாவது நாள் மூன்று ரூபாய், என்று பத்து நாளும் கொடுங்கள்’ என்கிறான் வியன். அப்பாவுக்குப் பையனின் அறிவுக்கூர்மையை நினைத்து வியப்பு! ‘வியன் என்னும் பெயருக்கு ஏற்ப நம்மை வியக்க வைக்கிறானே!’ என்று நினைத்துக் கொண்டே, ‘சரி! அப்படியே செய்யலாம்’ என்கிறார்.

நீங்கள் சொல்லுங்கள், வியனின் முதல் திட்டத்தில் அப்பாவுக்குச் செலவு அதிகமா? இரண்டாவது திட்டத்தில் செலவு அதிகமா? சிந்தித்து வைக்கிறீர்களா? அதையே பைத்தான் நிரலாக அடுத்த அத்தியாயத்தில் செய்து விடுவோம்!

18. யார், எத்தனை தோசை சாப்பிட்டார்கள்?

முந்தைய அத்தியாயத்தில் வியனின் அப்பா, அவனுடைய அறிவைப் பார்த்து வியந்தார் என்று சொன்னேன் அல்லவா! அதற்குக் காரணம் இருக்கிறது.

முதலில் வியன் என்ன கேட்கிறான்? இன்னும் பத்து நாட்கள் பள்ளிக்கூடம் போக வேண்டும்; ஒரு நாளைக்கு ஐந்து ரூபாய் எனப் பத்து நாளும் தாருங்கள் எனக் கேட்கிறான்.

மொத்தச்_செலவு = 0 #முதல் நாள் 5 ரூபாய் கொடுப்பதற்கு முன்
நாள் = 1 #முதல் நாள்
பணம் = 5 # முதல் நாள் கொடுக்கும் பணம்
while நாள்<=10: # பத்து நாள் வரை
    மொத்தச்_செலவு = மொத்தச்_செலவு + பணம்
    நாள்+=1 #ஒவ்வொரு நாளாகக் கூடும்
else:
    print(மொத்தச்_செலவு)

இப்படிக் கொடுத்தால் கடைசியில் 50 ரூபாய் செலவாகியிருக்கும். பத்தே நாளில் ஐம்பது ரூபாயைத் தின்பண்டத்திற்குக் கொடுக்கவா என அப்பா யோசிக்கும் போதே, ‘அப்படியானால் முதல் நாள் ஒரு ரூபாய், இரண்டாவது நாள் இரண்டு ரூபாய், மூன்றாவது நாள் மூன்று ரூபாய்’ எனக் கேட்கிறான் வியன். கேட்பதற்கு ஏதோ குறைவான தொகை தானே கேட்கிறான் எனத் தோன்றினாலும் கணக்குப் போட்டுப் பார்த்தால் கூட வருவது தெரியும். பார்ப்போமா?

மொத்தச்_செலவு = 0 #முதல் நாளுக்கு முன்
நாள் = 1
while நாள்<=10:
    மொத்தச்_செலவு = மொத்தச்_செலவு + நாள்#எந்த நாளோ அவ்வளவு பணம்
    நாள்+=1
else:
    print(மொத்தச்_செலவு)

இப்படிப் பார்க்கும் போது தான், மொத்தச் செலவு ஐம்பத்து ஐந்து ரூபாய் வருகிறது எனத் தெரியும். இதைத் தான் வியனின் அப்பா முதலிலேயே கணித்தார்.

வீட்டுப்பாடம்:

மேல் உள்ள இரண்டு நிரல்களுக்கும் பாய்வுப் படம்(Flow chart) வரைந்து பாருங்கள்.

யார், எத்தனை தோசை சாப்பிட்டார்கள்?

யாழினி, குழலி, நிறைமதி மூவரும் நண்பர்கள். கடும் உழைப்பாளிகள். மூவரும் வேலை முடித்து இரவு வர நேரம் ஆகிவிடும். முதலில் வீட்டில் சமைத்துச் சாப்பிட்டார்கள். ஆனால் வேலைப்பளு காரணமாகச் சமைக்க முடிவதில்லை. சரி, உணவகத்தில் சாப்பிடலாம் எனச் சாப்பிடத் தொடங்கினார்கள். ஆனால் தொடரும் கேஸ் விலை காரணமாக உணவகங்களும் விலையை ஏற்றத் தொடங்கியிருந்தார்கள். அவர்களும் என்ன தான் செய்வார்கள்? இரண்டு ஆண்டுகளில் இரண்டு மடங்கு விலையை உயர்த்தியிருக்கிறது அரசு. [பார்க்க: iocl.com/Indane-19Kg-Previous-Price]

அரசு சிலிண்டர் விலையை உயர்த்த, கடைக்காரர்கள் கட்டுப்படி ஆகாமல் பொருள் விலையை உயர்த்த, கடினமாக உழைத்து இப்படி வீணாய்ப் போகிறதே என்று அங்கலாய்த்துக் கொண்டார்கள் யாழினி, குழலி, நிறைமதி மூவரும். ‘சரி! இனி என்ன ஆனாலும் சரி, வீட்டிலேயே சமைத்துச் சாப்பிடுவோம், அது தான் உடலுக்கும் நல்லது, பர்சுக்கும் நல்லது’ என்று முடிவெடுத்துக் கொண்டார்கள். ஆனால், மூவரும் வேலைக்குப் போவதால் ஒழுங்காகச் சமைக்க முடியவில்லை. பக்கத்தில் இருந்த சமையல்காரர் ஒருவரை பணியமர்த்திக் கொண்டார்கள்.

ஒருநாள் இரவு, சமையல்காரர், நிறைய தோசைகளை ஊற்றி ஒரு பாத்திரத்தில் மூடி வைத்து விட்டுக் கிளம்பி விட்டார். வேலை முடித்து வீட்டுக்கு வந்த யாழினி, குழலி, நிறைமதி மூவரும் சாப்பிட உட்கார்ந்தார்கள். அப்போது தான் அவர்களுக்குத் தெரிய வந்தது – நம் வீட்டில் ஒரே ஒரு தட்டுத் தான் இருக்கிறது என்று! சரி, ஒவ்வொருவராகச் சாப்பிடுவோம் என முடிவெடுத்துக் கொண்டார்கள்.

முதலில் யாழினி சாப்பிடத் தொடங்கினாள். பாத்திரத்தில் இருந்த தோசைகளில் மூன்றில் ஒரு பங்குத் தோசையைச் சாப்பிட்டு விட்டு, மீதியை இருவருக்கும் வைத்து விட்டுப் போனாள். அடுத்து குழலி, சாப்பிட வந்தாள். அப்போது இருந்த தோசைகளில் மூன்றில் ஒரு பங்கை அவள் சாப்பிட்டு முடித்தாள். கடைசியாக நிறைமதி வந்தாள். பாத்திரத்தில் தோசைகளைப் பார்த்த நிறைமதி, தன் பங்குக்கு அங்கிருந்த தோசைகளில் மூன்றில் ஒரு பங்கைத் தின்று முடித்தாள். இப்படியே மூவரும் சாப்பிட்டு உறங்கி விட்டார்கள்.

மறுநாள் காலை, சமையல்காரர் வழக்கம் போல வந்து சமைக்கத் தொடங்கினார். ‘நேற்றிரவு தோசை ஊற்றி வைத்திருந்தோமே, மூவரும் சாப்பிட்டார்களா?’ எனப் பாத்திரத்தைத் திறந்து பார்த்தார். அங்கே எட்டுத் தோசைகள் மீதி இருந்தன. மூவரிடமும் போய்த் தோசை சாப்பிட்டீர்களா எனக் கேட்டார். மூவரும் தத்தம் கணக்கைச் சொன்னார்கள். அவர்கள் சொன்ன கணக்கில் இருந்து, கணக்கில் கெட்டிக்காரரான சமையல்காரர் ஒவ்வொருவரும் எத்தனைத் தோசைகள் சாப்பிட்டார்கள் எனக் கண்டுபிடித்து விட்டார். உங்களால் கண்டுபிடிக்க முடிகிறதா என்று பாருங்களேன். அதையே அடுத்த பைத்தான் நிரலாகச் செய்து பார்ப்போம்!

19. வியன், பாரி வயதைக் கண்டுபிடித்த அன்வர்

யாழினி, குழலி, நிறைமதி மூவரும் தோசை சாப்பிட்ட கதையைப் பார்த்தோம் அல்லவா? அதில் யார் யார் எத்தனைத் தோசை தின்றார்கள் என்று பார்த்து விடுவோமா?

கடைசியில் மீதம் இருந்த தோசை 8. இது நிறைமதி தின்றது போக மீதி வைத்த எண்ணிக்கை. நிறைமதி தின்றது மூன்றில் ஒரு பங்கு. அப்படியானால் இப்போது இருக்கும் எட்டுத் தோசை என்பது மூன்றில் இரண்டு பங்கு. மூன்றில் இரண்டு பங்கு என்பது எட்டு என்றால், மூன்றில் ஒரு பங்கு நான்கு. அப்படியானால் நிறைமதி தின்ற தோசைகளின் எண்ணிக்கை நான்கு. [மீண்டும் ஒரு முறை சத்தமாக வாசித்து உறுதி செய்து கொள்ளுங்கள்.]

அப்படியானால் நிறைமதி உணவுக்காகப் பாத்திரத்தை எடுக்கும் போது மொத்தம் பன்னிரண்டு தோசைகள் இருந்திருக்கின்றன. இந்தப் பன்னிரண்டு தான் குழலி மீதி வைத்துப் போன தோசைகளின் எண்ணிக்கை.

குழலி தின்றது மூன்றில் ஒரு பங்கு. அப்படியானால் இப்போது இருக்கும் பன்னிரண்டுத் தோசை என்பது மூன்றில் இரண்டு பங்கு. மூன்றில் இரண்டு பங்கு என்பது பன்னிரண்டு என்றால், மூன்றில் ஒரு பங்கு ஆறு தோசை. அப்படியானால் குழலியின் கணக்கில் ஆறு தோசையைச் சேர்த்துக் கொள்ளலாம். இப்படிப் பார்க்கும் போது குழலி, உண்ண நுழையும் போது [பன்னிரண்டு + ஆறு] பதினெட்டுத் தோசை இருந்திருக்கும்.

இந்தப் பதினெட்டுத் தோசை தான் யாழினி மீதி வைத்த தோசைகளின் எண்ணிக்கை. யாழினியும் மூன்றில் ஒரு பங்கு தின்றதால், [18/2] ஒன்பது தோசையை யாழினி தின்றிருக்க வேண்டும். அப்படியானால் யாழினி முதலில் தோசையை உண்ணத் தொடங்கும் போது இருபத்தேழு தோசைகள் இருந்திருக்க வேண்டும். இதைத்தான் கெட்டிக்காரச் சமையலாளர் கண்டுபிடித்திருந்தார். சரி, இதைப் பைத்தான் நிரலாக எழுதுவோமா?

மீதி = 8 #சமையலாளர் பார்த்த எண்ணிக்கை
#நிறைமதியின் கணக்கில் இருந்து தொடங்குகிறோம்.
தின்ற_தோசை = மீதி//2 # நிறைமதியின் கணக்கு [மூன்றில் ஒரு பங்கு]
print("நிறைமதி தின்ற தோசைகள்", தின்ற_தோசை)
மீதி = மீதி + தின்ற_தோசை #நிறைமதி உணவுக்கு முன் மொத்த மீதி
#இப்போது குழலியின் கணக்கைப் பார்ப்போம்.
தின்ற_தோசை = மீதி//2 #குழலி தின்ற தோசைகள் [மூன்றில் ஒரு பங்கு]
print("குழலி தின்ற தோசைகள்", தின்ற_தோசை)
மீதி = மீதி + தின்ற_தோசை #குழலி உணவுக்கு முன் மொத்த மீதி
#யாழினியின் கணக்கு
தின்ற_தோசை = மீதி//2 #யாழினி தின்ற தோசைகள் [மூன்றில் ஒரு பங்கு]
print("யாழினி தின்ற தோசைகள்", தின்ற_தோசை)
மீதி = மீதி + தின்ற_தோசை
print(மீதி) #சமையலாளர் சுட்டு வைத்திருந்த மொத்தத் தோசைகள்

இந்த நிரலை நன்றாக உற்றுப் பாருங்கள். மெல்ல கங்கா, சந்திரமுகியாக மாறுவதைப் பார் என்பதைப் போல[சந்திரமுகி படம் பார்த்தீர்கள் அல்லவா!?], மெல்ல இந்த நிரலை while தேவையுடைய ஒரு நிரலாக இருப்பதைப் பாருங்கள். while எப்போது போக வேண்டும் என்று படித்தோம்? எப்போது ஒரு வேலையைத் திரும்பத் திரும்பச் செய்கிறோமா அப்போது தானே! இங்கே தின்ற\_தோசை, மீதி ஆகிய இரண்டின் கணக்கையும் திரும்பத் திரும்பச் செய்கிறோம் பாருங்கள். எத்தனை பேர் இங்கே இருந்தார்கள்? யாழினி, குழலி, நிறைமதி மூவர். எனவே, மூன்று முறை கணக்கெடுத்துப் பார்த்தோம் அல்லவா?

மீதி = 8 #சமையலாளர் பார்த்த எண்ணிக்கை
நண்பரின்_எண் = 3 #மொத்த_நண்பர்கள்_எண்ணிக்கை
while நண்பரின்_எண்>=1:
    தின்ற_தோசை = மீதி//2 # நிறைமதியின் கணக்கு [மூன்றில் ஒரு பங்கு]
    print(நண்பரின்_எண்,'ஆவது ஆள் தின்றது', தின்ற_தோசை)
    மீதி = மீதி + தின்ற_தோசை
    நண்பரின்_எண்-=1
else:
    print("மொத்த மீதி", மீதி)

நிரல் எவ்வளவு சின்னதாகச் சுருங்கி விட்டது பாருங்கள். இது தான் whileஇன் பலம்.

வியன், பாரி வயதைக் கண்டுபிடித்த அன்வர்

வியனும் பாரியும் உடன் பிறந்த அண்ணன் தம்பிகள். சுட்டித்தனம் செய்வதில் வல்லவர்கள். வியன் பள்ளிக்கூடம் போய்க் கொண்டிருக்கிறான்; பாரிக்கு இன்னும் பள்ளிக்குப் போகும் வயது வரவில்லை. வியன், பாரி இருவரின் அப்பா அம்மாவின் நெருங்கிய நண்பர் அன்வர். ஒரு முறை அவர் வியன் வீட்டுக்குப் போய் இருந்தார். இவர்கள் சுழிச் சேட்டைகளை நேரில் பார்த்து, இருவரையும் கூப்பிட்டார்.

‘வியன் உன்னுடைய வயது என்ன? உன்னுடைய தம்பியின் வயது என்ன?’ என்று கேட்டார். அவர் கேட்பது என்னவென்றே சரிவரப் புரியாத மழலையாகிய பாரி, ”நூறு ஆயிரம்” என்று சொன்னான். இதைக் கேட்ட வியனுக்குச் சிரிப்பு வந்து விட்டது. ‘தம்பி தப்பாச் சொல்றான். நான் சரியாச் சொல்லட்டுமா மாமா?’ என்றான். ‘சரி’ என்றார் அன்வர்.

‘நான் பிறந்து ஆறு ஆண்டுகள் கழித்து என் தம்பி பாரி பிறந்தான். என் வயதுக்கும் என் தம்பியின் வயதுக்குமான பொது வகுத்தி[Common Divisor] என் தம்பியின் வயது. நீங்களே என் வயதையும் தம்பி வயதையும் கண்டுபிடித்துக் கொள்ளுங்கள்’ என்று சொல்லி விட்டு மீண்டும் விளையாட ஓடி விட்டான் வியன். வியனின் கேள்வியைக் கேட்டு நமுட்டுச் சிரிப்பை உதிர்த்த அன்வர், ஒரு சில நொடிகளில் அவர்கள் இருவர் வயதையும் கண்டு பிடித்து விட்டார். உங்களால் கண்டுபிடிக்க முடிந்ததா? கண்டுபிடித்து வையுங்களேன். அடுத்த பதிவில் அதைப் பார்ப்போம்!

குறிப்பு: பொது வகுத்தி என்பது சின்ன வயதில் படித்திருப்போம். ஒரு வேளை மறந்திருந்தால் புத்தகங்களைப் புரட்டிப் பார்த்து, பொது வகுத்தியை நினைவு படுத்திக் கொள்ளுங்கள்.

20. நீங்களும் துப்பறியலாம்!

அண்ணன் தம்பிகளான வியன், பாரி இருவரின் வயதை எப்படிக் கண்டுபிடிப்பது? கதையில் நமக்குக் கிடைத்திருக்கும் துப்புகள்[தடயங்கள்] என்னென்ன?

• வியன் பள்ளிக்கூடம் போகும் சிறுவன். பாரி, இன்னும் பள்ளிக்குப் போகாத மழலை.
• வியனுக்கும் பாரிக்கும் இடையில் வயது வேறுபாடு ஆறு வயது.
• இரண்டு பேரின் வயதிற்குமான பொது வகுத்தி வியனின் வயது.

இந்தக் குறிப்புகளின் படி,

பாரி  வியன்
1      7
2      8
3      9
4      10

இந்த வயதுகளில் ஏதேனும் ஒன்றில் தான் இருவரும் இருக்க வேண்டும். இந்த நான்கு கணிப்புகளில், முதல் கணிப்பையும் (1,7) கடைசிக் கணிப்பையும் விட்டு விடலாம். ஏனென்றால், ஒன்று என்பது எல்லா எண்ணையும் வகுக்கும். எனவே, அதைப் பொது வகுத்தியாக எடுத்துக் கொள்ள முடியாது. கடைசிக் கணிப்பில் 4,10 ஆகிய இரண்டின் பொது வகுத்தி 10 இல்லை. எனவே அதையும் நீக்கி விடலாம்.

‘நீங்களாகவே முதல் கணிப்பையும் கடைசிக்கணிப்பையும் நீக்கி விடலாம்’ என்று சொல்கிறீர்கள். எப்படிச் சொல்கிறீர்கள் என்று கொஞ்சம் சொல்லுங்கள் என்று கேட்கிறீர்களா?. பொது வகுத்தி என்பதே மறந்து விட்டது என்று சொல்கிறீர்களா? அப்படிச் சொல்பவராக நீங்கள் இருந்தால் அடுத்த தலைப்பைப் படியுங்கள். இல்லை, நான் கணக்கில் புலி தான்! என்று சொன்னால் நீங்கள் அடுத்த தலைப்பைத் [‘பைத்தான் வகுத்தி’] தொடருங்கள்.

பொது வகுத்தி:

பொது வகுத்தி[Common Divisor]யைப் பார்ப்பதற்கு முன்னால், வகுத்தி[Divisor] என்றால் என்னவென்று பார்த்து விடுவோம். ஓர் எண்ணின் வகுத்தி என்பது அந்த எண் எந்தெந்த எண்களால் வகுபடும் என்பது ஆகும். எடுத்துக்காட்டாக, 100 என்றோர் எண்ணை எடுத்துக் கொள்வோம்.

100இன் வகுத்திகள் –> 1, 2, 4, 5, 10, 20, 25, 50, 100 ஆகியன ஆகும். இதில் 1 எல்லா எண்களையும் வகுக்கும். 100 என்பது கொடுக்கப்பட்ட எண். ஆகவே, ஓர் எண் கொடுத்து அவ்வெண்ணின் மிகப்பெரிய வகுத்தி எது எனக் கேட்டால், கொடுக்கப்பட்ட அதே எண் தான் எனப் பதில் சொல்லி விடலாம்.

அதற்கு முந்தைய மிகப்பெரிய வகுத்தி எது எனக் கேட்டால், வகுத்தி] அவ்வெண்ணின் பாதியாக இருக்கலாம். [சில நேரங்களில் இல்லாமலும் இருக்கலாம்]. இன்னும் சில எடுத்துக்காட்டுகளைப் பார்ப்போமே! 4இன் வகுத்திகள் –> 1,2,4 [இங்கே மிகப்பெரிய வகுத்தி 4,அதாவது கொடுக்கப்பட்ட எண், 2 என்பது 4இன் பாதி] 9இன் வகுத்திகள் –> 1,3,9 [இங்கே மிகப்பெரிய வகுத்தி 9, அதாவது கொடுக்கப்பட்ட எண், 3 இரண்டாவது மிகப்பெரிய வகுத்தி] 16இன் வகுத்திகள் –> 1,2,4,8,16 [இங்கே மிகப்பெரிய வகுத்தி 16,அதாவது கொடுக்கப்பட்ட எண், 8 என்பது 8இன் பாதி] 25இன் வகுத்திகள் –> 1,5,25 [இங்கே மிகப்பெரிய வகுத்தி 25,அதாவது கொடுக்கப்பட்ட எண், 5 இரண்டாவது மிகப்பெரிய வகுத்தி]

இந்த எடுத்துக்காட்டுகளில் 9, 25 ஆகிய எண்களின் இரண்டாவது பெரிய வகுத்தியாக அவற்றின் பாதி வரவில்லை என்பதைக் கவனத்தில் கொள்க. சரி, இப்போது பொது வகுத்திக் கணக்குக்கு வருவோம். பொது வகுத்தி என்பது இரண்டு எண்கள் கொடுக்கப்பட்டால் அவை இரண்டுக்கும் பொதுவான வகுத்தியாகும். 100, 120 ஆகிய இரண்டு எண்களின் வகுத்திகளை முதலில் எழுதுவோம்.

100 இன் வகுத்திகள் –> 1, 2, 4, 5, 10, 20, 25, 50, 100

120 இன் வகுத்திகள் –> 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120

இவற்றில் பொதுவான வகுத்திகள் எவையெவை? 1, 2, 4, 5, 10, 20. இவற்றுள், 1 எப்போதுமே வகுத்தியாக எல்லா எண்களுக்குமே வரும் அல்லவா? எனவே, அதை விட்டு விடுவோம். மீதி எண்களாகிய, 2, 4, 5, 10, 20 ஆகியன பொது வகுத்திகள்.

பைத்தானில் வகுத்தி:

இரண்டு எண்களுக்கான பொதுவகுத்தியை இப்போது பைத்தானில் கண்டுபிடிக்க வேண்டும். முன்னொரு காலத்தில் if படித்தது நினைவிருக்கிறதா? % [மாடுலஸ்] நினைவிருக்கிறதா? இரண்டும் நினைவில் இருந்தாலே போதும். இந்த நிரலைத் தொடங்கி விடலாம்.

எண் = 100
if எண்%2 == 0:
    print("வகுத்தி", 2)
if எண்%3 == 0:
    print("வகுத்தி", 3)
if எண்%4 == 0:
    print("வகுத்தி", 4)
if எண்%5 == 0:
    print("வகுத்தி", 5)

இப்படியே கொடுக்கப்பட்ட எண்ணின் பாதி வரை [ஏன் பாதி வரை மட்டும்? மேலே படித்தது நினைவிருக்கிறது அல்லவா!] if எழுத வேண்டும். அத்தனை if எழுதுவதற்கான எளிதான மாற்று வழி தான் while எனப் படித்திருக்கிறோமே! அதை இங்கு செய்து விட வேண்டியது தான்!

எண் = 100
வகுக்கும்_எண் = 2 #வகுத்தியை இரண்டில் இருந்து தொடங்குகிறோம்.
while வகுக்கும்_எண் <= எண்//2: #பாதி வரை போகப் போகிறோம்.
    if எண்%வகுக்கும்_எண்==0:
        print("வகுத்தி",வகுக்கும்_எண்)
    வகுக்கும்_எண்+=1 #அடுத்த எண்ணைப் பார்க்கிறோம்.

பொது வகுத்தி:

சரி, இப்போது வகுத்தி கண்டுபிடித்து விட்டோம்! பொது வகுத்தியை எப்படிக் கண்டுபிடிப்பது? பொது வகுத்தி என்பது இரண்டு எண்களுக்குமான பொது அல்லவா? இரண்டு எண்களையும் எழுதி வைத்து, இரண்டையும் வகுக்கிறதா என்று பார்த்து விடுவோம்.

எண்1 = 100
எண்2 = 120
வகுக்கும்_எண் = 2
while வகுக்கும்_எண்<=120:
    if எண்1%வகுக்கும்_எண்==0 and எண்2%வகுக்கும்_எண் ==0:
        print("பொது வகுத்தி", வகுக்கும்_எண்)
    வகுக்கும்_எண்+=1

இங்கே ஐந்தாவது வரியில் ஏன் and சேர்த்திருக்கிறோம் என்பது புரிகிறது அல்லவா? நூற்றை’யும்’ வகுக்க வேண்டும், நூற்று இருபதை’யும்’ வகுக்க வேண்டும் எனச் சொல்கிறோமே! அந்த ‘உம்’ தான் பைத்தானில் and.

இந்த நிரலை நண்பர் ஒருவரிடம் விளக்கிச் சொல்லிக் கொண்டிருந்தேன். அவருக்கு இந்த நிரலில் ஓர் ஐயம்(அதாங்க, சந்தேகம்!). நான்காவது வரியில் ஏன் <=க்குப் பிறகு 120 கொடுத்தீர்கள்? அங்கே 100 கொடுத்திருக்கலாமே! என்கிறார். அவர் சொல்வது சரியா? இல்லை, 120 தான் சரியா? பேசுவோமா?

இரண்டு எண்களின் பொது வகுத்தி என்னும் போது முதலில் ஒரு செய்தியை நினைவில் நிறுத்திக் கொள்ள வேண்டும். ஓர் எண்ணின் மிகப் பெரிய வகுத்தி என்பது கொடுக்கப்பட்ட அவ்வெண் தான்! அதைத் தாண்டி ஒரு வகுத்தி அந்த எண்ணுக்குக் கிடையாது. [இதை முன்னரே பேசியிருக்கிறோம், மறந்திருந்தால் மீண்டும் வாசித்துப் பாருங்கள்.] எனவே, இரண்டு எண்கள் கொடுக்கப்பட்டால், அவற்றுள் சிறிய எண் வரை தான் பொது வகுத்தி கிடைக்கும். 10உம், 1200உம் கொடுக்கப்பட்ட எண்கள் என்று வைத்துக் கொள்ளுங்களேன். இரண்டுக்குமான பொது வகுத்திகளைத் தேடினால், 10 வரை தானே கிடைக்கும். அதைத் தான் சொல்கிறேன்.

எனவே, நம்முடைய நிரலில் நண்பர் சொல்வது (தான்) சரி! நாமும் அப்படியே எந்த எண் சிறிய எண் எனப் பார்த்து அதை நிரலில் மாற்றி விடுவோம்.

எண்1 = 100
எண்2 = 120
வகுக்கும்_எண் = 2
while வகுக்கும்_எண்<=100:
    if எண்1%வகுக்கும்_எண்==0 and எண்2%வகுக்கும்_எண் ==0:
        print("பொது வகுத்தி", வகுக்கும்_எண்)
    வகுக்கும்_எண்+=1

இந்த நிரல், 100க்கும் 120க்கும் மட்டும் பொருந்துகிறது. பொதுவாக எந்த இரண்டு எண்கள் கொடுக்கப்பட்டாலும் வேலை செய்ய வேண்டும் என்றால்,

எண்1 = int(input("எண்ணைச் சொல்லுங்கள்: "))
எண்2 = int(input("எண்ணைச் சொல்லுங்கள்: "))
வகுக்கும்_எண் = 2
if எண்1<எண்2:
    சின்ன_எண் = எண்1
elif எண்2<எண்1:
    சின்ன_எண் = எண்2
while வகுக்கும்_எண்<=சின்ன_எண்:
    if எண்1%வகுக்கும்_எண்==0 and எண்2%வகுக்கும்_எண் ==0:
        print("பொது வகுத்தி", வகுக்கும்_எண்)
    வகுக்கும்_எண்+=1

என மாற்றி எழுத வேண்டும். இதில் முதல் இரண்டு வரிகள் புரியவில்லை என்றாலும் அச்சம் வேண்டாம். பயனரிடம் இருந்து உள்ளீடுகளை(inputs) வாங்கி அதை எண்ணாக(int) மாற்றும் வேலை அது என்னும் புரிதலை மட்டும் வைத்துக் கொள்ளுங்கள். பிறகு அதை விரிவாகப் பேசுவோம்.

டெர்னரி ஆப்பரேட்டர் [Ternary Operator]:

இங்கே நான்காம் வரியில் இருந்து ஏழாம் வரி வரை எழுதியிருக்கிறோமே `if, elif` – அதைச் சுருக்கி,

சின்ன_எண் = எண்1 if எண்1<எண்2 else எண்2

என்று ஒரே வரியில் எழுதலாம். அதாவது, `எண்1`, `எண்2`ஐவிடச் சின்னது என்றால், அதைச் சின்ன எண்ணில் பொருத்துங்கள். இல்லையென்றால், `எண்2`ஐச் சின்ன எண்ணில் பொருத்துங்கள் என்று பொருள். இதை Ternary Operator என்பார்கள்.

இப்போது நம்முடைய நிரல், கீழே இருப்பது போல மாறியிருக்கும்.

எண்1 = int(input("எண்ணைச் சொல்லுங்கள்: "))
எண்2 = int(input("எண்ணைச் சொல்லுங்கள்: "))
வகுக்கும்_எண் = 2
சின்ன_எண் = எண்1 if எண்1<எண்2 else எண்2
while வகுக்கும்_எண்<=சின்ன_எண்:
    if எண்1%வகுக்கும்_எண்==0 and எண்2%வகுக்கும்_எண் ==0:
        print("பொது வகுத்தி", வகுக்கும்_எண்)
    வகுக்கும்_எண்+=1

சரி, இப்போது பாரி, வியன் கதைக்கு வருவோம். பாரியின் வயதுக்கும் வியனின் வயதுக்கும் ஒரே பொது வகுத்தி.

• முதலில் பாரியின் வயது 1 எனக் கொண்டால் வியனின் வயது 7. எண் ஒன்று எல்லா எண்களாலும் வகுபடும் என்பதால் இதை விட்டு விடலாம்.
• பாரியின் வயது 2 எனக் கொண்டால் வியனின் வயது 8. 2, 8 ஆகியவற்றின் பொது வகுத்தி 2 மட்டுமே. எனவே இதுவே பாரி, வியன் ஆகியோரின் வயதாக இருக்கலாம்.
• பாரியின் வயது 3 எனக் கொண்டால் வியனின் வயது 9. 3, 9 ஆகியவற்றின் பொது வகுத்தி 3 மட்டுமே. எனவே, பாரி, வியனின் வயது ஆகியோரின் வயதாக இருக்கலாம்.

இவை இரண்டில் முதலிலேயே 2உம் 8உம் வந்து விடுவதால், அவற்றையே சிறந்த தேர்வாக எடுத்துக் கொள்ளலாம்.

இப்போது பார்த்திருப்பது, பொது வகுத்திகளுக்கான நிரல், இதில் இருந்து மீப்பெரு பொது வகுத்தி [மீ.பெ.வ], மீச்சிறு மடங்கு[மீ.சி.ம] பார்ப்போமா! மீ.பெ.வ[HCF], மீ.சி.ம[LCM] என்பவை எங்கோ கேட்ட நினைவிருக்கிறதா? ஆறாம் வகுப்பு, ஏழாம் வகுப்பில் படித்த கணிதப் பாடம் தான்! தூசி தட்டி நினைவில் வையுங்கள். சந்திப்போம்.

21. காத்து வாக்குல ரெண்டு காதல்

மதன், கார்த்திகா இருவரும் ஒரே அலுவலகத்தில் வேலை செய்யும் மென்பொறியாளர்கள். மதனுக்கு லினக்ஸ் அத்துப்படி! கார்த்திகாவுக்கு மதனைக் காட்டிலும் வேலை அனுபவம் குறைவு! விண்டோசே கதி என்று இருந்த கார்த்திகாவுக்கு லினக்சின் ஒவ்வொரு படியாக மதன் காட்ட, கார்த்திகா, லினக்சில் படிப்படியாக முன்னேறிக் கொண்டிருந்தாள். லினக்சைக் காதலித்த மதனுக்கு, லினக்சைக் காதலிக்கத் தொடங்கிய கார்த்திகாவையும் பிடித்துத் தான் இருந்தது.

அதிலும் ஒரு நாள் அலுவலகத்தில் நடந்த பாட்டுப் போட்டியில் மதனுக்குப் போட்டியாகக் கார்த்திகா பாடிய ‘யமுனை ஆற்றிலே ஈரக் காற்றிலே’ பாடலில் கிறங்கிப் போய் இருந்தான் மதன். “ஆயர் பாடியில் கண்ணன் இல்லையோ” என்று அவள் பாடியதே தன்னைப் பார்த்துத் தானோ என்று மெய் மறந்தான் மதன். இப்படியாகக் கருப்பு வெள்ளைக் கனவுகளுக்கு லினக்ஸ், வண்ணக் கனவுகளுக்குக் கார்த்திகா என்று காத்து வாக்குல ரெண்டு காதலாகப் போய்க் கொண்டு இருந்தது மதனின் வாழ்க்கை.

லினக்சிடம் என்ன வேண்டுமானாலும் கேட்டு வாங்கத் தெரிந்த மதனுக்குக் கார்த்திகாவின் கண்களைப் பார்த்து, காதலைச் சொல்லும் தைரியம் மட்டும் இன்னும் வரவே இல்லை. லினக்சில் பல தேர்வுகள் எழுதிச் சான்றிதழ்கள் குவித்து வைத்திருந்த மதனுக்குக் காதல் தேர்வு மட்டும் என்னவோ கலவரத்தைக் கொடுத்துக் கொண்டு இருந்தது. “நான் தோற்றுப் போவேன் என்று அஞ்சியே என் தேர்வை எல்லாம் ஒத்தி வைக்கிறேன்” என்று மனத்திற்குள் பாடிக் கொண்டே இருந்தான்.

ஒரு நாள் இரவு, மதன் நன்றாகத் தூங்கிக் கொண்டிருந்தான்; ஆழ்ந்த தூக்கத்தில் மதனுக்குக் கனவு! கனவில் மதனும் கார்த்திகாவும் உட்கார்ந்திருக்கிறார்கள். இருவருக்கும் நரைதிரை எல்லாம் விழுந்து வயதான தோற்றத்தில் வீட்டில் உட்கார்ந்திருக்கிறார்கள்; தொலைக்காட்சி ஓடிக் கொண்டிருக்கிறது. ‘முழுமை பெற்ற காதல் என்றால் முதுமை வரை கூட வரும்’ என்று ஏதோ பாட்டு ஓடிக் கொண்டிருக்கிறது. அப்போது ஒரு சிறுவன் வருகிறான். மதனைப் பார்த்து, ‘தாத்தா என் நண்பன் ஒருவன், உன் வயதையும் பாட்டி வயதையும் கேட்டான். எனக்கு இருவர் வயதும் தெரியாது.

ஆனால், எங்க பாட்டியை விடத் தாத்தாவுக்கு வயது அதிகம்’ என்று சொன்னேன். அவனாகவே ‘உங்க தாத்தாவுக்கு எழுபது வயது, பாட்டிக்கு அறுபது வயது இருக்கும்’ என்று சொல்லிக் கொண்டான். அப்படிச் சொன்ன நண்பன், என்னுடைய வயதையும் தம்பி தங்கை வயதையும் கேட்டான். ‘நான் என் வயதையும், தம்பி தங்கை வயதையும் சொல்லவில்லை’ என்றான். மதன், ‘ஏன் பேராண்டி! வயதைக் கேட்டால் சொல்ல வேண்டியது தானே!’ என்றான். ‘இல்லை தாத்தா! உனக்கும் பாட்டிக்கும் பத்து வயது வித்தியாசம் இருக்காது தானே! அவன் உன்னைக் கிழவன் என்று கிண்டல் செய்வதற்காகக் கேட்டது போல எனக்குப் பட்டது.

அதனால், நான் நேரடியாக வயதைச் சொல்லவில்லை’ என்றான். பேரனின் பாசத்தைப் பார்த்து மதனுக்கு மகிழ்ச்சி. ‘நேரடியாக வயதைச் சொல்லவில்லை சரி, பிறகெப்படி மறைமுகமாகச் சொன்னாயா?’ இது மதனின் கேள்வி! ‘ஆமாம் தாத்தா, என் தாத்தா வயது எழுபது, என் பாட்டியின் வயது அறுபது என்றால், அவர்கள் வயதுகளின் பொது வகுத்திகளைக் கண்டுபிடி! அதில் இருப்பதில் சின்ன எண் என் தம்பியின் வயது, அடுத்த எண், என் தங்கையின் வயது, பெரிய எண் என் வயது’ என்று சொல்லி விட்டேன் என்றான் பேராண்டி.

பொது வகுத்தி, கணக்கு என்று கனவு, காதலைத் தாண்டி எங்கோ போனவுடன் கலைந்து போனது மதனின் கனவு. ‘சே! காதல் கனவு வரும் என்று நினைத்தால் இப்படிக் கணக்குக் கனவு வந்து தூக்கம் தொலைந்து போனதே’ என்று மதனுக்கு ஒரே வருத்தம். ‘சரி, தூக்கம் கலைந்து சீக்கிரம் எழுந்து விட்டோம்! கனவில் கண்ட கணக்கைப் போட்டுத் தான் பார்ப்போமே!’ என்று கணக்குப் போடத் தொடங்கினான் மதன்.

மதன்_வயது = 70
கார்த்திகா_வயது = 60
வகுக்கும்_எண் = 2
while வகுக்கும்_எண்<=கார்த்திகா_வயது:
    if மதன்_வயது%வகுக்கும்_எண்==0 and கார்த்திகா_வயது%வகுக்கும்_எண்==0:
        print('பேரன்/பேத்தி வயது', வகுக்கும்_எண்)
    வகுக்கும்_எண்+=1

இந்த நிரலை எளிதாகப் போட்டு முடித்து விட்டான் மதன். பைத்தானுக்கு அவன் புதியது என்றாலும் கணியம்.காமில் வரும் பைத்தான் பற்றிய தொடரைத் தொடர்ந்து படித்து வந்ததால் எளிதாக இந்த நிரலை எழுதி விட்டான். (என்ன செய்வது? நமக்கு நாமே இப்படி விளம்பரம் செய்து கொண்டால் தான் உண்டு :)) இப்போது மதனுக்குள் ஒரு கேள்வி! தனக்குப் பிறக்கப் போகும் பேரன், பேத்திகளில் மூத்த பேரனின் வயதை மட்டும் கண்டுபிடிக்க வேண்டும் என்றால் எப்படிக் கண்டுபிடிப்பது? எப்படி அதைக் கண்டுபிடிக்கலாம் என்று மூளையைப் போட்டுக் கசக்கிக் கொண்டிருந்தான்.

திடீரென அவனுக்குப் பொறி தட்டியது! முதலில் கிடைக்கும் வகுத்தி[Divisor] கடைசிப் பேரக்குழந்தை என்றால், முதல் பேரக்குழந்தை என்பது கடைசி வகுத்தி! அப்படியானால் அந்தக் கடைசி வகுத்தியை மட்டும் நினைவில் வைத்துக் கொண்டால் போதுமானது. கிடைக்கும் ஒவ்வொரு வகுத்தியையும் பேரன்\_வயது எனச் சேமிப்போம். கடைசியாக என்ன எண் கிடைக்கிறதோ அதுவே முதல் பேரக்குழந்தையின் வயதாக இருக்க முடியும் எனக் கணித்துக் கொண்டான். கணித்து, முதலில் எழுதிய நிரலை,

மதன்_வயது = 70
கார்த்திகா_வயது = 60
வகுக்கும்_எண் = 2
while வகுக்கும்_எண்<=கார்த்திகா_வயது:
    if மதன்_வயது%வகுக்கும்_எண்==0 and கார்த்திகா_வயது%வகுக்கும்_எண்==0:
        பேரன்_வயது = வகுக்கும்_எண்
    வகுக்கும்_எண்+=1
else:
    print('முதல் பேரக் குழந்தையின் வயது', பேரன்_வயது)

என்று மாற்றி எழுதினான். நிரலின் வெளியீட்டை(output)ப் பார்த்து, ‘யுரேக்கா யுரேக்கா’ என்று கத்தலாம் போல் இருந்தது. “சீச்சீ! இப்படிச் சின்ன நிரலுக்கு எல்லாமா யுரேக்கா யுரேக்கா என்று கத்துவது” என்று நினைத்துக் கொண்டான். இப்படி நினைத்துக் கொண்டிருக்கும் போதே, ‘காதல் என்னும் தேர்வெழுதி’ என்று அலைபேசி பாடத் தொடங்கியது. இந்தப் பாட்டு, ‘கார்த்திகாவுக்கு மட்டும் அல்லவா வைத்திருந்தேன், காலையிலேயே கூப்பிடுகிறாளா?’ என்று நினைத்தபடியே பாய்ந்து எடுத்து, ‘சொல்லுங்க கார்த்திகா’ என்று சொல்வதில் ‘ங்க’வைக் கொஞ்சம் குறைத்துச் சொல்லிக் கொண்டான்.

‘மதன், உங்களிடம் எப்படிச் சொல்வது என்றே தெரியவில்லை’ என்றாள் கார்த்திகா.

‘என்ன? எதுவும் சிக்கலா கார்த்திகா?’, இது மதன். ‘நேற்று இராத்திரி தூக்கத்தில் ஒரு கனவு!’ என்றாள் கார்த்திகா.

‘உனக்குமா’ என்று கேட்க நினைத்து, ‘உங்களுக்குமா?’ என்றான் மதன்.

‘உங்களுக்குமா என்றால்? உங்களுக்குமா?’ என்றாள் கார்த்திகா.

கனவுகளிலும் அவர்கள் சந்திக்கத் தொடங்கியிருந்தார்கள்.

குறிப்பு: இங்கு மதனின் மூத்த பேரன்/பேத்தியின் வயது தான் மீப்பெரு பொது வகுத்தி கண்டுபிடிப்பதற்கான வழி.

22. முடிவுரை

நன்றி இந்த புத்தகம் kaniyam.com வலைத்தளத்தில் வெளியிடப்பட்ட article களை வைத்து உருவாக்கப்பட்டது. கி. முத்துராமலிங்கம் அவர்களுக்கு நன்றி.