Python ஃபங்சன்கள்

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

இது டேட்டாவை manipulate செய்து வெளியீடு செய்கின்றது.

இதன் மூலம் கோடிங்க் ஆனது reusability ஆகின்றது.

ஃபங்க்சனின் இரு வகைகள்”

ஃபங்க்சனில் இரு வகைகள் உண்டு . முதலாவது Built-in functions.இது சாஃப்ட் வேரை இன்ஸ்டால் செய்யும் பொழுது லைப்ரரி ஃபங்க்சன்களாக கிடைக்கின்றன.

இரண்டாவது ஒரு நிரலில் நிரலாளரால் எழுதப்படும் கோடிங் ஆகும்.

ஃபங்க்சனை வரையறு செய்தல்:

ஒரு ஃபங்கசன் ஆனது பைத்தானில் def என்கின்ற கீவேர்டு அதை அறிவிக்க(declare) செய்ய பயன்படுகின்றது.

Def கீவேர்டுக்கு அடுத்து ஃபங்க்சனில் பெயர் வருகின்றது. அதை அடித்து அடைப்புக் குறிக்குள்  பராமீட்டர் சேர்க்கப் படுகின்றது. முடிவில் கோலன் வைக்கப்படுகின்றது

Python Function Syntax

1. def <function_name>(parameters):  
2. </function_name>  

உதாரணம்:

1. def sum(a,b):  

ஃபங்க்சனின் பாடி ஆனது குறிப்பிட்ட இண்டண்டேசன் விட்டு எழுதப்படுகின்றது.

ஃபங்க்சனின் முதல் வரியாக ஒரு ஆப்சனல் ஸ்டேட்மெண்ட் உண்டு. இது ஃபங்கசன் பற்றிய டாக்குமென்டேசனுக்கு பயன்படுகின்றது.

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

Syntax:

பைத்தான் ஃபங்க்சனை அழைத்தல்

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

Python Function Syntax

1. <function_name>(parameters)  
2. </function_name>  

Python Function Example

1. sum(a,b)   

சான்று நிரல்:

1. #Providing Function Definition  
2. def sum(x,y):  
3.      "Going to add x and y"  
4.       s=x+y  
5.      print "Sum of two numbers is"  
6.        print s  
7.        #Calling the sum Function  
8.       sum(10,20)  
9.       sum(20,30)   

வெளியீடு:

1. >>>   
2. Sum of two numbers is  
3. 30  
4. Sum of two numbers is  
5. 50  
6. >>> 
7. குறிப்பு:

ஒரு ஃபங்க்சன் என்ன ஆர்டரில் அழைக்கப்படுகின்றதோ அதே ஆர்டரில் இயக்கப்படுகின்றது.

பைத்தான் ஃபங்க்சன் ரிடர்ன் ஸ்டேட்மெண்ட்

 Return  ஸ்டேட்மென்ட் ஆனது அந்த ஃபன்சனால் வெள்யீடு செய்யப்பட்டு அந்த ஃபங்க்சனை அழைக்கும் வரியின் இடது புறம் உள்ள வேரியபிளுக்கு மதிப்பிருத்தப்படுகின்றது.

மற்ற படி பார்த்தால் ஃபங்க்சனின் முடிவாக return ஸ்டேட்மெண்ட் எடுத்துக் கொள்ளப்படுகின்றது.

சான்று நிரல்

1. def sum(a,b):  
2.             "Adding the two values"  
3.          print "Printing within Function"  
4.  print a+b  
5.             return a+b  
6. def msg():  
7.             print "Hello"  
8.             return  
9.   
10. total=sum(10,20)  
11. print “Printing Outside: “,total  
12. msg()  
13. print "Rest of code"  

வெளியீடு:

1. >>>   
2. Printing within Function  
3. 30  
4. Printing outside:  30  
5. Hello  
6. Rest of code  
7. >>>  

Python Function Argument and Parameter

பைத்தான் ஆர்க்கியூமென்ட் மற்றும் பராமீட்டரின் வித்தியாசம்.:

.ஃபங்க்சன் அழைக்கப்படும் பொழுது அதில் pass செய்யப்படும் டேட்டா “arguments” எனப்படுகின்றது.

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

ஆர்க்கியூமெண்ட் ஆனது லிட்டரலாகவும் இருக்கலாம் அல்லது வேரியபிளாகவும் இருக்கலாம்.

பராமீட்டர்கள் மதிப்பை சேமிக்க உதவும் வேரியபிளாக  இருக்க வேண்டும்

சான்று நிரல்:

1. def addition(x,y):  
2.             print x+y  
3. x=15  
4. addition(x ,10)  
5. addition(x,x)  
6. y=20  
7. addition(x,y)  

வெளியீடு:

1. >>>   
2. 25  
3. 30  
4. 35  
5. >>>  

பராமீட்டரை பாஸ் செய்தல்

Apart from matching the parameters, there are other ways of matching the parameters.

பைத்தான் ஆனது மூன்று வகையான ஃபார்மல் ஆர்க்கியூமெண்டை கொண்டுள்ளது.

1) Positional argument (Required argument).

2) Default argument.

3) Keyword argument (Named argument)

Positional/Required Arguments:

ஃபங்க்சன் ஆர்க்கியூமெண்டின்  எண்ணிக்கையும் பராமீட்டரின் எண்ணிக்கையும் ஒரே மாதிரி இருக்க வேண்டும்.இது தான் Positional சான்று நிரல்:

1. #Function definition of sum   
2. def sum(a,b):  
3.             "Function having two parameters"  
4.          c=a+b  
5.               print c  
6.   
7. sum(10,20)  
8. sum(20)  

வெளியீடு:

1. >>>   
2. 30  
3.   
4. Traceback (most recent call last):  
5.     File "C:/Python27/su.py", line 8, in <module>  
6.         sum(20)  
7. TypeError: sum() takes exactly 2 arguments (1 given)  
8. >>>  
9. </module>  

விளக்கம்:

முதல் sum() ஸ்டேட்மென்ட் 10,20 என இரு ஆர்க்கியூமெண்ட்களைக் கொண்டுள்ளது. இது பங்க்சனின் பராமீட்டர் லிஸ்ட் உடன் மேட்ச் ஆகின்றது. எனவே பிழையில்லாமல் வெளியீடு கிடைக்கின்றது,

இரண்டாவது sum() ஸ்டேட்மெண்ட் ஆனது ஒரே ஒரு ஆர்க்கியூமெண்ட்களைக் கொண்டுள்ளது. எனவே பிழை சுட்டப்படுகின்றது.

Python Function டிஃபால்ட் பராமீட்டர்

Default Argument ஆனது ஃபங்க்சன் அழைக்கபடும் பொழுது அது pass செய்யப்படாவிட்டால் பராமீட்டராக அதன் default மதிப்பு எடுத்துக் கொள்ளபடுகின்றது

சான்று நிரல்:

1. #Function Definition  
2. def msg(Id,Name,Age=21):  
3.             "Printing the passed value"  
4.             print Id  
5.          print Name  
6.          print Age  
7.          return  
8. #Function call  
9. msg(Id=100,Name='Ravi',Age=20)  
10. msg(Id=101,Name='Ratan')  

வெளியெடு:

1. >>>   
2. 100  
3. Ravi  
4. 20  
5. 101  
6. Ratan  
7. 21  
8. >>>  

Explanation:

முதல் தடவை ஃபங்சன் அழைக்கப்படும் பொழுது மூன்று ஆர்க்கியூமென்ட்களும் pass செய்யப்படுகின்றது. இரண்டாவது தடவை  அது அழைக்கப்படும் பொழுது age ஆனது pass செய்யபடவில்லை.எனினும் ஃபன்சன் வரைரறை செய்யும் பொழுது அதில் கொடுக்கப்பட்டுள்ள default மதிப்பு எடுத்துக் கொள்ளப்படுகின்றது.

 Python கீவேர்டு ஆர்க்கியூமென்ட்

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

சான்று நிரல்

1. def msg(id,name):  
2.          "Printing passed value"  
3.                print id  
4.                print name  
5.            return  
6. msg(id=100,name='Raj')  
7. msg(name='Rahul',id=101)  

வெளியீடு:

1. >>>   
2. 100  
3. Raj  
4. 101  
5. Rahul  
6. >>>  

Python Anonymous Function

ஆனானிமஸ் ஃபங்க்சன் என்பது பெயரிடப்படாத ஃபங்க்சன் ஆகும்.

இதற்கு lambda என்ற கீவேர்டு  பயன்படுகின்றது.

Lambda ஆனதும் எந்த என்னிக்கையிலான ஆர்க்கியூமெண்ட்களையும் ஏற்றுக்கொள்ளுகின்றது.

இதற்கு def கீவேர்டு பயன்படுவதில்லை.

Python Anonymous Function Syntax

1. lambda arg1,args2,args3,?,argsn :expression  

சான்று நிரல்

1. #Function Definiton  
2. square=lambda x1: x1*x1  
3.   
4. #Calling square as a function  
5. print "Square of number is",square(10)  

வெளியீடு:

1. >>>   
2. Square of number is 100  
3. >>>  

சாதாரண ஃபங்க்சனுக்கும் அனானிமஸ் ஃபங்க்சனுக்கும் உள்ள வேறுபாடு:

சான்று நிரல்:

Example:

Normal function:

1. #Function Definiton  
2. def square(x):  
3.     return x*x  
4.       
5. #Calling square function  
6. print "Square of number is",square(10)  

Anonymous function:

1. #Function Definiton  
2. square=lambda x1: x1*x1  
3.   
4. #Calling square as a function  
5. print "Square of number is",square(10)  

விளக்கம்:

அனானிமஸ் ஃபங்க்சன் def கீவேர்டை பயன் படுத்துவதில்லை.

மாறாக lambda கீவேர்டு பயன்படுகின்றது.

 இது மதிப்ப்டப்பட்ட எக்ஸ்பிரஸனை வெளியீடு செய்கின்றது.

Scope of Variable:

ஒரு வேரியபிள் அறிவிக்கப்படும் இடத்தை பொருத்து அது இரண்டு வகைப்படுகின்றது

1) Local Variable.

2) Global Variable.

1) Python Local Variables

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

சான்று நிரல்

1. def msg():  
2.            a=10  
3.            print "Value of a is",a  
4.            return  
5.   
6. msg()  
7. print a #it will show error since variable is local  

வெளியீடு:

1. >>>   
2. Value of a is 10  
3.   
4. Traceback (most recent call last):  
5.     File "C:/Python27/lam.py", line 7, in <module>  
6.      print a #it will show error since variable is local  
7. NameError: name 'a' is not defined  
8. >>>  
9. </module>  

b) Python Global Variable

ஃபங்க்சனுக்கு வெளியே அறிவிக்கப்படும் வேரியபிள்கள் global variable எனப்படுகின்றது. இதை நிரலின் எந்த பகுதியிலும் ஆக்சஸ் செய்யலாம்.

சான்று நிரல்

1. b=20  
2. def msg():  
3.            a=10  
4.            print "Value of a is",a  
5.            print "Value of b is",b  
6.            return  
7.   
8.            msg()  
9.            print b  

வெளியீடு:

1. >>>   
2. Value of a is 10  
3. Value of b is 20  
4. 20  
5. >>>  

-முத்து கார்த்திகேயன் மதுரை.