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

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

பைத்தான் நிரலில் C++ நிரலை தருவித்துக் கொள்ளுதலைப் பைத்தானில் C++ யை உறையிடுதல் என்கிறோம்.

ஒரு Scripting மொழி என்பது பிற நிரலாக்க மொழிகளுடன் ஒருங்கிணைப்பதற்கும், தொடர்பு கொள்வதற்கும் வடிவமைக்கப்பட்ட ஒரு நிரலாக்க மொழியாகும். ஜாவாஸ்கிரிப்ட் ஒரு நிரலாக்க மொழியாகும். ஜாவாஸ்கிரிப்ட், VB ஸ்கிரிப்ட், PHP, பெர்ல், பைத்தான், ரூபி, ASP மற்றும் Tcl ஆகியவை மிகவும் பரவலாக பயன்படுத்தப்படும் Scripting மொழியாகும்.

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

பைத்தான் வெற்றிகரமான C++ நிரலை இயக்குவது மட்டுமல்லாது, தொகுத்தலின் போது C++ கூற்றில் ஏதேனும் பிழைகள் இருப்பின் அவற்றை வெளியிடவும் உதவுகிறது. உதாரணத்திற்கு, கீழ்க்காணும் C++ நிரலின் ஒரு பிழை உள்ளது. பைத்தான் மூலம் தொகுக்கும் போது என்ன நேரும் என்பதைத் பார்க்கலாம்.
எடுத்துக்காட்டு :
// C++ program to print the message Hello
// Now select File-s-New in Notepad and type the C++ program
#include< iostream >
using namespace std ;
int main( )
{
std::cout<<"hello"
}
// Save this file as hello.cpp
#Now select File\(\rightarrow \)New in Notepad and type the Python program as main.py
# Program that compiles and executes a .cpp file
# Python main.py -i hello 
import sys, os, getopt
def main(argv):
cpp_file ="
exe_  file ="
opts,args = getopt.getopt( argv,"i:" ,['ifile='])
for o, a in opts :
if in ("-i", "--ifile"):
cpp_file = a + '.cpp'
exe_file = a + '.exe'
runecpp_file, exe_file)
def runecpp_file, exe_file):
print=Compiling " + cpp _file)
os.system('g++ ' + cpp_file +' -o' +exe_ file)
print("Running " + exe_file)
print("_______ ")
print
os.system( exe_file)
print
if____  name =='____  main_____ ':
main(sys.argv[l:])
நிரலின் வெளியீடு 
C:\Program Files\OpenOffice 4\ 
program > Python c:\pyprg\main.py -i c:\pyprg\hello
[('-i', 'c:\\pyprg\\hello')] .
Compiling c:\pyprg\heHo.cpp
c:\pyprg\hello.cpp: In function 'int main( )':
before 'return'
std::cout < <"hello"
/\
;
return 0;
------------
Running c:\pyprg\ch14\cpp __file.exe
_______ 
'c:\pyprg\hello.exe' is not recognized as an internal or external command, operable program or batch file.
C:\Program Files\OpenOffice 4\program> 

பைத்தான் getopt கூறுநிலை : பைத்தானில் getopt கூறுநிலை கட்டளை வரி தேர்வுகளையும் செயலுருபுகளையும் பிரித்தெடுக்க உங்களுக்கு உதவும். இந்த கூறுநிலை கட்டளைவரி செயலுருபு பிரித்தெடுத்தலை செயல்படுத்த செயற்கூறுகளை வழங்குகிறது.
getopt.getopt செயற்கூறு:
இந்த செயற்கூறு கட்டளை வரி தேர்வுகளையும், அளபுருக்களின் பட்டியலையும் பிரித்தெடுக்கும். இந்த வழிமுறைக்கான தொடரியல் பின்வருமாறு
<opts>,<args>=getopt.getopt(argv, options, [long_options])
அளபுருக்களின் விவரங்கள் :
(i) argv - இது பிரிக்கப்பட வேண்டிய அளபுருக்களின் மதிப்புகளின் பட்டியலைக் குறிக்கும். நமது நிரலில், கட்டளை முழுமையும் பட்டியலாக அனுப்பப்படுகிறது.
(ii) options-இது உள்ளீட்டு அல்லது வெளியீட்டு முறைகளை குறிக்கும். சர எழுத்து தேர்வுக்களாகும். இங்கு 'i' அல்லது 'o' போன்ற தேர்வுகளும், அதைத் தொடர்ந்து முக்காற்புள்ளியும் (:) அமைந்திருக்கும். இங்கு (:) முறைமை குறிப்பிடப் பயன்படுகிறது.
(iii) long_options - இந்த அளபுரு சரங்களின் பட்டியலை கொண்டுள்ளது, Long options-ன் செயலுருபைத் தொடர்ந்து அதன் அமைவிடத்தின் முழு முகவரியுடன் '=' சமக்குறி இடம்பெற வேண்டும். நம்முடைய நிரலில் C++ கோப்பின் பெயர் சரமாக செலுத்தப்படும். மேலும், அது ஒரு உள்ளீடு கோப்பு என்பதைக் குறிக்க, அதனுடன் 'i' என்ற தேர்வும் செலுத்தப்படும்.
வழிமுறை இரண்டு உறுப்புகளை கொண்டுள்ள மதிப்புகளை திருப்பியனுப்பும். இவை ஒவ்வொன்றும் தனித்தனியாக opts மற்றும் args என்ற இரண்டு வெவ்வேறு பட்டியலில் (அணிகள்) சேமிக்கப்படும்.
Opts முறைமை, பாதைப் போன்ற பிரிக்கப்பட்ட சரங்களின் பட்டியலைக் கொண்டிருக்கும். Args, தவறான பாதை அல்லது முறைமையின் காரணமாக பிரிக்கப்பட முடியாத எந்தவொரு சரத்தின் பட்டியலைக் கொண்டிருக்கும்.
getopt() வழிமுறையின் மூலம் சரங்களை பிரித்தெடுக்கும் போது பிழையேதும் இல்லாவிட்டால் args வெற்று அணியாக அமையும்.
உதாரணத்திற்கு, p4 என்ற C++ கோப்பினை, கட்டளை வரியில் இயக்கப்போகும் பைத்தான் நிரல், பின்வரும் ஒன்றைப் போல getopt() வழிமுறையைக் கொண்டிருக்கும்.
opts, args = getopt.getopt (argv, "i:",['ifile='])

நம்முடைய எடுத்துக்காட்டுகளில், கட்டளை வரி கட்டளைகளை அனைத்தும் பிரிக்கப்பட்டிருப்பதாலும், செயலுருபு மீதமில்லாமலிருப்பதாலும்,
இரண்டாவது செயலுருபு args வெறுமையாக இருக்கும். Print() கட்டளையைப் பயன்படுத்தி args வெளிக்காட்டப்பட்ட செய்திருந்தால், வெளியீடு [] என இருக்கும்.
>>>print(args)
[ ]

உதாரணத்திற்கு, கட்டளை தூண்டுக்குறியில் "Python pycpp.py - i pali" என்று உள்ளிட்டு enter விசையை அழுத்தவும். தொகுத்தல் வெற்றிகரமாக முடிந்தால் நீங்கள் எதிர்பார்த்த வெளியீடு கிடைக்கும் இல்லையேல் பிழைச் செய்தி வெளியிடப்படும். 

(i) பைத்தான் பயனிலா (garbage) மதிப்புகளைச் சேகரிக்கும் தானியங்கியைப் பயன்படுத்துகிறது. இந்த பண்புக்கூறு C++ல் கிடையாது.
(ii) C++ நிலையான வகையைச் சார்ந்த மொழி, ஆனால் பைத்தான் ஒரு மாறக்கூடிய வகையைச் சார்ந்த மொழியாகும்.
(iii) பைத்தான் வரி மொழி மாற்றி மூலம் இயங்குகிறது. ஆனால் C++ நிரல் பெயர்ப்பியின் மூலம் தொகுக்கப்பட்டு இயக்கப்படுகிறது.
(iv) C++ நிரல் குறிமுறையைக் காட்டிலும் பைத்தான் குறிமுறை 5-லிருந்து 10 மடங்கு குறைவானது.
(v) பைத்தானில், வெளிப்படையாக தரவினங்களை அறிவிக்க தேவையில்லை.

C++ நிரலை இயக்குவதற்கான படிநிலைகள்:
படிநிலை 1 உள்ளீடு செய்யப்பட்ட எண் பாலிண்ட்ரோமோ இல்லையா என சோதிக்கும் C++ நிரலை நேர்கோட்டில் தட்டச்சு செய்து pali.cpp என்று சேமிக்கவும்.
படிநிலை 2 பைத்தான் நிரலை தட்டச்சு செய்து pali.py என்று சேமிக்கவும்.
படிநிலை 3 Run முனையத்தை Run terminal கிளிக் செய்து கட்டளை சாளரத்தை திறக்கவும்.
படிநிலை 4 பைத்தான் கோப்புறைக்கு Cd கட்டளையை பயன்படுத்தி செல்லவும்.
படிநிலை 5 python pali.py -i pali என்ற கட்டளையை தட்டச்சு செய்யவும்.

(i) ஒரு கூறுநிலைக்குள் மற்றொரு கூறுநிலையின் வரையறைகளைத் தருவித்துக் கொள்ளலாம். அவ்வாறு செய்வதற்கு நாம் 'import''என்ற சிறப்பு சொல்லைப் பயன்படுத்த முடியும்.
(ii) நாம் முன்னதாக வரையறுத்து factorial என்ற கூறுநிலையைத் தருவித்துக் கொள்ள பைத்தான் தூண்டுகுறியில் கீழ்கண்டவாறு தட்டச்சு செய்யவும்.
>>> import factorial
(iii) கூறுநிலைக்குள், வரையறுக்கப்பட்ட செயற்கூறுகளை, கூறுநிலையின் பெயரைப் பயன்படுத்தி அணுக முடியும்.
(iv) செயற்கூறுகளை அணுக புள்ளிச் செயற்குறி பயன்படுத்தப்படுகிறது கூறுநிலையிலிருந்து செயற்கூறுகளை அணுகுவதற்கான தொடரியல் 
.< module name > . < function name >

(i) பைத்தான் பல கூறுநிலைகளைக் கொண்டுள்ளது . ஒரு சிக்கலுக்கு நிரலர்கள் பல தரப்பட்ட கூறுநிலைகளைத் தங்கள் வசதிக்கேற்ப பயன்படுத்திக் கொள்ள பைத்தான் அனுமதிக்கிறது.
(ii) இப்பொழுது நாம் கற்றுக் கொள்ளவிருக்கும் பைத்தான் நிரல் அடிப்படை பைத்தான் நிரலில் நீங்கள் அறிந்திராத சில புதிய கட்டளைகளைக் கொண்டுள்ளது.
(iii) இந்த அதிகாரத்தில், நிரல்கள் இரண்டு வெவ்வேறு மொழிகளின் ஒருங்கிணைப்பைப் பெற்றுள்ளதால் os,sys மற்றும் getopt போன்ற கூறுநிலைகளைத் தருவித்துக் கொள்ள வேண்டும்.

(i) MinGW run -ன் முனையத்தை இரட்டைக் கிளிக் செய்யவும்.
(ii) பைத்தான் மென்பொருள் அமைந்திருக்கும் (python.exe) கோப்புறைக்கு செல்லவும்.
இந்த உதாரணத்தில், பைத்தான் கோப்புறை C:\Program Files\OpenOffiice 4\Python என்ற அமைவிடத்தில் காணலாம்.
c: \ > கோப்புறையிலிருந்து பைத்தான் அமைந்திருக்கும் கோப்புறைக்கு மாறுவதற்கான தொடரியல்.
cd < absolute path >
இதில் "cd" கட்டளை change directory என்பதையும் absolute path என்பது பைத்தான் நிறுவப்பட்டிருக்கும் முழுமையான பாதையையும் குறிக்கும்.

பொதுவாக பயன்படுத்தப்படும் இடைமுகங்களாவன.
(i) Python-C-API (API -Application Programming Interface C நிரல்களுடன் தொடர்பு கொள்ள)
(ii) Ctypes (c நிரல்களுடன் தொடர்பு கொள்ள)
(iii) SWIG (Simplified Wrapper Interface Generator-C மற்றும் C++ இரண்டு மொழிகளுக்கும்)
(iv) Cython (C-நீட்டிபுக்களை எழுதுவதற்கான ஒரு பைத்தான் போன்ற மொழியாகும்)
(v) Boost. Python (Python மற்றும் C++ தொடர்பு கொள்வதற்கான கட்டமைப்பு)
(vi) MinGW (விண்டோஸ்-க்கான குறைந்தபட்ச GNU)