പ്രവർത്തനങ്ങൾ
ഇതുവരെ, ഞങ്ങൾ 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, ഒന്നുമില്ല. ഇവിടെ എന്താണ് സംഭവിക്കുന്നത്?
പൈത്തൺ ഇന്റർപ്രെറ്റർ ഈ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, ആദ്യം അത് സ്ക്വയർ ഫംഗ്ഷനെ വിളിക്കുകയും നിയന്ത്രണം ഫംഗ്ഷനിലേക്ക് നീങ്ങുകയും ചെയ്യും. ഇവിടെ നൽകിയിരിക്കുന്ന ഈ സംഖ്യയുടെ വർഗ്ഗം നമ്മൾ കണക്കാക്കി ടെർമിനലിൽ പ്രിന്റ് ചെയ്യുക.
ഇപ്പോൾ, ഡിഫോൾട്ടായി, എല്ലാ ഫംഗ്ഷനുകളും ഒന്നും ഇല്ല എന്ന മൂല്യം നൽകുന്നു. നമുക്ക് ഇവിടെ റിട്ടേൺ സ്റ്റേറ്റ്മെന്റ് ഇല്ലെങ്കിൽ, ഡിഫോൾട്ടായി പൈത്തൺ ഒന്നും നൽകില്ല. ഒന്നും ഒരു മൂല്യത്തിന്റെ അഭാവത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു വസ്തുവല്ല. ഇത് C, C++, Java, Javascript എന്നിവയിൽ ഒന്നുമല്ല അല്ലെങ്കിൽ ശൂന്യവും പോലെയാണ്.
അവസാനിപ്പിക്കുക!
പ്രവർത്തനങ്ങളുടെ പ്രാധാന്യം നിങ്ങൾ മനസ്സിലാക്കിയിട്ടുണ്ടെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.
നിങ്ങളുടെ കോഡിംഗ് കരിയറിൽ വലുതും സങ്കീർണ്ണവുമായ പ്രോഗ്രാമുകൾ എഴുതാൻ നിങ്ങൾ പദ്ധതിയിടുകയാണെങ്കിൽ അവ പൈത്തൺ പഠനത്തിന്റെ ഒരു പ്രധാന വശമാണ്.
നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക