15: ഫംഗ്ഷനുകൾ

print(), len(), type() — ഇവയെല്ലാം പൈത്തൺ നേരത്തേ തയ്യാറാക്കി വെച്ചിരിക്കുന്ന ഫംഗ്ഷനുകൾ ആണ്. ഒരു നിശ്ചിത ജോലി ചെയ്യുന്ന, ആവശ്യമുള്ളപ്പോൾ വീണ്ടും വീണ്ടും വിളിക്കാവുന്ന ഒരു കോഡ് ബ്ലോക്കാണ് ഫംഗ്ഷൻ. ഇനി, നമ്മുടെ സ്വന്തം ഫംഗ്ഷനുകൾ എങ്ങനെ ഉണ്ടാക്കാം എന്ന് നോക്കാം.

ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നു

def കീവേഡ് ഉപയോഗിച്ചാണ് ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നത്.

def greet():
	print("Hello, welcome!")

ഈ കോഡ് റൺ ചെയ്താൽ ഒന്നും പ്രിന്റ് ആകില്ല — ഫംഗ്ഷൻ നിർവചിക്കുക എന്നാൽ അതിനുള്ളിലെ കോഡ് ഉടനെ പ്രവർത്തിക്കുക എന്നല്ല, ഭാവിയിൽ ഉപയോഗിക്കാൻ ഒരു പേരിട്ട് സൂക്ഷിച്ചു വെക്കുക എന്നാണ്.

ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നു

ഫംഗ്ഷൻ പ്രവർത്തിക്കണമെങ്കിൽ, അതിന്റെ പേരും () ഉം ഉപയോഗിച്ച് വിളിക്കണം.

def greet():
	print("Hello, welcome!")

greet()
greet()

പാരാമീറ്ററുകളുള്ള ഫംഗ്ഷനുകൾ

ഒരു ഫംഗ്ഷനിലേക്ക് ഡാറ്റ അയക്കാൻ പാരാമീറ്ററുകൾ ഉപയോഗിക്കാം.

def greet(name):
	print(f"Hello, {name}!")

greet("Anu")
greet("Ravi")

ഫംഗ്ഷൻ നിർവചിക്കുമ്പോൾ ബ്രാക്കറ്റിൽ എഴുതുന്ന name എന്നത് പാരാമീറ്റർ ആണ്. ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ കൈമാറുന്ന "Anu", "Ravi" എന്നിവ ആർഗ്യുമെന്റുകൾ ആണ്.

റിട്ടേൺ മൂല്യങ്ങൾ

ഫംഗ്ഷനുകൾക്ക് return ഉപയോഗിച്ച് ഒരു മൂല്യം തിരികെ നൽകാം, പിന്നീട് ആ മൂല്യം പ്രോഗ്രാമിൽ ഉപയോഗിക്കാം.

def add(a, b):
	return a + b

result = add(5, 7)
print(result)

print()-ഉം return-ഉം തമ്മിലുള്ള വ്യത്യാസം ഓർക്കുക: print() ഒരു മൂല്യം സ്ക്രീനിൽ കാണിക്കുന്നു മാത്രം. return ആ മൂല്യം ഫംഗ്ഷനിൽ നിന്ന് പുറത്തേക്ക് കൈമാറുന്നു, അതിനാൽ പിന്നീട് അത് ഒരു വേരിയബിളിൽ സൂക്ഷിക്കാനോ, ഗണിതത്തിന് ഉപയോഗിക്കാനോ കഴിയും.

ഡിഫോൾട്ട് പാരാമീറ്റർ മൂല്യങ്ങൾ

ഒരു ആർഗ്യുമെന്റ് നൽകിയില്ലെങ്കിൽ ഉപയോഗിക്കേണ്ട ഡിഫോൾട്ട് മൂല്യം പാരാമീറ്ററിന് നൽകാം.

def greet(name="Friend"):
	print(f"Hello, {name}!")

greet()
greet("Anu")

കീവേഡ് ആർഗ്യുമെന്റുകൾ

പാരാമീറ്ററിന്റെ പേര് വ്യക്തമാക്കി ആർഗ്യുമെന്റ് കൈമാറാം — ഇത് ക്രമം അറിയാതെ തന്നെ വായിക്കാൻ എളുപ്പമാക്കുന്നു.

def describe_pet(name, animal_type):
	print(f"{name} is a {animal_type}")

describe_pet(animal_type="dog", name="Rex")

ഫംഗ്ഷൻ വേരിയബിളുകൾ എവിടെ വരെ ജീവിക്കും

ഒരു ഫംഗ്ഷനുള്ളിൽ സൃഷ്ടിക്കുന്ന വേരിയബിളിന് ലോക്കൽ സ്കോപ്പ് ആണ് — ഫംഗ്ഷന് പുറത്ത് നിന്ന് അത് ആക്സസ് ചെയ്യാൻ കഴിയില്ല. താഴെയുള്ള കോഡ് റൺ ചെയ്ത് എന്ത് പിശക് വരുന്നു എന്ന് നോക്കൂ:

def add(a, b):
	result = a + b
	return result

add(2, 3)
print(result)

result എന്ന വേരിയബിൾ add()-നുള്ളിൽ മാത്രമേ നിലനിൽക്കൂ — ഫംഗ്ഷൻ അവസാനിച്ചാൽ അത് ഇല്ലാതാകും. അതുകൊണ്ട് ഫംഗ്ഷന് പുറത്ത് print(result) NameError നൽകുന്നു. ഫംഗ്ഷന് ആവശ്യമായ ഡാറ്റ പാരാമീറ്ററായി കൈമാറുകയും, ഫലം return ചെയ്യുകയും ചെയ്യുന്നതാണ് ശരിയായ രീതി.

യഥാർത്ഥ ജീവിത ഉദാഹരണം: ലളിതമായ കാൽക്കുലേറ്റർ ഫംഗ്ഷനുകൾ

def add(a, b):
	return a + b

def subtract(a, b):
	return a - b

print(add(10, 5))
print(subtract(10, 5))

സാധാരണ തുടക്കക്കാരുടെ തെറ്റുകൾ

  • ഫംഗ്ഷൻ നിർവചിക്കുക മാത്രം ചെയ്ത്, വിളിക്കാൻ മറക്കുന്നു
  • return-ന് പകരം print() ഉപയോഗിച്ച്, ഫലം പിന്നീട് ഉപയോഗിക്കാൻ കഴിയാതെ വരുന്നു
  • ഫംഗ്ഷനുള്ളിലെ ലോക്കൽ വേരിയബിൾ, ഫംഗ്ഷന് പുറത്ത് ആക്സസ് ചെയ്യാൻ ശ്രമിക്കുന്നു
  • ഫംഗ്ഷന് ആവശ്യമുള്ളതിലും കുറവോ കൂടുതലോ ആർഗ്യുമെന്റ് കൊടുക്കുന്നു

ഈ അധ്യായത്തിന്റെ സംഗ്രഹം

  • def ഉപയോഗിച്ച് ഫംഗ്ഷൻ നിർവചിച്ചു, വിളിച്ചു
  • പാരാമീറ്ററുകളും ആർഗ്യുമെന്റുകളും ഉപയോഗിച്ചു
  • return ഉപയോഗിച്ച് മൂല്യങ്ങൾ തിരികെ നൽകി
  • ഡിഫോൾട്ട് പാരാമീറ്ററുകളും കീവേഡ് ആർഗ്യുമെന്റുകളും ഉപയോഗിച്ചു
  • ലോക്കൽ സ്കോപ്പ് എന്താണെന്ന് നേരിട്ട് പിശക് വരുത്തി മനസ്സിലാക്കി

വ്യായാമങ്ങൾ

  • ഒരു സംഖ്യ പാരാമീറ്ററായി വാങ്ങി, അതിന്റെ വർഗ്ഗം (square) return ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ എഴുതി വിളിച്ച് പ്രിന്റ് ചെയ്യുക
  • ഒരു പേര് പാരാമീറ്ററായി വാങ്ങി, ഡിഫോൾട്ട് മൂല്യം "Guest" ആയി വെച്ച്, f"Welcome, {name}!" print ചെയ്യുന്ന ഫംഗ്ഷൻ എഴുതുക — ആർഗ്യുമെന്റ് ഇല്ലാതെയും, ഉള്ളതുകൊണ്ടും വിളിച്ചു നോക്കുക
  • രണ്ട് സംഖ്യകൾ പാരാമീറ്ററായി വാങ്ങി, ഏതാണ് വലുതെന്ന് return ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക

Quiz & Self Assessment

ചോദ്യം 1 / 4
ഒരു ഫംഗ്ഷൻ def ഉപയോഗിച്ച് നിർവചിച്ചാൽ മാത്രം (വിളിക്കാതെ) എന്ത് സംഭവിക്കും?

അടുത്ത അധ്യായത്തിൽ, എത്ര ആർഗ്യുമെന്റുകൾ വേണമെങ്കിലും സ്വീകരിക്കാൻ കഴിയുന്ന *args, kwargs എന്നിവയും, ഒരു ഫംഗ്ഷൻ സ്വയം വിളിക്കുന്ന റിക്കർഷനും** നിങ്ങൾ പഠിക്കും.