Tuple:
(i) Pairs என்பது இரு தரவு பகுதிகளை சேமிக்கும் கலவை தரவு என்பதை நினைவில் கொள்ள வேண்டும்.
(ii) இதுவரை இருவேறு முறைகளில் pairs தரவு வகை உருவமைப்பை முதல் வழி, List கொண்டு உருவமைத்தல் மற்றும் இரண்டாம் வழி Tuple கொண்டு வடிவமைத்தல் ஆகும்.
(iii) tuple என்பது அடைப்புக்குறிக்குள் கொடுக்கப்பட்டுள்ள தொடர் மதிப்புகளை காற்புள்ளியில் பிரிக்கப்பட்டிருக்கும். tuple என்பது List போன்றதாகும்.
(iv) இவை இரண்டிற்கும் உள்ள வேறுபாடு என்னவென்றால் tuple -ல் கொடுக்கப்பட்ட உறுப்புகளை மாற்ற முடியாது, ஆனால் List -ல் இடம்பெற்றுள்ள உறுப்புகளை மாற்றலாம். எடுத்துக்காட்டு:
 colour = ('red', 'blue', 'Green')
Tuple-சை Pair உருவமைத்தல்:
 nums: = (1, 2)
 nums0
 1
 nums1
 2
(v) சதுர அடைப்புக்குறி குறியீடு, பேர்ஸில் சேமிக்கப்பட்டுள்ள தரவுகளை அணுகுவதற்கு பயன்படுகிறது என்பதை கவனிக்கவும். தரவுகள் பூஜ்யம் சுட்டு வரிசைப்பட்டுள்ளதால், முதல் உறுப்பு nums[0] என்றும் இரண்டாம் உறுப்பு nums[1] என்றும் அணுகப்படும்.

தேர்ந்தெடுப்பு வரிசையாக்கம் (Selection Sort):
(i) பட்டியலில் ஒவ்வொரு முறியும் நுழையும் போது ஒரே ஒரு இடமாற்றம் மட்டுமே இருப்பதால், இது குமிழி வரிசையாக்கத்தை விட மேம்பட்டதாகும்
(ii) தேர்ந்தெடுப்பு வரிசையாக்கமானது கருத்துருவின் படி மிகவும் எளிமையான வரிசையாக்க நெறிமுறையாகும்
(iii) இந்த நெறிமுறை, முதலில் மிகச்சிறிய உறுப்பை அணியில் கன்டுபிடித்து அதனை முதல் இருப்பிடத்திலுள்ள உறுப்புகளையும் வரிசைப்படுத்தப்படும் வரை இடமாற்றமானது நடைபெறும்
போலி குறிமுறை:
(i) முதல் உறுப்பில் தொடங்கி அணியில் உள்ள மிகச் சிறிய உறுப்பைத் தேடி, முதல் இடத்தில் உள்ள உறுப்போடு இடமாற்றம் செய்ய வேண்டும். (அணியின் சுட்டு எண் 0 - ல்)
(ii) பிறகு இரண்டாவது இடத்திற்கு சென்று, துணை அணியில் உள்ள மிகச் சிறிய உறுப்பை சுட்டெண் வரை தேட வேண்டும்
(iii) அணி வரிசையாக்கம் செய்யப்படும் வரை, இதை மீண்டும் மீண்டும் செய்தல் வேண்டும் (13, 16, 11, 18, 14, 15} மதிப்புகளைக் கொண்ட ஒரு அணியை எடுத்துக்கொள்வோம்
(iv) தேர்ந்தெடுப்பு வரிசையாக்கம் கொடுக்கப்பட்ட அணியை எவ்வாறு வரிசையாக்கம் செய்கிறது என்பதற்கான விளக்கப்படம் கீழே கொடுக்கப்பட்டுள்ளது

(v) முதல் சுற்றில், மிகச் சிறிய எண் 11 ஆகும். எனவே, அது முதல் இடத்தில இறுதி வைக்கப்படுகிறது
(vi) முதல் உறுப்பைத் தவிர்த்து, மீதமுள்ள உறுப்புகளில் இருந்து அடுத்த மிகச் சிறிய உறுப்பைத் தேட வேண்டும்
(vii) 13 தான் அடுத்த மிகச்சிறிய எண் ஆதலால் அதை இரண்டாம் இடத்தில் இறுதி வைக்கப்படுகிறது
(ix) இவ்வாறு அணியானது வரிசைப்படுத்தப்படும் வரை மீண்டும் மீண்டும் இச்செயல் நடைபெறும்

வ. எண்	நெறிமுறை	நிரல்
1.	சிக்கலை தர்க்கரீதியாக தீர்க்க உதவுகிறது மற்றும் நிரலுடன் வேறுபட்டிருக்கலாம்	நிரல் என்பது நிரலாக்க மொழியில் நெறிமுறையின் வெளிப்பாடாகும்
2.	செயல்படுத்தப்படும் முறை மற்றும் வடிவமைப்பு நுடம் ஆகியவற்றை பொறுத்து இதனை வகைப்படுத்தலாம்	கடனமைப்பு நிரல் அணுகுமுறை அல்லது பொருள் நோக்கு நிரலாக்க அணுகுமுறையை பயன்படுத்தி இதனை செயல்படுத்த முடியும்
3.	நெறிமுறைக்கு குறிப்பிட்ட விதிமுறைகள் கிடையாது ஆனால் சில வழிகாட்டுதல்களை பின்பற்ற வேண்டும்	தேர்ந்தெடுக்கப்பட்ட மொழியில் குறிப்பிட்ட கட்டளை அமைப்புகளைக் கொண்டு நிரலை எழுதலாம்
4.	போலி குறிமுறையை ஒத்திருக்கும் இதை எந்த கணிப்பொறி மொழியில் வேண்டுமானாலும் செயல்படுத்தலாம்	நிரலாக்க மொழிக்கு மிகவும் குறிப்பிடத் தக்கதாக நிரல் இருக்க வேண்டும்

(i) ஒரு அணியில் n - மதிப்புகள் உள்ளதாக வைத்துக் கொள்வோம். இந்த பட்டியலில் இருந்து ஒரு குறிப்பிட்ட உறுப்பைத் தேட வேண்டும்
(ii) நெறிமுறையானது n - உறுப்புகளைக் கொண்ட பட்டியலில் இருந்து தேட வேண்டிய பட்டியலில் உள்ள ஒவ்வொரு உறுப்புகளோடு வரிசையாக ஒப்பீடு செய்து உறுப்புகளை பட்டியலில் ஒவ்வொன்றாக அதன் முதன்மை உறுப்பை கொண்டு ஒப்பிட வேண்டும்
(iii) இந்த எடுத்துக்காட்டில், பட்டியலில் உள்ள முதல் உறுப்பு தேடப்படும் உறுப்போடு பொருத்தமாக இருந்தால் அது தான் மிகச் சிறந்த நிலையாகும்
(iv) இந்த நிலையின் செயல்திறனை O(1) என்று வெளிப்படுத்தலாம். ஏனெனில், ஒரே ஒரு ஒப்பீடுதான் தேவைப்படுகிறது
(v) அதேபோல, இந்த எடுத்துக்காட்டில்,பட்டியல் முழுவதற்கும் சென்று தேடினால், அந்த உறுப்பு பட்டியலில் இறுதியில் கண்டுபிடிக்கப்பட்டால் அல்லது பட்டியலின் இல்லாமல் இருந்தால் அதுதான் மோசமான நிலையாகும்
(vi) இந்த நிலையின் செயல்திறனை O(n) என்று வெளிப்படுத்தலாம், ஏனென்றால், n ஒப்பீடுகள் செய்யப்படுகின்றன
(vii) அதே எடுத்துக்காட்டுடன் தொடர்ந்தால் சராசரி ஒப்பீடுகள் எண்ணிக்கையைக் கண்டுபிடிப்பதன் மூலம் சராசரி நிலையின் செயல்திறனைப் பெறலாம். இங்கு,
குறைந்தபட்ச ஒப்பீடுகளின் எண்ணிக்கை = 1
அதிகபட்ச ஒப்பீடுகளின் எண்ணிக்கை = n 
கண்டுபிடிக்கப்படாத உறுப்பின் அதிகபட்ச ஒப்பீடுகள் எண்ணிக்கை = n 
எனவே, சராசரி ஒப்பீடுகள் எண்ணிக்கை = (n + 1)2
ஆகையால் சராசரி நிலையின் செயல்திறனை O(n) என்று வெளிப்படுத்தலாம்

import sqlite3
connection = sqlite3 . connect ("ABC.db")
cursor = connection. cursor ( )
sql_command = " " "
CREATE TABLE Item (Icode INTEGER, Item_Name VARCHAR (25), Rate Integer); " " "
cursor. execute (sql_command)
sql_command = " " "INSERT INTO Item (Icode, Item_name, Rate)
VALUES (1008, "Monitor", 15000);" " "
cursor. execute (sql_command)
connection.commit ()
connection.close ()
Print ("TABLE CREATED").
வெளியீடு:
(1008, 'Monitor', 15,000)

#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 welcome
import sys, os, getopt
def main(argv):
      cpp_file = ''
      exe_file = "
       opts, args = getopt,getopt(argv,"i:",['ifile='])
       for 0, a in opts:
          if 0 in ("-i", "--ifile"):
          cpp_file = a + '.cpp'
          exe_file = a + '.exe'
          run(cpp_file, exe_file)
def run(cpp_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[1:])
வெளியீடு:
         

Python	கட்டளை வரியிலிருந்து பைத்தான் நிரலை செயல்படுத்துவதற்கான சிறப்புச் செயல்
filename.py	செயல்படுத்த வேண்டிய பைத்தான் நிரலின் பெயர்
-i	உள்ளீட்டு முறைமை
C++ filename without cpp extension	தொகுக்கப்பட்டு செயல்படுத்தப்பட வேண்டிய C++ நிரலின் பெயர்

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

import csv
info = [['SNO', 'Person', 'DOB'],
['1', 'Madhu', '18/12/2001'],
['2', 'Sowmya','19/12/1998'],
['3', 'Sangeetha','20/3/1999'],
['4', 'Eshwar', '21/4/2000'],
['5', 'Anand', '22/5/2001']
csv.register_dialect('myDialect' ,quoting=csv. QUOTE_ALL)
with open(' c:\\pyprg\\ch13\\person.csv' ,'w') as f:
writer = csv.writer(f, dialect='myDialect')
for row in info:
writer.writerow(row)
f.close( )

பைத்தானில் கோப்பு முறைமைகள்:

முறை	விளக்கம்
'r'	படிப்பதற்கு மட்டுமே ஒரு கோப்பினை திறக்கவும் (தானமைவு நிலை)
'w'	கோப்பில் தரவுகளை எழுதுவதற்கு திறக்கவும். குறிப்பிடப்பட்ட கோப்பு இல்லையெனில் புதிய கோப்பினை உருவாக்கும். கோப்பில் தரவுகள் இருப்பின் அவை அழிக்கப்படும்.
'x'	தனித்துவமான படைப்பிற்காக கோப்பினை திறக்கவும். கோப்பு முன்பே உருவாக்கப்பட்டிருந்தால் இந்த செயல் முறையானது தோல்வியடையும்.
'a'	கோப்பின் தரவுகளை அழிக்காமல் அதன் இறுதியில் புதிய தரவுகளை சேர்ப்பதற்கு திறக்கவும். குறிப்பிட்ட கோப்பு இல்லையெனில் புதிய கோப்பினை உருவாக்கும்.
't'	உரை முறைமையில் கோப்பு திறக்கவும் (தானமைவு நிலை)
'b'	இருமநிலை முறைமையில் கோப்பினை திறக்கவும்.
'+'	புதுப்பித்தலிற்காக கோப்பினை திறக்கவும்.(படித்தல் மற்றும் எழுதுதல்)

SQL- கட்டளைகள் ஐந்து பொதுப்பிரிவுகளாக பிரிக்கப்பட்டுள்ளது:
(i) DML - தரவு கையாளுதல் மொழி
(ii) DDL - தரவு வரையறை மொழி
(iii) DCL - தரவு கட்டுப்பாடு மொழி 
(iv) TCL - பரிவர்த்தனை கட்டுப்பாட்டு மொழி
(v) DQL - தரவு வினவல் மொழி
(i) தரவு வரையறை மொழி:
தரவு வரையறை மொழி(DDL) தரவுத்தள அமைப்பு அல்லது திட்ட வடிவமைப்பினை வரையறுக்கும் SQL கூற்றுகளை கொண்டிருக்கும். இது தரவுத்தள திட்ட வடிவமைப்பின் விளக்கங்களுடன் செயல்படுகிறது. மேலும், தரவுத்தளங்களில் உள்ள தரவுத்தள உறுப்புகளில் கட்டமைப்பை உருவாக்குவதற்கும், மாற்றியமைப்பதற்கும் பயன்படுகிறது
தரவு வரையறை மொழியின் கீழ்வரும் SQL கட்டளைகள் பின்வருமாறு:
CREATE தரவுத்தளத்தில் அட்டவணைகளை உருவாக்க
ALTER தரவுத்தளத்தின் வடிவமைப்பை மாற்றியமைக்க 
DROP தரவுத்தளத்தில் உள்ள அட்டவணைகளை நீக்க
TRUNCATE ஒரு அட்டவணையில் உள்ள அனைத்து பதிவுகளையும் அளிக்கும், மேலும் அவற்றுக்கென ஒதுக்கப்பட்ட இடத்தையும் விடுவிக்கும்
(ii) தரவு கையாளுதல் மொழி:
தரவு கையாளுதல் மொழி (DML) என்பது ஒரு தரவுத்தளத்தில் உள்ள தரவுகளை சேர்த்தல் அழித்தல் மற்றும் மாற்றியமைப்பதற்காக பயன்படும் ஒரு வினவல் மொழியாகும். SQL- ல் தரவு கையாளுதல் மொழி தரவுத்தள அட்டவணையில் சேமித்து வைக்கப்பட்டுள்ள தரவுகளை மாற்றியமைக்க பயன்படும் SQL தரவு மாற்று கூற்றுகளை கொண்டிருக்கும்
தரவுத்தள திட்ட வடிவமைப்பின்படி, தரவுத்தளம் உருவாக்கிய பின்னர், DML ல் குறிப்பிடப்பட்டுள்ள செயல் முறைகளின் தொகுப்பை பயன்படுத்தி தரவுகளை கையாளலாம்
SQL-லில் உள்ள தரவு கையாளுதல் மொழியின் கட்டளைகள்:
INSERT ஒரு அட்டவணையில் தரவுகளை நுழைத்தல்
UPDATE அட்டவணையில் ஏற்கனவே உள்ள தரவுகளை புதுப்பித்தல்
DELETE அட்டவணையில் உள்ள அனைத்து பதிவுகளையும் நீக்கும். ஆனால் அவற்றிற்கு ஒதுக்கப்பட்ட நினைவாக பகுதியை விடுவிக்காது
(iii) தரவு கட்டுப்பாடு மொழி:
ஒரு தரவு கட்டுப்பாடு மொழி என்பது தரவுத் தளத்தில் சேமித்து வைக்கப்பட்டுள்ள தரவுகளின் அணுகுதலை கட்டுப்படுத்தும் ஒரு நிரலாக்க மொழியாகும். இது தரவுத்தளத்தை அணுகுவதற்கான சிறப்புரிமையை கட்டுப்படுத்துகிறது (அங்கீகாரம்). இத்தகைய சிறப்புரிமைகள் வரிசைத்தொடர்களை உருவாக்கல், அட்டவணைகளை பார்வையிடுதல் போன்ற அனைத்து தரவுத்தள செயல்பாடுகளை செயல்படுத்துவதைக் குறிக்கும்
SQL- லில் உள்ள தரவு கட்டுப்பாடு மொழியின் கட்டளைகள்:
GRANT ஒரு குறிப்பிட்ட பணியை செய்ய ஒன்று அல்லது அதற்கு மேற்பட்ட பயனர்களுக்கு அனுமதி வழங்கும்
REVOKE Grant கட்டளையினால் தரப்பட்ட அணுகல் அனுமதி திரும்பப் பெறப்படும்.
(iv) பரிவர்த்தனைக்கான கட்டுப்பாட்டு மொழி :
தரவுத்தளத்தில் உள்ள பரிவர்த்தனைகளை (TCL) நிர்வகிக்க பரிவர்த்தனை கட்டுப்பாட்டு மொழி பயன்படுகிறது. DML கூற்றுகளின் மூலம் அட்டவணையில் உள்ள தரவுகளுக்கு செய்யப்படும் மாற்றங்களை நிர்வகிக்க அவை பயன்படுத்தப்படுகின்றன.
SQL - லில் உள்ள பரிவர்த்தனை கட்டுப்பாட்டு மொழியின் கட்டளைகள்:
Commit தரவுத்தள பரிவர்த்தனையை நிரந்தரமாக சேமிக்கும்.
Roll back ஒரு தரவுத்தளத்தை முந்தைய Commit நிலைவரை மீட்டெடுக்கும்
Save point Rollback செய்வதற்கு ஏதுவாக தரவுத்தள பரிவர்த்தனையை தற்காலிகமாக சேமிக்கும்
(v) தரவு வினவல் மொழி:
தரவு வினவல் மொழி ஒரு தரவுதளத்தில் உள்ள தரவுகளை வினவலுக்கும், மீட்டெடுப்பதற்கான கட்டளைகளை கொண்டுள்ளது. தரவு வினவல் மொழியில் உள்ள அத்தகைய ஒரு SQL கட்டளை SELECT ஆகும்
Select: அட்டவணையிலுள்ள பதிவுகளை வெளிக்காட்டும்

கட்டுப்பாடுகளின் வகைகள்:
கட்டுப்பாடுகள் தரவுத்தள ஒருங்கிணைப்பை உறுதி செய்வதால், அவற்றை தரவுத்தள ஒருங்கிணைப்பு கட்டுப்பாடுகள் எனவும் அழைக்கலாம். கட்டுப்பாடுகள் பலவகைப்படும். அவை
(i) Unique கட்டுப்பாடு:

இந்த கட்டுப்பாடு குறிப்பிட்ட நெடுவரிசைகளில் எந்த இரு வரிசைகளும் ஒரே மதிப்பை கொண்டிருக்காது என்பதை உறுதி செய்கிறது. உதாரணத்திற்கு, student அட்டவணையில் Admno என்ற புலத்திற்கு UNIQUE கட்டுப்பாட்டை பயன்படுத்தி, ஒரே சேர்க்கை எண் இரு மாணவர்களுக்கு தரப்படாததை உறுதி செய்து கொள்ளலாம். இந்த கட்டுப்பாட்டை கீழ்கண்டவாறு பயன்படுத்திக் கொள்ளலாம்:
CREATE TABLE Student
(
Admno integer NOT NULL UNIQUE, \(\rightarrow\)
Unique constraint
Name char (20) NOT NULL,
Gender char (1),
Age integer,
Place char (10),
);
UNIQUE கட்டுப்பாட்டை NOT NULL என்று அறிவிக்கப்பட்ட புலங்களுக்கு மட்டுமே பயன்படுத்த முடியும். ஒரு தனிப்பட்ட புலத்திற்கு இரு கட்டுப்பாட்டுகளை பயன்படுத்தினால் அப்புலம் பல கட்டுப்பாடுகளைக் கொண்ட புலம் என அழைக்கலாம். மேற்கண்ட கட்டளை அமைப்பில் NOT NULL மற்றும் UNIQUE எனும் பல கட்டுப்பாடுகள் Admno என்ற ஒரு தனித்த புலத்தில் பயன்படுத்தப்பட்டுள்ளது.
(ii) Primary Key கட்டுப்பாடு:
தரவுத்தளத்திலுள்ள ஒரு பதிவை தனித்தன்மையோடு அடையாளம் காட்ட ஒரு புலத்தினை primary key என்ற கட்டுப்பாட்டுடன் அறிவிக்க வேண்டும். இது unique கட்டுப்பாட்டினை போன்றே காணப்பட்டாலும் அட்டவணையின் ஒரு புலத்தை மட்டுமே primary key ஆக குறிப்பிட முடியும். primary key கட்டுப்பாடு வெற்று (NULL) மதிப்புகளை அனுமதிக்காது என்பதால், primary key என்ற கட்டுப்பாட்டுடன் அறிவிக்கப்படும் புலம் NOT NULL என்ற கட்டுப்பாட்டையும் கொண்டிருக்க வேண்டும்.
மாணவர் அட்டவணையில் primary key கட்டுப்பாட்டை பயன்படுத்துதலை விளக்கும் எடுத்துக்காட்டு: 
CREATE TABLE Student
(
Admno integer PRIMARY KEY, \(\rightarrow\) Primary Key constraint
Name char(20) NOT NULL,
Gender char(1),
Age integer,
Place char(10),
);
மேற்கண்ட எடுத்துக்காட்டில், admno என்ற புலம் primary key என்று வரையறுக்கப்பட்டுள்ளதால், ஒரு பதிவை தனித்தன்மையோடு அடையாளம் காட்ட முடிகிறது. மேலும் NOT NULL என்றும் வரையறுக்கப்பட்டுள்ளதால், இந்த புலத்தின் மதிப்பு காலியாக இருக்கக் கூடாது
(iii) DEFAULT கட்டுப்பாட்டு:
DEFAULT கட்டுப்பாடு ஒரு புலத்தில் கொடாநிலை மதிப்புகளை இருத்தி வைக்க பயன்படுகிறது. DEFAULT கட்டுப்பாட்டை கொண்ட குறிப்பிட்ட புலத்திற்கு மதிப்பு கொடுக்காவிடில், தானாகவே கொடாநிலை மதிப்பு அந்த புலத்தில் இருத்தப்பட்டுவிடும், மாணவர் அட்டவணையில் Default கட்டுப்பாடு பயன்படுத்துதலை விளக்கும்.
எடுத்துக்காட்டு:
CREATE TABLE Student
(
Admno integer PRIMARY KEY,
Name char(20) NOT NULL,
Gender char(1),
Age integer DEFAULT 17,  \(\rightarrow\) Default Constraint
Place char(10),
);
மேற்கண்ட எடுத்துக்காட்டில் "Age" என்ற புலத்திற்கு 17 என்று கொடாநிலை மதிப்பு கொடுக்கப்பட்டுள்ளதால், அந்த புலத்தில் பயனரால் எந்த மதிப்பும் உள்ளிடப்படவில்லை எனில், "Age" என்ற புலம் தானாகவே 17 மதிப்பை எடுத்துக்கொள்ளும்.
(iv) CHECK கட்டுப்பாடு:
இந்த கட்டுப்பாடு ஒரு புலத்திற்கான மதிப்பின் வரம்பை நிர்ணயிக்க உதவுகிறது. CHECK கட்டுப்பாட்டை ஒரு நெடுவரிசைக்கு வரையறுத்தால், அப்புலத்தில் வரையறுக்கப்பட்ட மதிப்புகளை மட்டுமே உள்ளிட அனுமதிக்கும்
மாணவர் அட்டவணையில் CHECK கட்டுப்பாட்டை பயன்படுத்துதலை விளக்கும் எடுத்துக்காட்டு
CREATE TABLE Student
(
Admno integer PRIMARY KEY
Name char(20) NOT NULL,
Gender char(1),
Age integer (CHECK Age < = 19), \(\rightarrow\) Check Constraint
Place char(10),
);
மேற்கண்ட எடுத்துக்காட்டில், Age என்ற புலத்தில் CHECK கட்டுப்பாட்டை பயன்படுத்தி, Age என்ற புலத்திற்கு உள்ளிடும் மதிப்பு 19க்கு குறைவாகவோ அல்லது சமமாகவோ இருக்க வேண்டும் என வரையறுக்கப்படுகிறது
(v) அட்டவணை கட்டுப்பாடு:
ஒரு அட்டவணையில் உள்ள புலங்களின் குழுவிற்கு கட்டுப்பாட்டைப் பயன்படுத்தினால் அதனை அட்டவணைக் கட்டுப்பாடு என்கிறோம். பொதுவாக, அட்டவணை கட்டுப்பாடு அட்டவணை வரையறுப்பின் இறுதியில் குறிப்பிடப்படும், Admno, Firstname, Lastname, Gender, Age, Place என்ற புலங்களை கொண்ட student 1 என்ற ஒரு புதிய அட்டவணையை எடுத்துக்கொள்வோம்
CREATE TABLE Student!
(
Admno integer NOT NULL,
Firstname char(20),
Lastname char(20),
Gender char(1),
Age integer,
Place char(10),
PRIMARY KEY (Firstname, Lastname) \(\rightarrow\) Table constraint
);
மேற்கண்ட எடுத்துக்காட்டில் primary key என்று வரையறுக்கப்பட்டுள்ள Firstname, Lastname என்ற இருபுலங்கள், அட்டவணை கட்டுப்பாடுடையதாக அமைந்துள்ளன.

1.	தரவுகளை கையாளும் திறன்	உறவுநிலை தரவுதள மேலாண்மை அமைப்பானது தரவு தளத்தில் தரவுகளை கையாளும் வசதியை வழங்குகிறது (சேமித்தல், மாற்றம் செய்தல் மற்றும் நீக்குதல்)
2.	மிகைமை (தேவைக்கு அதிகமானவற்றை) குறைத்தல்	நவீன உலகில் வன்வட்டுகளின் விலை மிகவும் குறைவு. ஆனால் முந்தைய காலங்களில் வன்வட்டுகள் மிகவும் விலை உயர்ந்தவை, ஆகையால் தரவுதளத்தில் உள்ள தேவையற்ற தரவுகள் பெரிய சிக்கலாக இருந்தது. ஆனால் RDBMS தரவுகளை பிரித்தாளும் இயல்பு நிலையைப் பின்பற்றி தேவையற்ற தரவுகள் மீண்டும் இடம்பெறுவதைக் குறைக்கிறது.
3.	தரவுகளின் நிலைத்தன்மை	தொடர்ச்சியாக புதுப்பிக்கப்படும் மற்றும் பராமரிக்கப்படும் நேரடி தரவின் (Live data) நிலைத்தன்மையை பராமரிப்பது ஒரு சவாலாக மாறும். ஆனால் RDBMS தானாகவே அதை கையாளுகிறது.
4.	பல பயனர்கள் மற்றும் ஒத்த அணுகுதலை ஆதரித்தல்	RDBMS பல பயனர்களை ஒரே நேரத்தில் ஒரு தரவின் மீது வேலை (தரவுகளைப் புதுப்பித்தல், செருகுதல், நீக்குதல்) செய்ய அனுமதிக்கிறது. இருப்பினும் தரவின் நிலைத்தன்மைப் பராமரிப்பை கையாளுகிறது.
5.	வினவல் மொழி	RDBMS ஒரு எளிய வினவல் மொழியை பயனருக்கு வழங்குகிறது. இதைப்பயன்படுத்தி தரவுத்தளத்திலிருந்து தரவுகளை எளிமையாக பெறவும், சேர்க்கவும், நீக்கவும், புதுப்பிக்கவும் முடியும்.
6.	பாதுகாப்பு	RDBMS. தரவின் பாதுகாப்பை கவனித்துக்கொள்கிறது. அங்கீகாரமற்ற அணுகுதலில் இருந்து தரவுகளுக்கு பாதுகாப்பை வழங்குகிறது. வழக்கமான RDBMS -ல், பல்வேறு அணுகலுக்கான அனுமதியுடன் பயனர் கணக்குகளை நாம் உருவாக்கமுடியும். இதனைப் பயன்படுத்தி பயனர் அணுகுதலை கட்டுப்படுத்தி நம்முடைய தரவுகளை எளிமையாக பாதுகாத்துக் கொள்ள முடியும்.
7.	RDBMS பரிவர்த்தனைகளை ஆதரித்தல்	இது நிகழ் உலக பயன்பாடுகளில் தரவு ஒருமைப்பாட்டை கையாள மற்றும் நிர்வகிக்க நம்மை அனுமதிக்கிறது. இங்கு பல்புரியாக்கம் (multithreading) விரிவாக பயன்படுகிறது.

தரவுத்தளத்தில் பயன்படும் உறவுநிலைகளின் வகைகள்.
1. ஒன்றுடன் ஒன்று உறவுநிலை (One-to-One Relationship)
2. ஒன்றுடன் பல உறவுநிலை (One-to-Many Relationship)
3. பலவற்றுடன் ஒன்று உறவுநிலை (Many-to- One Relationship)
4. பலவற்றுடன் பல உறவுநிலை (Many-to- Many Relationship)
1. ஒன்றுடன் ஒன்று உறவுநிலை:
(i) இந்த உறவுநிலையில் ஒரு பொருள் வேறு ஒரு பொருளுடன் மட்டுமே தொடர்பு கொண்டிருக்கும். ஒரு அட்டவணையின் ஒரு பதிவு மற்றொரு அட்டவணையின் ஒரு பதிவுடன் மட்டுமே இணைக்கப்பட்டிருக்கும்.
(ii) எடுத்துக்காட்டு: ஒரு மாணவனுக்கு ஒரு தேர்வெண் மட்டுமே இருக்க முடியும்.

2. ஒன்றுடன் பல உறவுநிலை :
(1) இந்த உறவுநிலையில் ஒரு பொருள் வேறு பல பொருள்களுடன் தொடர்பு கொண்டிருக்கும். அட்டவணை A-வின் ஒரு பதிவு அட்டவணை B யின் பல பதிவுகளுடன் தொடர்பு கொண்டிருக்கலாம்.
(ii) ஆனால் அட்டவணை B யின் ஒரு பதிவு அட்டவணை A-வின் ஒரு பதிவுடன் மட்டுமே தொடர்பு கொண்டிருக்க முடியும்.
(iii) எடுத்துக்காட்டு: ஊழியர்களைக் கொண்டுள்ளது.

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

4. பலவற்றுடன் பல உறவுநிலை :
(i) இந்த உறவுநிலையில் ஒரு அட்டவணையில் உள்ள பல பதிவுகள் மற்றொரு அட்டவணையில் உள்ள பல பதிவுகளுடன் தொடர்பு கொண்டிருக்கும்.
(ii) எடுத்துக்காட்டு 1: நுகர்வோர் மற்றும் விலை பொருள்: நுகர்வோர் பல விலைப்பொருள்களை வாங்குகிறார் மற்றும் விலைப்பொருள்கள் பல நுகர்வோரால் வாங்கப்படலாம்.
(iii) எடுத்துக்காட்டு 2: மாணவர்கள் மற்றும் பாடப்பிரிவுகள்: ஒரு மாணவன் பல பிரிவுகளில் பதியலாம் மற்றும் ஒரு பாடப்பிரிவு பல மாணவர்களைக் கொண்டிருக்கலாம்.
(iv) எடுத்துக்காட்டு 3: புத்தகங்கள் மற்றும் மாணவன்: நூலகத்தில் உள்ள பல புத்தகங்கள் பல மாணவர்களுக்கு வழங்கப்படும்.

Class stationery:
def getdata(self):
self.Itemname = input ("enter name of the item")
self.Brand = input ("enter brand name")
item = {}
ch= 'y'
while (ch = = 'y'):
print ("1. Add items \n 2. Delete items")
n = int (input ("enter your choice"))
if (n = = 1):
s = stationery ( )
s.getdata ( )
item.append {S}
elif (n = = 2):
del item
else: print ("Invalid Input")
ch = input ("Do you want to continue (Y/N)")

(i) பைத்தானில், ஒரு Tuple-ஐ மற்றொரு Tuple-க்குள் வரையறை செய்வதை பின்னலான Tuples என்கிறோம்.
(ii) பின்னலான Tuples-ல் ஒவ்வொரு Tuple-ல் ஒரு உறுப்பாக கருதப்படுகிறது. for மடக்கு பின்னலான Tuples-ன் அனைத்து உறுப்புகளை அணுகுவதற்கு பயன்படுகிறது.
(iii) எடுத்துக்காட்டு :
Toppers = (("Vinodini", "XII-F", 98.7), ("Soundarya", "XII-H", 97.5), ("Tharani", "XII-F", 95.3), ("Saisri", "XII-G", 93.8))
for i in Toppers:
         print(i)
(iv) வெளியீடு :
('Vinodini', 'XII-F', 98.7)
('Soundarya', 'XΙΙ-Η', 97.5)
('Tharani', 'XII-F', 95.3)
('Saisri', 'XII-G', 93.8)

def lcm(x, y):
if x>y:
    greater = x
else:
    greater = y
while (True):
     if ((greater % x == 0) and (greater % y == 0)):
     lcm = greater
     break
     greater += 1
     return lcm
a = int (input ("Enter first number :"))
b = int (input ("Enter second number :"))
print ("The LCM of", a, "and", b, "is", lcm(a,b)).
வெளியீடு :
Enter the first number: 15
Enter the second number: 20
LCM is : 60

	செயற்கூறு	விளக்கம்	பொது வடிவம்	எடுத்துக்காட்டு
a)	id( )	கொடுக்கப்பட்ட பொருளின் நினைவக முகவரியைத் திருப்பி அனுப்பும். குறிப்பு:x,y நினைவக முகவரி ஒவ்வொரு கணிப்பொறிக்கும் வேறுபடும்.	id( object)	x=15 y='a' print ('address of x is :',id (x)) print ('address of y is :',id (y)) வெளியீடு  address of x is : 1357486752 address of y is: 13480736
b)	chr ( )	கொடுக்கப்பட்ட ASCII மதிப்பிற்கு யுனிக்கோடு எழுத்தை திருப்பி அனுப்பும், இது ord( ) செயற்கூறின் தலைகீழாகும்.	chr (i)	c=65 d=43 print (chr (c)) print(chr(d)) வெளியீடு  A +
c)	round ( )	கொடுக்கப்பட்ட எண்ணின் முழு எண்ணாக மாற்றி திருப்பி அனுப்பும். 1. முதல் செயலுருபு கொடுக்கப்பட்ட எண்ணைக் குறிக்கும்  2. இரண்டாவது செயலுருபு முழு எண்ணிற்கு பிறகு தசம புள்ளிகளின் எண்ணிக்கையைக் குறிக்கும்.	round (number [,ndigits])	x= 17.9 y= 22.2 z= -18.3 print ('x value is rounded to', round (x)) print ('y value is rounded to', round (y)) print ('z value is rounded to', round (z)) வெளியீடு : 1  x value is rounded to 18 y value is rounded to 22 z value is rounded to -18 n1=17.89 print (round (n1,0)) print (round (n1,1)) print (round (n1,2)) வெளியீடு:2 18.0 17.9 17.89
d)	type ( )	கொடுக்கப்பட்ட பொருளின் தரவின் வகையைத் திருப்பி அனுப்பும். குறிப்பு: ஒரு அளபுரு பொருளுடன் இது பயன்படுத்தப்படுகிறது.	type (object)	x= 15.2 y='a' s= True print (type (x)) print (type (y)) print (type (s)) வெளியீடு
e)	pow ( )	கொடுக்கப்பட்ட எண்ணின் a - ன் அடுக்கு b - ன் மதிப்பை அதாவது (a**b) திருப்பி அனுப்பும்.	pow (a,b)	a=5 b=2 c=3.0 print (pow (a,b)) print (pow (a,c)) print (pow (a+b,3)) வெளியீடு: 25 125.0 343

வில்லைகள்:
பைத்தான், நிரலின் இடம்பெறும் வரிகளை அடிப்படை மொழிக்கூற்றுகளாக பிரிக்கிறது. இந்த கூறுகள் வில்லைகள் எனப்படும் பொதுவாக வில்லைகளின் வகையான,
(i) குறிப்பெயர்கள்
(ii) சிறப்புச் சொற்கள்
(iii) செயற்குறிகள்
(iv) வரம்புக்குறிகள்
(v) நிலைஉருக்கள்
வில்லைகளை பிரிப்பதற்கு வெற்று இடைவெளி கண்டிப்பாக இருத்தல் வேண்டும்
(i) குறிப்பெயர்கள்: மாறி, செயற்கூறு, இனக்குழு, தொகுதி அல்லது பொருள்களை அடையாளம் காணப் பயன்படும் பெயர்கள் குறிப்பெயர் என்று அழைக்கப்படுகிறது
சரியான குறிப்பெயர்களின் எடுத்துக்காட்டு:
                          Sum, total_marks, regno, num 1
தவறான குறிப்பெயர்களின் எடுத்துக்காட்டுகள்:
                          12Name, name\(\$\), total - mark, continue
(ii) சிறப்புச் சொற்கள்: நிரலின் அமைப்பை அடையாளம் காண பைத்தான் வரிமொழி மாற்றி சிறப்புச் சொற்களை பயன்படுத்துகிறது. சிறப்பு சொற்கள் மொழிமாற்றியில் குறிப்பிட்ட பொருள் கொண்டுள்ளதால் இவற்றை பிற பயன்பாட்டிற்கு பயன்படுத்தக்கூடாது.
பைத்தான் சிறப்புச் சொற்கள்:

false	class	finally	is	return
None	continue	for	lambda	try
True	def	from	nonlocal	while
and	del	global	not	with
as	elif	if	or	yield
assert	else	import	pass	raise
break	except	in

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

(	)	[	]	{	}
,	:	.	'	=	;

v) நிலைஉருக்கள் : நிலைஉருக்கள் என்பது மாறிகள் அல்லது மாறிலிகளுக்கு வழங்கப்படும் மூல தரவாகும். பைத்தானில் பல்வேறு வகையான நிலைஉருக்கள் உள்ளன.
எண்கள்
சரம்
பூலியன்

உள்ளீடு மற்றும் வெளியீடு செயற்கூறுகள் :
ஒரு நிரல் பயனர் விரும்பிய பணியை நிறைவேற்றுவதற்கு பயனருடன் தொடர்பு கொள்ள வேண்டும். இதற்கு உள்ளீட்டு - வெளியீட்டு செயற்கூறுகள் பயன்படுகிறது. input( ) செயற்கூறு, ஓர் நிரலை இயக்கம் பொழுது தரவுகளை இயக்கும் பொழுது தரவுகளை உள்ளீடு செய்யவும், print( ) என்ற வெளியீடு செயற்கூறு நிரலின் தீர்வுகளை திரையில் காண்பிக்க உதவுகிறது
Print( ) செயற்கூறு
பைத்தானில், print( ) செயற்கூறு நிரலை இயக்கும் பொழுது தரவுகளை வெளியிட பயன்படுகிறது
print( ) செயற்கூறின் தொடரியல் கீழே கொடுக்கப்பட்டுள்ளது.
print ("string to be displayed as output")
print (variable)
print ("String to be displayed as output", variable)
print ("String1", variable, "String 2", variable, "String 3" .....)
எடுத்துக்காட்டு:
> > > print ("Welcome to Python Programming")
Welcome to Python Programming
> > > x = 5
> > > y = 6
> > > z = x + y
> > > print (z)
                 11
> > > print ("The sum = ", z)
         The sum = 11
> > > print ("The sum of ", x, "and", y, "is", z)
         The sum of 5 and 6 is 11
வெளியீடு
Welcome to Python programming
11
The sum = 11
The sum of 5 and 6 is 11
print( ) செயற்கூறு தீர்வுகளை திரையில் காண்பிக்கும் முன் கோவையை மதிப்பீடு செய்யவும். print( ) செயற்கூறினுள் கொடுக்கப்படும் முழு கூற்றினையும் திரையில் காட்டும். காற்புள்ளி(,) கொண்டு print( ) செயற்கூறினுள் ஒன்றுக்கு மேற்பட்ட உருப்புகளை பிரிக்கலாம்.
input ( ) செயற்கூறு
பைத்தானில், input( ) செயற்கூறு நிரலை இயக்கம் பொழுது தரவுகளை உள்ளீடாக பெற்றுக் கொள்ளப் பயன்படுகிறது. input( ) செயற்கூறின் தொடரியல், 
Variable = input ("prompt string")
இந்த தொடரியலில் உள்ள "prompt string" பயனர் கொடுக்கப்பட வேண்டிய உள்ளீடு எதுவென்பதை உணர்த்தும் கூற்று அல்லது செய்தியை கொண்டிருக்கும்
 input( ) கட்டளை அமைப்பில் உள்ள "prompt string" திரையில் தோன்றும், பயனர் இதை படித்து உள்ளீடு சாதனத்திலிருந்து எதிர்பார்க்கப்படும் தரவுகளை கொடுக்கலாம். input( ) செயற்கூறு, விசைப்பலகையின் மூலம் தட்டச்சு செய்தவற்றை மாறியில் சேமித்து வைக்கும் "prompt string" கொடுக்கப்படவில்லையெனில் திரையில் எந்த தகவலும் தோன்றாது. இதனால் பயனர் எவற்றை உள்ளீடு செய்ய வேண்டும் என்பதை தெரிந்து கொள்ள முடியாது
எடுத்துக்காட்டு 1: "prompt string" கொண்டுள்ளன input ( ) செயற்கூறு
> > > city=input ("Enter Your City:")
                          Enter Your City: Madurai
> > > print ("I am from", city)
                          I am from Madurai
எடுத்துக்காட்டு 2: "prompt string" இடம்பெறாத input( )  செயற்கூறு
> > > city=input( )
                            Rajarajan
> > > print (I am from", city)
                            I am from Rajarajan
மேலே உள்ள எடுத்துக்காட்டு 2 ல், input( ) செயற்கூற்றில் "prompt string" இடம்பெறவில்லை. எனவே, எவற்றை உள்ளீடாக தர வேண்டும் என்பது பயனர் புரிந்து கொள்ள இயலாது. நிரலுக்கு தொடர்பில்லாத தரவுகளை உள்ளிட்டால், தவறான வெளியீட்டை வெளியிடும். எனவே பயனர் நிரலை உரிய முறையில் இயக்க, "prompt string" input() செயற்கூறில் பயன்படுத்த வேண்டும்.
input() செயற்கூறு அனைத்து தரவுகளையும் சரங்களாக ஏற்றுக் கொள்ளும். பயனர் எண்களை மதிப்புகளாக உள்ளீடு செய்யும் போது, அவை வெளிப்படையாக எண்வகை தரவுகளாக மாற்றப்பட வேண்டும். int() செயற்கூறு சரவகை தரவை எண்வகை தரவாக வெளிப்படையாக மாற்ற உதவுகிறது.

குமிழி வரிசையாக்க நெறிமுறை (Bubble Sort Algorithm):
(i) குமிழி வரிசையாக்கம் ஒரு எளிமையான வரிசையாக்க நெறிமுறை ஆகும். வரிசைப்படுத்தப்பட்ட பட்டியலின் படிநிலைகளை மீண்டும் மீண்டும் செய்து, ஒவ்வொரு ஜோடி அருகிலுள்ள உருப்படிகளை ஒப்பீடு செய்து, வரிசையாக்கம் செய்யப்படாத வரிசை எனில் அவற்றை இடமாற்றம் செய்யும்
(ii) இடமாற்றம் தேவைப்படும் வரை அவை மீண்டும் மீண்டும் பட்டியலிடப்படும். இது பட்டியல் வரிசையாக்கம் செய்யப்பட்டுள்ளது என்பதைக் குறிக்கும்.
(iii) இந்த ஒப்பீடு வரிசையாக்கம் நெறிமுறையில் பட்டியலின் மேல் பகுதியில் குமிழியைப் போல் சிறிய உறுப்புகளை அமைக்கும் முறையினால் இதற்கு இந்த பெயரிடப்பட்டது.
(iv) இந்த நெறிமுறை எளிமையானதாக இருந்த போதிலும், இது மிகவும் பொதுவானது மற்றும் செருகும் வரிசையாக்கத்தோடு (insertion sort) ஒப்பீடு செய்யும் போது இது சாத்தியமற்றதாகும்
(v) n உறுப்புகளை கொண்ட அணியை கருத்தில் கொள்ளவும் Options இடமாற்ற செயல்முறை (swap function) மதிப்புகளை இடமாற்றம் செய்யும்
வழிமுறை:
(i) முதல் உறுப்புடன் (சுட்டெண் = 0), அணியின் தற்போதைய உறுப்போடு அடுத்த உறுப்பை ஒப்பீடு செய்யவும்
(ii) தற்போதைய உறுப்பு அடுத்த உறுப்பை விட அதிகம் எனில், அவற்றை இடமாற்றம் செய்யவும்
(iii) தற்போதைய உறுப்பு அடுத்த உறுப்பை விட சிறியது எனில், அடுத்த உறுப்பிற்கு செல்லவும் மீண்டும் படிநிலை - 1லிருந்து தொடங்கவும். {15, 11, 16, 12, 14, 13} மதிப்புகளோடு கூடிய அணியை எடுத்துக் கொள்வோம்
(iv) கீழே குமிழி வரிசையாக்கம் கொடுக்கப்பட்ட அணியை எவ்வாறு வரிசையாக்கம் செய்கிறது என்பதற்கான விளக்கப்படம் கீழே கொடுக்கப்பட்டுள்ளது

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

11

12

13

14

15

16

வரிசைமுறைத் தேடல்: வரிசைமுறைத் தேடல் அல்லது தொடர் தேடல் பட்டியலில் விரும்பும் உறுப்பைக் கண்டுபிடிக்கும் வரை அல்லது பட்டியல் முடியும் வரை வரிசையிலுள்ள ஒவ்வொரு உறுப்புகளையும் சரிபார்த்து, குறிப்பிட்ட மதிப்பைப் பட்டியலில் கண்டுபிடிக்கும் வழிமுறையாகும். பட்டியலை வரிசைப்படுத்த வேண்டிய தேவை இல்லை
வழிமுறை:
(i) for மடக்கினைப் பயன்படுத்தி அணியில் பயணித்தல்.
(ii) ஒவ்வொரு சுழற்சியிலும், இலக்கு மதிப்பை தற்போதைய மதிப்புடன் ஒப்பிடவும்
1. மதிப்புகள் பொருத்தமாக இருந்தால் அணியின் தற்போதைய சுட்டெண்ணைத் திருப்பி அனுப்பும்
2. மதிப்புகள் பொருந்திவிட்டால் அணியில் அடுத்துள்ள உறுப்புக்கு சென்று விடும்
(iii) பொருத்தம் எதுவும் இல்லையென்றால், -1 மதிப்பைத் திருப்பி அனுப்பும்.
கீழே கொடுக்கப்பட்டுள்ள அணியில் 25 என்ற எண்ணைத் தேடுவதற்கு, வரிசைமுறைத் தேடலானது படிப்படியாக தொடர் வரிசையில் கொடுக்கப்பட்ட அணியின் முதல் உறுப்பிலிருந்து தேடலைத் தொடங்கும். தேடப்படும் உறுப்பு கண்டுபிடிக்கப்பட்டால் அந்த சுட்டெண் திரும்ப அனுப்பப்படும். இல்லையெனில், அணியின் இறுதி சுட்டெண் வரை தேடல் தொடரும். இந்த எடுத்துக்காட்டில், எண் 25 சுட்டெண் 3-ல் காணப்படுகிறது.

அணியின் சுட்டு	0	1	2	3	4
மதிப்புகள்	10	12	20	25	30

எடுத்துக்காட்டு 1:
Input: values[ ] = {5, 34, 65, 12, 77, 35}
target = 77
Output: 4
எடுத்துக்காட்டு 2:
Input: values[ ] = {101, 392, 1, 54, 32, 22, 90, 93}
target = 200
Output: -1 (not found) 

பின்வரும் பண்புகளை நெறிமுறைகள் கொண்டிருக்க வேண்டும்.

1.	உள்ளீடு	பூஜ்ஜியம் அல்லது அதிக எண்ணிக்கையில் வழங்கப்பட வேண்டும்
2.	வெளியீடு	குறைந்தபட்சம் ஒன்றாவது உருவாக்கப்பட வேண்டும்
3.	எல்லையற்றது	வரையறுக்கப்பட்ட எண்ணிக்கையிலான படிநிலைகளில் நெறிமுறை நிறுத்தப்பட வேண்டும்
4.	வரையறுத்தல்	அனைத்து செயல்பாடுகளும் நன்றாக வரையறுக்கப்பட வேண்டும். எடுத்துக்காட்டாக, பூஜ்ஜியம் மூலம் வகுத்தல் அல்லது எதிர்ம எண்ணுக்கு வர்க்க மூலத்தை கணக்கிடுதல் ஆகிய செயல்பாடுகள் ஏற்றுக் கொள்ள முடியாதது ஆகும்
5.	செயல்தன்மை	ஒவ்வொரு கட்டளைகளும் திறம்பட நடத்தப்பட வேண்டும்
6.	உண்மைத் தன்மை	நெறிமுறைகள் பிழை இல்லாததாக இருக்க வேண்டும்
7.	எளிமை	செயல்படுத்துவதற்கு மிக எளிதாக இருக்க வேண்டும்
8.	குழப்பமற்றது	நெறிமுறையானது தெளிவாகவும் குழப்பமற்றதாகவும் இருத்தல் வேண்டும். அதன் ஒவ்வொரு படிநிலைகளும் மற்றும் அதனுடைய உள்ளீடுகள் / வெளியீடுகள் தெளிவானதாக இருக்க வேண்டும் மற்றும் ஒரே ஒரு பொருளுக்கு வழிவகுக்க வேண்டும்
9.	செயலாக்கம்	கிடைக்கும் வளங்களை வைத்து செயலாக்க வல்லது.
10.	அடக்கமானது	நெறிமுறை பொதுவானதாக இருக்க வேண்டும். அனைத்து வகையான உள்ளீடுகளையும் கையாள்வதற்கு எந்த நிரலாக்க மொழியையும் மற்றும் இயக்க அமைப்பையும் சாராமல் இருக்க வேண்டும்
11.	சார்பற்றது	நெறிமுறையானது படிநிலை வழிமுறைகளைக் கொண்டிருக்க வேண்டும். அது எந்த நிரலாக்க குறிமுறையை சாராமல் இருக்க வேண்டும்

LEGB விதிமுறை
வரையெல்லை என்பது சரியான மதிப்பை பெறுவதற்காக மாறிகள் எந்த வரிசையில் பொருளுடன் Map செய்யப்பட வேண்டும் என்பதை வரையறுக்கிறது. கீழே கொடுக்கப்பட்ட எளிய எடுத்துக்காட்டைக் காண்போம்.
1. x:= 'outer x variable'
2. display():
3. x:= 'inner x variable'
4. print x
5. print x
6. display()
மேலே உள்ள கூற்றுகளை இயக்கும்போது. கூற்று (4) மற்றும் (5) பின்வரும் விடையைக் காண்பிக்கிறது.
வெளியீடு
outer x variable
inner x variable
மேலே உள்ள கூற்றுகள் வெவ்வேறு வெளியீடுகளைத் தருகிறது. ஏனெனில், மாறி x என்பது வெவ்வேறு வரையெல்லைகளில் உள்ளது. ஒன்று display ( ) என்ற செயற்கூறுக்கு உள்ளேயும், மற்றொன்று அதன் மேல் கூற்றிலும் உள்ளது. 'Outer x variable' என்ற மதிப்பு, x என்பது செயற்கூறின் வரையறைக்கு வெளியில் அணுகப்படும்போது வெளியிடப்படுகிறது. ஆனால் display ( ) செயற்கூறு இயக்கப்படும்போது, "inner x Variable" என்ற மதிப்பு அச்சிடப்படுகிறது. இது செயற்கூறு வரையறைக்குள் உள்ள x-ன் மதிப்பாகும். மேலே கொடுக்கப்பட்டுள்ள எடுத்துக்காட்டில், ஒரு மாறி எந்த வரையெல்லையில் எடுத்துக்கொள்ளப்பட வேண்டும் என்பதை தீர்மானிக்க ஒரு விதிமுறை பின்பற்றப்படுவதை கணித்துக் கொள்ள முடிகிறது. LEGB விதி வரையெல்லை தேடப்பட வேண்டிய (Scope resolution) வரிசையை தீர்மானிக்கப் பயன்படுகிறது. வரையெல்லைகள் பின்வருமாறு படிநிலை முறையில் பட்டியலிடப்பட்டுள்ளன. (பெரியதிலிருந்து சிறியது), 

உள்ளமை Local (L)	செயற்கூறு / இனக்குழுவிற்கு உள்ளே வரையறுக்கப்பட்டவை
இணைக்கப்பட்ட Enclosed (E)	பின்னலான செயற்கூறுகளுக்குள் வரையறுக்கப்பட்டவை
முழுதளாவிய Global (G)	மேல்நிலையில் வரையறுக்கப்பட்டவை
உள்ளிணைந்த Built-in (B)	உள்ளிணைந்த செயற்கூறுகளில் (கூறுகள்) உள்ள முன்னரே வரையறுக்கப்பட்ட பெயர்களாகும்.

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

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

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

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

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

List:
(i) List என்பது கோவைகளை சதுர அடைப்புக்குறிக்குள் காற்புள்ளியால்  பிரிக்கப்பட்டிருக்கும் அமைப்பு ஆகும். இவ்வகை கோவைகளை List literal என்று அழைக்கப்படுகிறது. List பல மதிப்புகளை சேமிக்கும் இம்மதிப்புகள் எவ்வகையாகவும் இருக்கலாம் அல்லது மற்றொரு லிஸ்டாகவும் இருக்கலாம்.
எடுத்துக்காட்டு : List[10, 20].
(ii) list-ன் உறுப்புகளை இரு வழியில் அணுகலாம். முதல் வழி, அதிகம் பயன்படுத்தப்படும் பன்மடங்கு மதிப்பிருத்தல். இம்முறையில், list-ன் உறுப்புகள் பிரிக்கப்பட்டு, அனைத்து உறுப்புகளும் வேறு பெயர்களுடன் இணைக்கப்படுகிறது.
lst := [10, 20]
x, y := lst
மேலே காணும் எடுத்துக்காட்டில், Xயின் மதிப்பு 10 என்றும், Y யின் மதிப்பு 20 என மதிப்பிருத்தப்படும்.
(iii) இரண்டாம் முறையில் லிஸ்டின் உறுப்புகள், உறுப்புகள் தேர்வு செயற்குறிகள் மூலம் அணுகப்படுகிறது. லிஸ்ட் லிட்டரல்ஸ் போல் அல்லாது கோவையில் ஒரு சதுர அடைப்புக்குறியை தொடர்ந்து வரும் மற்றொரு சதுர அடைப்புக்குறி லிஸ்டின் மதிப்புகளாக எடுத்துக்கொள்ளப்படுவதில்லை. ஆனால் முந்தைய கோவையின் உறுப்பை மதிப்பாக தேர்வு செய்யும்.
1st[0]
10
1st[1]
20
மேலே காணும் எடுத்துக்காட்டினை கணித முறையில் set போன்று அமைக்கலாம்.

(iv) இரு மதிப்புகளை ஒன்றாக இணைக்கும் முறையை இணைகள் (Pairs) என்று அழைக்கிறோம். List அதிகமாக பயன்படுத்தப்படும் முறையாகும். எனவே, List, Pairs என்று அழைக்கப்படுகிறது.

(அ) gcd 
(ஆ) let rec gcd a b : =
(இ) a,b
(ஈ) gcd b (a mod b)
(உ) if b < > 0 ல் உள்ள else return a