# python program to find HCF
def HCF (x, y):
if (x >y):
s=y
else:
s=x
for i in range (1, s + 1):
if ((x % i == 0) and (y % i == 0)):
hcf= i
return hcf
x = int (input ("Enter Number 1"))
y= int (input ("Enter Number 2"))
print (HCF (x, y))

தேவைப்படும் செயலுருபுகள்:
1) செயலுருபுகளை சரியான இடவரிசையில் செயற்கூற்றுக்கு அனுப்புவதே தேவைப்படும் செயலுருப்புகள் எனப்படும்.
2) இங்கு, செயற்கூறு அழைப்புக் கூற்றில் உள்ள செயலுருபுகளின் எண்ணிக்கை, செயற்கூறு வரையறையோடு சரியாக பொருந்த வேண்டும்.
3) தொடரியல் பிழையை தவிர்த்து, தேவையான வெளியீட்டை பெறுவதற்கு குறைந்தது ஒரு செயலுருபாவது  தேவை.
எடுத்துக்காட்டு:
def printstring( str):
print ("Example - Required arguments ")
print (str)
return
# Now you can call printstring() function
printstring("Welcome")
வெளியீடு:
Example - Required arguments
Welcome
சிறப்புச் சொல் செயலுருபுகள்:
1) அளபுருக்க்களின் பெயரை அடையாளம் கண்டபின்பு சிறப்புச் சொல் செயலுருபானது செயற்கூறினை அழைக்கிறது.
2) சிறப்புச் சொல் செயலுருபின் மதிப்பு அளபுரு பெயருடன் பொருந்த வேண்டும். எனவே, முறையற்ற வரிசையிலும் செயலுருபுகளைக் கொடுக்கலாம்.
எடுத்துக்காட்டு:
def printdata (name):
print ("Example-1 Keyword arguments")
print ("Name :",name) 
return
# Now you can call printdata() function
printdata(name = "Gshan")
வெளியீடு:
Example-1 Keyword arguments
Name :Gshan.
தானமைவு செயலுருபுகள்:
1) பைத்தானில், செயற்கூறை அழைக்கும் போது எந்த மதிப்பும் கொடுக்கப்படவில்லை எனில், செயலுருபானது தானாகவே மதிப்பை எடுத்துக் கொள்ளும். இதுவே தானமைவு செயலுருபு ஆகும்.
2) பின்வரும் எடுத்துக்காட்டில் செயலுருபுவை அனுப்பாதபோது தானமைவு Salary -யை அச்சிடுவதைக் காணலாம்.
எடுத்துக்காட்டு:
def printinfo( name, salary = 3500):
print ("Name:", name)
print ("Salary:", salary)
return
printinfo("Mani ")
வெளியீடு:
Name: Mani 
Salary: 3500
மாறும் நீள செயலுருபுகள்:
1) சில சமயங்களில், ஏற்கனவே குறிப்பிடப்பட்ட செயலுருபுகளை விட அதிகமான செயலுருபுகளை அனுப்ப வேண்டிய தேவை இருக்கும்.
2) மீண்டும் செயற்கூறினை மறுவரையறை செய்வது கடினமான செயல் அதற்கு பதிலாக மாறும் நீள செயலுருபுகளை பயன்படுத்தலாம்.
3) செயற்கூறு வரையறையில் இது குறிப்பிடப்படுவதில்லை. மாறாக இந்த செயலுருபுகளை குறிப்பிடுவதற்கு * குறியீடு பயன்படுகிறது.
மாறும் நீள செயலுருபின் பொதுவடிவம்:
def function_name(*args):
function_body
return statement
எடுத்துக்காட்டு:
def printnos (*nos):
for n in nos:
print (n)
return
# now invoking the printnos() function
print ('Printing two values')
printnos (1,2)
print ('Printing three values')
printnos (10,20,30)
வெளியீடு:
Printing two values
1
2
Printing three values
10
20
30

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

ஒரு செயற்கூறின் உடற்பகுதியின் உள்ளே அல்லது உள்ளமை வரையெல்லையில் மாறியை அறிவிப்பது உள்ளமை மாறி எனப்படும்.

lambda [argument(s)] : expression

லாம்டா அல்லது பெயரில்லா செயற்கூறின் பயன்கள்:
1) லாம்டா செயற்கூறு பெரும்பாலும் சிறிய மற்றும் ஒரு முறை பெயரில்லாத செயற்கூறை உருவாக்க பயன்படுகிறது.
2) filter ( ), map ( ) மற்றும் reduce ( ) போன்ற செயற்கூறுகளுடன் சேர்த்து லாம்டா செயற்கூறுகளை பயன்படுத்தலாம்.

வெளியீடு:
32

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

1) அளபுருக்களின் பெயரை அடையாளம் கண்ட பின்பு சிறப்புச் சொல் செயலுருபானது செயற்கூறினை அழைக்கிறது.
2) சிறப்புச் சொல் செயலுருபின் மதிப்பு அளபுரு பெயருடன் பொருந்த வேண்டும். எனவே, முறையற்ற வரிசையிலும் செயலுருபுகளைக் கொடுக்கலாம்.
எடுத்துக்காட்டு:
defprintdata (name):
print ("Example-1 Keyword arguments")
print ('Name :",name)
return
# Now you can call printdatat) function
printdata(name = "Gshan")
வெளியீடு:
Example-1 Keyword arguments
Name :Gshan

1. செயலுருபுகளை சரியான இடவரிசையில் செயற்கூற்றுக்கு அனுப்புவதே தேவைப்படும். செயலுருபுக்கள் எனப்படும்.
2. இங்கு, செயற்கூறு அழைப்புக் கூற்றில் உள்ள செயலுருபுகளின் எண்ணிக்கை, செயற்கூறு வரையறையோடு சரியாக பொருந்த வேண்டும்.
3. தொடரியல் பிழையை தவிர்த்து தேவையான வெளியீட்டை பெறுவதற்கு குறைந்தது ஒரு செயலுருபாவது தேவை.
எடுத்துக்காட்டு:
def printstring( str):
print ("Example - Required arguments ")
print (str)
return
# Now you can call printstring( ) function
printstring("Welcome")

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