பணிகள்
இதுவரை, நாங்கள் எங்கள் எல்லா குறியீட்டையும் app.py இல் எழுதி வருகிறோம், ஆனால் எங்கள் திட்டங்கள் வளரும்போது, எங்கள் குறியீட்டை ஒழுங்கமைக்க சிறந்த வழி தேவை. நமது குறியீட்டை செயல்பாடுகள் என்று அழைக்கும் சிறிய, மேலும் நிர்வகிக்கக்கூடிய மற்றும் பராமரிக்கக்கூடிய பகுதிகளாக பிரிக்க வேண்டும். செயல்பாடு என்பது ஒரு குறிப்பிட்ட பணியைச் செய்யும் சில வரிக் குறியீடுகளுக்கான கொள்கலன் ஆகும்.
எடுத்துக்காட்டாக, பைத்தானில் உள்ள சில உள்ளமைக்கப்பட்ட செயல்பாடுகளைப் பற்றி நீங்கள் ஏற்கனவே அறிந்திருக்கிறீர்கள் print()
மற்றும் input()
. ஒவ்வொரு செயல்பாட்டிற்கும் ஒரு நோக்கம் உள்ளது மற்றும் ஒரு குறிப்பிட்ட பணியை எவ்வாறு செய்வது என்பது தெரியும். எனவே, நாம் பெரிய சிக்கலான நிரல்களை உருவாக்கும்போது, நமது குறியீட்டை மீண்டும் பயன்படுத்தக்கூடிய சிறிய துண்டுகளாக, அதாவது செயல்பாடுகளாக உடைக்க வேண்டும்.
வாழ்த்துச் செய்தியை அச்சிடுவதற்கான திட்டத்தை உருவாக்குவதன் மூலம் இந்த கருத்தைப் புரிந்துகொள்வோம்.
print('Hi there!')
print('Welcome aboard!')
இரண்டு கோடுகள் கொண்ட ஒரு எளிய நிரல் இங்கே உள்ளது. இப்போது, நாம் மீண்டும் பயன்படுத்தக்கூடிய ஒரு செயல்பாட்டில் அவற்றை வைக்க மற்ற நிரல்களில் அவை தேவைப்படும் என்று சொல்லலாம்.
ஒதுக்கப்பட்ட முக்கிய சொல்லை அறிமுகப்படுத்துகிறேன் def
பைத்தானில், இது வரையறைக்கு குறுகியது மற்றும் ஒரு செயல்பாட்டை வரையறுக்கப் பயன்படுகிறது.
def greet_user():
print('Hi there!')
print('Welcome aboard!')
இப்போது இந்த குறியீட்டின் தொகுதி ஒரு செயல்பாட்டை வரையறுக்கும் "greet_user
” அதன் பிறகு குறியீடுகளின் வரிகளுடன். இந்த செயல்பாடு அழைக்கப்படும் போதெல்லாம், இந்த இரண்டு வரிகளும் செயல்படுத்தப்படும். இதைப் பயன்படுத்துவோம்:
print('start')
greet_user()
print('finish')
நிரல் தொடர்ச்சியாக செயல்படுத்தப்படுகிறது, அதாவது நிரலில் அழைப்பதற்கு முன் நீங்கள் ஒரு செயல்பாட்டை வரையறுக்க வேண்டும்.
துப்புகள்
பைத்தானின் உள்ளமைக்கப்பட்ட செயல்பாடுகளை விட வரையறுக்கப்பட்ட செயல்பாடுகள் சற்று வித்தியாசமாக வேலை செய்கின்றன. உதாரணமாக, வழக்கில் print()
ஒரு செயல்பாடு, நாங்கள் அச்சிட விரும்பும் சில தகவல்களை இது எடுக்கும், ஆனால் எங்கள் வாழ்த்து செயல்பாடு எந்த தகவலையும் எடுக்காது. "ஹாய் தேர்" என்று சொல்வதற்குப் பதிலாக, பயனரின் பெயரை இங்கே அனுப்பினால் நன்றாக இருக்கும் அல்லவா?
வரையறுக்கப்பட்ட செயல்பாட்டின் அடைப்புக்குறிக்குள் அளவுருக்களைச் சேர்ப்பதன் மூலம் இதைச் செய்யலாம். நான் உங்களுக்குக் காட்டுகிறேன்:
def greet_user(name):
print('Hi there!')
print('Welcome aboard!')
இப்போது "name
” அடைப்புக்குறிக்குள் உள்ள ஒரு லோக்கல் வேரியபிள் போல செயல்படும் மேலும் அதை அழைக்கும் போது பயனரின் பெயரை அனுப்பலாம்.
greet_user('Shahbaz')
இப்போது பெயர் அளவுரு அமைக்கப்பட்டுள்ளது "Shahbaz
”. அதைப் பயன்படுத்த நிரலை மாற்றுவோம்.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
print('finish')
கவனிக்க வேண்டிய முக்கியமான விஷயம் என்னவென்றால், முதல் வரியில் உள்ள “பெயர்” ஒரு அளவுரு என்று அழைக்கப்படுகிறது, அதே சமயம் வழங்கப்பட்ட பெயர் அதாவது ஷாபாஸ் ஒரு வாதம் என்று அழைக்கப்படுகிறது.
இந்த திட்டத்தை இயக்கவும்.
எனவே இந்த அளவுருக்கள் மூலம், எங்கள் செயல்பாடுகளில் தகவலைப் பெறலாம்.
இப்போது, சுவாரஸ்யமான ஒன்றைச் செய்வோம். வாழ்த்துச் செய்தியில் வேறொரு பெயரைச் சேர்க்க விரும்புகிறீர்கள் என்று வைத்துக் கொள்வோம். இது எளிமை.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
greet_user('Aayush')
print('finish')
ஒரு செயல்பாட்டிற்கு ஒரு அளவுரு இருக்கும் போது, அந்த அளவுருவிற்கு மதிப்பை அனுப்ப நாம் கடமைப்பட்டுள்ளோம் என்பதை இப்போது கவனிக்கவும். நீங்கள் செயல்பாட்டிலிருந்து பெயரை நீக்கி, நிரலை இயக்கினால், எங்களுக்கு ஒரு பிழை வரும். கமாவால் பிரிக்கப்பட்ட ஒரு செயல்பாட்டில் பல அளவுருக்களையும் நீங்கள் பயன்படுத்தலாம்.
உதாரணமாக, greet_user(first_name, last_name):
. வாதங்களும் இதேபோல் வடிவமைக்கப்படும்.
முக்கிய வாதங்கள்
இதுவரை, எங்கள் செயல்பாடுகளுக்கான அளவுருக்களை வரையறுக்கும் போதெல்லாம், மதிப்புகளை எப்போதும் வழங்க வேண்டும், இல்லையெனில் பிழையைப் பெறுவோம் என்பதை நாங்கள் கற்றுக்கொண்டோம். கடைசி நிரலில், வாதங்கள் 'Shahbaz'
மற்றும் 'Bhatti'
நிலை வாதங்கள் என்று அழைக்கப்படுகின்றன, அதாவது நிரலில் அவற்றின் நிலை அல்லது ஒழுங்கு விஷயங்கள்.
பைத்தானில், முக்கிய வாதங்கள் என்று அழைக்கப்படும் மற்றொரு வகையான வாதம் உள்ளது, இதற்கு நிலை ஒரு பொருட்டல்ல. அவர்கள் எப்படி வேலை செய்கிறார்கள் என்பதைக் காட்டுகிறேன்.
கடைசி நிரலைப் பாருங்கள். நாம் இதை இப்படி மாற்றலாம்:
def greet_user(first_name, last_name):
print(f'Hi {first_name} {last_name}')
print('Welcome aboard!')
print('start')
greet_user(first_name='Shahbaz', last_name='Bhatti')
print('finish')
இப்போது first_name
மற்றும் last_name
முக்கிய அளவுருக்கள். நீங்கள் அவர்களின் இடங்களை மாற்றலாம் மற்றும் முடிவு ஒரே மாதிரியாக இருக்கும்.
இப்போது நாம் எப்போதும் முக்கிய வாதங்களைப் பயன்படுத்த வேண்டும் என்று அர்த்தமல்ல. பெரும்பாலான நேரங்களில் நாம் நிலை வாதங்களைப் பயன்படுத்துகிறோம், ஆனால் சில சூழ்நிலைகளில், இந்த முக்கிய வாதங்கள் எங்கள் குறியீட்டின் வாசிப்புத் திறனை மேம்படுத்த உதவுகின்றன.
முக்கிய வாதங்களைப் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய மற்றொரு விஷயம் உள்ளது. முக்கிய வாதங்கள் எப்போதும் நிலை வாதங்களுக்குப் பிறகு வர வேண்டும்.
திரும்ப அறிக்கை
செயல்பாடுகளை உருவாக்குவது மற்றும் அவற்றின் அளவுருக்களைப் பயன்படுத்தி தகவல்களை அனுப்புவது எப்படி என்பதை இதுவரை கற்றுக்கொண்டோம். மதிப்புகளை வழங்கும் செயல்பாடுகளை எவ்வாறு உருவாக்குவது என்பதை இப்போது கற்றுக்கொள்வோம். நீங்கள் சில வகையான கணக்கீடுகளைச் செய்து, உங்கள் செயல்பாட்டைப் பயன்படுத்துபவர்களுக்கு முடிவைத் திருப்பித் தர விரும்பினால் இது மிகவும் பயனுள்ளதாக இருக்கும். காட்டுகிறேன்.
ஒரு எண்ணின் வர்க்கத்தைக் கணக்கிடும் ஒரு செயல்பாட்டை வரையறுப்போம்.
def square(number):
return number*number
இந்த எண்ணை செயல்பாட்டிற்கு வெளியே திரும்ப திரும்ப அறிக்கையைப் பயன்படுத்தியுள்ளோம். இப்போது, இந்த செயல்பாட்டை அழைத்தால், அது போன்ற ஒரு மதிப்பை வழங்குகிறது input()
செயல்பாடு. டெர்மினலில் அச்சிடுவோம்.
ரிட்டர்ன் ஸ்டேட்மென்ட்டைப் பயன்படுத்தாமல் அதே முடிவைப் பெறலாம் என்று நீங்கள் வாதிடலாம். சரி பார்க்கலாம்.
நாம் இரண்டு விஷயங்களைக் காண்கிறோம், எண் 9, மற்றும் எதுவும் இல்லை. இங்கே என்ன நடக்கிறது?
பைதான் மொழிபெயர்ப்பாளர் இந்த குறியீட்டை இயக்கும் போது, முதலில் அது சதுர செயல்பாட்டை அழைக்கும் மற்றும் கட்டுப்பாடு செயல்பாட்டிற்கு நகரும். இங்கே கொடுக்கப்பட்ட எண்ணின் சதுரத்தைக் கணக்கிட்டு, அதை முனையத்தில் அச்சிடுகிறோம்.
இப்போது, முன்னிருப்பாக, அனைத்து செயல்பாடுகளும் மதிப்பு எதுவும் இல்லை. எங்களிடம் ரிட்டர்ன் ஸ்டேட்மென்ட் இல்லையென்றால், முன்னிருப்பாக பைதான் எதையும் தராது. மதிப்பு இல்லாததைக் குறிக்கும் பொருள் எதுவுமில்லை. இது சி, சி++, ஜாவா மற்றும் ஜாவாஸ்கிரிப்ட் ஆகியவற்றில் ஒன்றும் அல்லது பூஜ்யமும் இல்லை.
மடக்கு!
செயல்பாடுகளின் முக்கியத்துவத்தை நீங்கள் புரிந்து கொண்டிருப்பீர்கள் என்று நம்புகிறேன்.
உங்கள் குறியீட்டு வாழ்க்கையில் பெரிய மற்றும் சிக்கலான நிரல்களை எழுத திட்டமிட்டால், பைதான் கற்றலின் குறிப்பிடத்தக்க அம்சம் அவை.
ஒரு பதில் விடவும்