කාර්යයන්
මෙතෙක්, අපි අපගේ සියලුම කේතයන් app.py හි ලියා ඇත, නමුත් අපගේ වැඩසටහන් වර්ධනය වන විට, අපගේ කේතය සංවිධානය කිරීමට අපට වඩා හොඳ ක්රමයක් අවශ්ය වේ. අපගේ කේතය අපි ශ්රිතයන් ලෙස හඳුන්වන කුඩා, වඩා කළමනාකරණය කළ හැකි සහ නඩත්තු කළ හැකි කොටස් වලට බෙදිය යුතුය. කාර්යය යනු නිශ්චිත කාර්යයක් ඉටු කරන කේත පේළි කිහිපයක් සඳහා වන බහාලුමකි.
උදාහරණයක් ලෙස, ඔබ දැනටමත් Python හි ගොඩනඟන ලද කාර්යයන් කිහිපයක් ගැන ඉගෙන ගෙන ඇත print()
සහ input()
. සෑම කාර්යයකටම අරමුණක් ඇති අතර නිශ්චිත කාර්යයක් ඉටු කරන්නේ කෙසේදැයි දනී. ඉතින්, අපි විශාල සංකීර්ණ වැඩසටහන් ගොඩනඟන විට, අපි අපගේ කේතය නැවත භාවිතා කළ හැකි කුඩා කොටස් වලට, එනම් කාර්යයන් වලට බෙදිය යුතුය.
සුබපැතුම් පණිවිඩයක් මුද්රණය කිරීම සඳහා වැඩසටහනක් ගොඩනැගීමෙන් මෙම සංකල්පය අපි තේරුම් ගනිමු.
print('Hi there!')
print('Welcome aboard!')
මෙහිදී අපට ඇත්තේ කේත පේළි දෙකක් පමණක් සහිත සරල වැඩසටහනකි. දැන්, අපි කියමු, අපට ඒවා නැවත භාවිතා කළ හැකි කාර්යයක් තුළ තැබීමට වෙනත් වැඩසටහන් වල ඒවා අවශ්ය වනු ඇත.
මට වෙන් කළ මූල පදයක් හඳුන්වා දීමට ඉඩ දෙන්න def
Python හි, එය නිර්වචනය සඳහා කෙටි වන අතර ශ්රිතයක් අර්ථ දැක්වීම සඳහා භාවිතා වේ.
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'
ස්ථානීය තර්ක ලෙස හැඳින්වේ, එයින් අදහස් කරන්නේ වැඩසටහනේ ඒවායේ පිහිටීම හෝ පිළිවෙල කරුණු ය.
Python වලදී, අපට Keyword arguments ලෙස හැඳින්වෙන තවත් ආකාරයක තර්කයක් ඇත, ඒ සඳහා ස්ථානය වැදගත් නොවේ. ඔවුන් වැඩ කරන ආකාරය මම ඔබට පෙන්වන්නම්.
පසුගිය වැඩසටහන බලන්න. අපට එය මේ ආකාරයට වෙනස් කළ හැකිය:
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
මූල පද පරාමිතීන් වේ. ඔබට ඔවුන්ගේ ස්ථාන මාරු කළ හැකි අතර ප්රතිඵලය සමාන වනු ඇත.
දැන් ඒකෙන් අදහස් වෙන්නේ නැහැ අපි නිතරම Keyword arguments භාවිතා කළ යුතුයි කියලා. බොහෝ විට අපි ස්ථානීය තර්ක භාවිතා කරයි, නමුත් සමහර අවස්ථා වලදී, මෙම මූල පද තර්ක අපගේ කේතයේ කියවීමේ හැකියාව වැඩි දියුණු කිරීමට උපකාරී වේ.
Keyword arguments ගැන ඔබ දැනගත යුතු තවත් දෙයක් තිබේ. මූල පද තර්ක සෑම විටම ස්ථානීය තර්ක වලට පසුව පැමිණිය යුතුය.
ආපසු ප්රකාශය
අපි මෙතෙක් ඉගෙන ගෙන ඇත්තේ ශ්රිතයන් නිර්මාණය කර ඒවායේ පරාමිති භාවිතයෙන් තොරතුරු යවන ආකාරයයි. දැන් අපි ඉගෙන ගනිමු අගයන් ලබා දෙන Functions සාදා ගන්නේ කෙසේද කියා. ඔබ යම් ආකාරයක ගණනය කිරීම් කරන්නේ නම් සහ ඔබේ කාර්යය භාවිතා කරන ඕනෑම කෙනෙකුට ප්රතිඵලය ලබා දීමට ඔබට අවශ්ය නම් මෙය විශේෂයෙන් ප්රයෝජනවත් වේ. මම ඔබට පෙන්වන්නම්.
සංඛ්යාවක වර්ග ගණනය කරන ශ්රිතයක් නිර්වචනය කරමු.
def square(number):
return number*number
අපි මෙම අංකය ශ්රිතයෙන් පිටත ආපසු ලබා දීමට ආපසු ප්රකාශය භාවිතා කර ඇත. දැන්, අපි මෙම ශ්රිතය ලෙස හැඳින්වුවහොත්, එය හරියට අගයක් ලබා දෙයි input()
කාර්යය. අපි එය ටර්මිනලයේ මුද්රණය කරමු.
ප්රතිලාභ ප්රකාශය භාවිතා නොකර එකම ප්රති result ලය ලබා ගත හැකි බවට ඔබට තර්ක කළ හැකිය. අපි එය පරීක්ෂා කර බලමු.
අපට කරුණු දෙකක් පෙනේ, අංක 9 සහ කිසිවක් නැත. මෙතන මොකද වෙන්නේ?
පයිතන් පරිවර්තකය මෙම කේතය ක්රියාත්මක කරන විට, පළමුව එය වර්ග ශ්රිතය ලෙස හඳුන්වන අතර පාලනය ශ්රිතයට ගමන් කරයි. මෙන්න අපි මෙම ලබා දී ඇති අංකයේ වර්ග ගණනය කර එය ටර්මිනලය මත මුද්රණය කරමු.
දැන්, පෙරනිමියෙන්, සියලුම ශ්රිතයන් කිසිවක් නැත අගය ලබා දෙයි. එබැවින් මෙහි ආපසු ප්රකාශයක් නොමැති නම්, පෙරනිමියෙන් Python කිසිවක් ලබා නොදේ. කිසිවක් අගයක් නොමැතිකම නියෝජනය කරන වස්තුවක් නොවේ. එය සී, සී++, ජාවා සහ ජාවාස්ක්රිප්ට් වල කිසිවක් හෝ ශුන්ය නොවේ.
අවසන් කරන්න!
කාර්යයේ වැදගත්කම ඔබ තේරුම් ගෙන ඇතැයි මම සිතමි.
ඔබ ඔබේ කේතීකරණ වෘත්තිය තුළ විශාල හා සංකීර්ණ වැඩසටහන් ලිවීමට සැලසුම් කරන්නේ නම් ඒවා පයිතන් ඉගෙනීමේ වැදගත් අංගයකි.
ඔබමයි