தனது முதல் Python பயிற்சியைத் தொடங்கும் பெரும்பாலான மக்கள், மாறிகள் (variables), சுழற்சிகள் (loops) மற்றும் ஏதேனும் ஒன்றை நேரடியாக உருவாக்குவதற்குத் தாவிச் செல்ல விரும்புகிறார்கள். அந்தத் தூண்டுதல் இயல்பானதுதான். ஆனால், Python உண்மையில் என்ன என்பதையும், அது அதன் அடியில் உள்ள இயந்திரத்துடன் எவ்வாறு தொடர்பு கொள்கிறது என்பதையும் புரிந்து கொள்ள நீங்கள் சற்று நேரம் ஒதுக்கினால், எதிர்காலத்தில் உங்கள் குறியீட்டில் (code) ஏற்படும் பிழைகளை (debug) மிகக் குறைந்த குழப்பத்துடன் சரிசெய்ய முடியும். அனைத்து நிரலாக்க மொழிகளும் ஒன்றல்ல. அவை வெவ்வேறு அளவிலான அப்பஸ்ட்ராக்ஷன் (abstraction) நிலைகளைக் கொண்டுள்ளன, வசதிக்காகக் கட்டுப்பாடுகளைப் பல்வேறு வழிகளில் விட்டுக்கொடுக்கின்றன, மேலும் வெவ்வேறு பாதைகள் வழியாகச் செயலிக்கு (processor) சென்றடைகின்றன. அந்தச் சூழலில் Python ஒரு குறிப்பிட்ட இடத்தில் அமைகிறது. அந்த இடத்தைப் புரிந்துகொள்வதே நிரலாக்கம் செய்வதைக் கற்றுக்கொள்வதற்கான முதல் உண்மையான படியாகும்.

மொழிகளின் படிநிலை: Python எங்கே அமைகிறது

நிரலாக்க மொழிகள் வன்பொருளுடனான (hardware) அவற்றின் நெருக்கத்தைப் பொறுத்து பொதுவாக மூன்று வகைகளாகப் பிரிக்கப்படுகின்றன.

உயர்நிலை மொழிகள் (High-level languages) சிலிக்கானிலிருந்து (silicon) வெகு தொலைவில் உள்ளன. Python, Java மற்றும் JavaScript ஆகியவற்றுடன் இங்கேதான் அமைகிறது. இந்த மொழிகள் மனித மொழியைப் போன்ற தொடரியலைப் (syntax) பயன்படுத்துகின்றன. நீங்கள் மெமரி முகவரிகள் (memory addresses) மற்றும் பைனரி அறிவுறுத்தல்களுடன் போராடுவதற்குப் பதிலாக, user_count = 5 அல்லது print("Hello") என்று எழுதுகிறீர்கள். இவை CPU, மெமரி மேனேஜ்மென்ட் மற்றும் சிப்செட் வேறுபாடுகளின் நுணுக்கங்களை மறைத்து (abstract) வைப்பதால், அதே உயர்நிலை குறியீட்டை மிக little அல்லது எந்த மாற்றமும் இன்றி ஒரு Mac, Windows PC அல்லது Linux சர்வரில் இயக்க முடியும்.

அந்தப் பெயர்வுத்தன்மைக்கு (portability) ஒரு விலை உண்டு. உயர்நிலை மொழிகளுக்கு ஒரு மொழிபெயர்ப்பாளர் தேவை. அவற்றால் நேரடியாகச் செயலியின் மீது இயங்க முடியாது. உங்கள் வாசிக்கக்கூடிய குறியீட்டிற்கும் இயந்திரத்தின் மின் சமிக்ஞைகளுக்கும் (electrical signals) இடையே உள்ள இடைவெளியைக் குறைக்க உங்களுக்கு ஒரு கம்பைலர் (compiler) அல்லது இன்டர்பிரிட்டர் (interpreter) தேவைப்படும். இதன் நன்மை என்னவென்றால், மேம்பாட்டு வேகம் (speed of development) அதிகம். முதல் நாளிலிருந்தே பயனுள்ள நிரல்களை எழுத நீங்கள் நேரடியாக வன்பொருளைக் கட்டுப்படுத்தும் வசதியை விட்டுக்கொடுக்கிறீர்கள்.

குறைந்தநிலை மொழிகள் (Low-level languages) இதற்கு நேர்மாறான நிலையில் உள்ளன. இவை அடிப்படையில் இயந்திரக் குறியீடு (machine code) ஆகும் — அதாவது செயலி நேரடியாகப் புரிந்துகொள்ளும் ஒன்றுகள் மற்றும் பூஜ்ஜியங்களின் (ones and zeros) மூல வரிசைகள். இயந்திரக் குறியீட்டை எழுதுவது என்பது அந்தச் சிப்பைப் போலவே சிந்திப்பதாகும். எந்த மெமரி முகவரி அணுகப்பட வேண்டும் மற்றும் எந்த CPU பதிவேடு (register) ஒரு குறிப்பிட்ட மதிப்பை வைத்திருக்க வேண்டும் என்பதை நீங்கள் துல்லியமாகத் தீர்மானிக்கிறீர்கள். வன்பொருள் உடனடியாகவும், எந்த மொழிபெயர்ப்புத் தாமதமும் இன்றி கீழ்ப்படிகிறது.

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

அசெம்பிளி மொழிகள் (Assembly languages) குறுகிய இடைப்பட்ட நிலையை ஆக்கிரமித்துள்ளன. இவை பைனரி அறிவுறுத்தல்களுக்குப் பதிலாக 'mnemonics' எனப்படும் குறுகிய, மனிதர்கள் எளிதில் வாசிக்கக்கூடிய குறியீடுகளைப் பயன்படுத்துகின்றன. ஒன்றுகள் மற்றும் பூஜ்ஜியங்களின் வரிசைக்கு பதிலாக, தரவை நகர்த்த MOV அல்லது கூட்டல் செய்ய ADD என்று நீங்கள் எழுதலாம். இந்த குறியீடுகள் மூல பைனரியை விட நினைவில் கொள்ள எளிதானவை, ஆனால் அவை ஒரு குறிப்பிட்ட செயலி கட்டமைப்போடு (processor architecture) நெருக்கமாகப் பிணைக்கப்பட்டுள்ளன. Intel x86 சிப்பிற்காக எழுதப்பட்ட ஒரு அசெம்பிளி நிரல் ARM செயலிയിൽ இயங்காது.

ஒரு அசெம்பிளர் (assembler) இந்த குறியீடுகளை இயந்திரக் குறியீடாக மாற்றுகிறது. அசெம்பிளி, Python-ஐ விட நிரலாளர்களுக்குப் பல மடங்கு கட்டுப்பாட்டை வழங்குகிறது, ஆனால் இது செயலியின் உள் செயல்பாடுகள் குறித்த ஆழமான அறிவைக் கோருகிறது. இது பைனரியை விட மனித சிந்தனைக்கு நெருக்கமானது, இருப்பினும் செயலியின் இயல்பான மொழியிலேயே பேசுகிறது.

குறியீடு எவ்வாறு செயலாக மாறுகிறது

ஒவ்வொரு நிரலும் இறுதியில் இயந்திர அறிவுறுத்தல்களாக மாற வேண்டும். மூலக் குறியீட்டிலிருந்து (source code) இயங்கும் பயன்பாட்டிற்கான பாதை இரண்டு உத்திகளில் ஒன்றைப் பின்பற்றுகிறது.

ஒரு கம்பைலர் (compiler) உங்கள் முழுமையான குறியீட்டுத் தொகுப்பையும் (codebase) ஒரே முறையில் மொழிபெயர்க்கிறது. நீங்கள் நூறு வரிகள் கொண்ட ஒரு கோப்பைக் கொடுத்தால், அது எதையும் இயக்க முயற்சிப்பதற்கு முன் நூறு வரிகளையும் படித்து ஆய்வு செய்யும். அது முழு நிரலிலும் உள்ள தொடரியல் பிழைகளைத் (syntax errors) தேடிப் பார்க்கும். ஐம்பதாவது வரியில் ஒரு எழுத்துப் பிழை இருந்தால்? கம்பைலர் நின்றுவிடும், அந்தப் பிரச்சினையைத் தெரிவிக்கும், மேலும் நீங்கள் அதைச் சரிசெய்யும் வரை இயங்கக்கூடிய நிரலை உருவாக்க மறுக்கும்.

C மற்றும் C++ போன்ற மொழிகள் இந்த அணுகுமுறையைப் பயன்படுத்துகின்றன. இதன் முடிவு பொதுவாக வேகத்திற்காக மேம்படுத்தப்பட்ட ஒரு தனித்த இயங்கக்கூடிய கோப்பாக (standalone executable file) இருக்கும். கம்பைலர் முன்கூட்டியே முழு குறியீட்டுத் தொகுப்பையும் நுணுக்கமாக ஆய்வு செய்வதால், நிரல் தொடங்குவதற்கு முன்பே பல வகையான பிழைகளை அது கண்டறிந்துவிடும். இதில் உள்ள சவால் என்னவென்றால், இது சற்று மெதுவானது. திருத்துதல்-கம்பைல் செய்தல்-இயக்குதல் (edit-compile-run) சுழற்சி நேரமெடுக்கும். ஒரு வரியை மாற்றினால் கூட, முழுத் திட்டத்தையும் மீண்டும் உருவாக்க நீங்கள் காத்திருக்க வேண்டியிருக்கலாம்.

ஒரு இன்டர்பிரிட்டர் (interpreter) முற்றிலும் மாறுபட்ட அணுகுமுறையைக் கொண்டுள்ளது. இது உங்கள் குறியீட்டை வரி வரியாகப் படித்து, ஒவ்வொரு கூற்றையும் (statement) படிக்கும்போதே மொழிபெயர்த்துச் செயல்படுத்துகிறது. இது முழு கோப்பும் ஆய்வுக்கு உட்படுத்தப்படும் வரை காத்திருப்பதில்லை. Python REPL-இல் ஒரு கட்டளையைத் தட்டச்சு செய்து, Enter அழுத்தினால், இன்டர்பிரிட்டர் அந்த ஒற்றை வரியை மட்டும் செயலாக்கி, அதை அறிவுறுத்தல்களாக மாற்றி உடனடியாக இயக்கும்.

இது பிழைத்திருத்தத்தின் (debugging) தன்மையையே மாற்றுகிறது. ஒரு interpreter மூலம், பிழைகள் அந்தப் பிரச்சனை உள்ள வரியை interpreter அடையும் போதுதான் வெளிப்படும், அதற்கு முன்பல்ல. உங்கள் நிரல் எண்பது வரிகள் வரை மிகச் சரியாக இயங்கிவிட்டு, எண்பத்தியொன்றாவது வரியில் செயலிழக்கலாம் (crash). அந்த உடனடித் தன்மை, கற்றலுக்கு interpreters-ஐ எளிதாக்குகிறது. நீங்கள் சோதனைகளைச் செய்து, முடிவுகளைப் பார்த்து, உடனுக்குடன் மாற்றங்களைச் செய்யலாம். Python-ன் தரநிலையான CPython, உண்மையில் ஒரு கலப்பு மாதிரியைப் (hybrid model) பயன்படுத்துகிறது: இது உங்கள் மூலக் குறியீட்டை (source) bytecode ஆக மாற்றுகிறது, பின்னர் ஒரு virtual machine மூலம் அந்த bytecode-ஐ இயக்குகிறது. உள்ளுக்குள் ஒரு மொழிபெயர்ப்பு படிநிலை இருந்தாலும், இது ஒரு ஊடாடும் (interactive) மற்றும் வரிக்கு வரி இயங்கும் உணர்வைக் கொடுக்கிறது.

Python ஏன் ஒரு Scripting Language என்று அழைக்கப்படுகிறது

Python பெரும்பாலும் ஒரு scripting language என்று விவரிக்கப்படுகிறது. இந்தத் தொடர் அதன் தோற்றம் மற்றும் பொதுவான பயன்பாட்டு முறைகளைப் பிரதிபலிக்கிறது. ஒரு பணியைத் தானியக்கமாக்கவோ (automate), உரையை மாற்றியமைக்கவோ அல்லது தனித்தனி நிரல்களை ஒன்றிணைக்கவோ நீங்கள் ஒரு சிறிய கோப்பை — ஒரு script — எழுதி, அதை நேரடியாக இயக்கலாம். Interpreter அந்த மொழிபெயர்ப்பை உடனுக்குடன் கையாள்கிறது. நிர்வகிக்கத் தனிப்பயன் compilation படிநிலையோ அல்லது கண்காணிக்க build artifacts-களோ தேவையில்லை.

Scripting languages மற்றும் பொது நோக்கத்திற்கான (general-purpose) programming languages ஆகியவற்றிற்கு இடையிலான வேறுபாடு இப்போது கணிசமாக மறைந்துவிட்டது. Python இப்போது பிரம்மாண்டமான web applications, data science pipelines மற்றும் machine learning systems ஆகியவற்றை இயக்குகிறது. இருப்பினும், அதன் அடிப்படைத் தத்துவம் மாறவில்லை. நீங்கள் ஒரு build system-ஐ நிர்வகிப்பதை விட, ஒரு சிக்கலைத் தீர்ப்பதில் கவனம் செலுத்துகிறீர்கள். நீங்கள் கட்டளையிட்ட அடுத்த கணமே, உங்கள் அறிவுறுத்தல்களைச் செயல்படுத்த interpreter தயாராக உள்ளது.

நீடித்த ஒரு அடித்தளத்தை உருவாக்குதல்

இந்த வேறுபாடுகள் வெறும் கல்வி சார்ந்த தகவல்கள் மட்டுமல்ல. நீங்கள் Python எழுதத் தொடங்கும் முதல் வாரத்தில் நீங்கள் சந்திக்கும் செயல்பாடுகளை இவை விளக்குகின்றன. இயங்கும் போது Python ஒரு SyntaxError-ஐத் தூண்டும்போது, interpreter-ஆல் மொழிபெயர்க்க முடியாத ஒரு வரியை அது அடைந்துவிட்டது என்பதை நீங்கள் இப்போது புரிந்துகொள்வீர்கள். சில பணிகளுக்கு Python, C-யை விட மெதுவானது என்று நீங்கள் படிக்கும்போது, interpretation மற்றும் high-level abstraction ஆகியவற்றால் ஏற்படும் கூடுதல் சுமையை (overhead) நீங்கள் புரிந்துகொள்வீர்கள். உங்கள் scripts-களுடன் .pyc கோப்புகள் தோன்றுவதைக் காணும்போது, ஒவ்வொரு முறையும் உங்கள் text file-ஐ மீண்டும் மொழிபெயர்க்கத் தேவையில்லை என்பதற்காக Python compiled bytecode-ஐச் சேமித்து (caching) வைக்கிறது என்பதை நீங்கள் உணர்வீர்கள்.

மொழி வரிசையில் (language hierarchy) Python எங்குள்ளது என்பதைத் தெரிந்துகொள்வது, பின்னர் சரியான கருவியைத் தேர்ந்தெடுக்கவும் உதவும். ஒவ்வொரு CPU cycle-ம் முக்கியமான ஒரு device driver-ஐ எழுத வேண்டுமா? நீங்கள் பெரும்பாலும் C அல்லது assembly-யைத் தேர்ந்தெடுப்பீர்கள். ஒரு மதிய நேரத்தில் ஒரு CSV file-ஐச் செயலாக்க வேண்டுமா அல்லது ஒரு web API-யை உருவாக்க வேண்டுமா? Python-ன் interpreter மற்றும் எளிதில் வாசிக்கக்கூடிய syntax இதற்காகவே உருவாக்கப்பட்டவை.

உண்மையான பயன்

Python-ன் வலிமை அதன் நிலையிலிருந்து வருகிறது. இது வன்பொருளுக்கு (hardware) மிக உயரத்தில் உள்ளது; இயந்திர வேகத்தை விட நிரலாளரின் வேகத்திற்கு முக்கியத்துவம் கொடுக்கும் ஒரு interpreter மூலம் இது மொழிபெயர்க்கப்படுகிறது. இந்த பின்னணித் தகவல்கள் தெரியாமலேயே நீங்கள் syntax-ஐக் கற்றுக்கொள்ளலாம், ஆனால் உள்ளே இருக்கும் இயந்திரவியலைப் (machinery) புரிந்துகொள்ளும் வரை உங்களால் புத்திசாலித்தனமாக பிழைத்திருத்தவோ (debug) அல்லது இயல்பாக மேம்படுத்தவோ (optimize) முடியாது. இந்த அடிப்படைகளில் இருந்து தொடங்குங்கள். நீங்கள் உங்கள் முதல் உண்மையான நிரலை எழுதும் போது, நீங்கள் வெறும் கட்டளைகளைத் தட்டச்சு செய்ய மாட்டீர்கள்; அவை எவ்வாறு இயந்திரத்தை அடைகின்றன என்பதைத் துல்லியமாகத் தெரிந்து வைத்திருப்பீர்கள்.