16: *args, **kwargs, റിക്കർഷൻ

കഴിഞ്ഞ അധ്യായത്തിലെ ഫംഗ്ഷനുകൾക്ക് ഒരു നിശ്ചിത എണ്ണം പാരാമീറ്ററുകൾ മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ. ചിലപ്പോൾ, എത്ര ആർഗ്യുമെന്റുകൾ വരും എന്ന് നമുക്ക് നേരത്തേ അറിയില്ല. ഇതിനാണ് *args, **kwargs.

`*args`: ഏത് എണ്ണം ആർഗ്യുമെന്റുകളും

പാരാമീറ്റർ പേരിന് മുന്നിൽ * ഇട്ടാൽ, ആ ഫംഗ്ഷന് ഏത് എണ്ണം ആർഗ്യുമെന്റുകളും സ്വീകരിക്കാം. അവയെല്ലാം ഒരു ട്യൂപ്പിൾ ആയാണ് ഫംഗ്ഷനുള്ളിൽ ലഭിക്കുന്നത്.

def add_all(*args):
	print(type(args))
	return sum(args)

print(add_all(1, 2, 3))
print(add_all(10, 20, 30, 40))

`**kwargs`: ഏത് എണ്ണം കീവേഡ് ആർഗ്യുമെന്റുകളും

പാരാമീറ്റർ പേരിന് മുന്നിൽ ഇട്ടാൽ, ഫംഗ്ഷന് ഏത് എണ്ണം കീവേഡ് ആർഗ്യുമെന്റുകളും സ്വീകരിക്കാം. അവ ഒരു ഡിക്ഷനറി** ആയാണ് ലഭിക്കുന്നത്.

def show_info(**kwargs):
	for key, value in kwargs.items():
		print(key, ":", value)

show_info(name="Anu", age=20, city="Kochi")

സാധാരണ പാരാമീറ്ററുകൾക്കൊപ്പം

സാധാരണ പാരാമീറ്ററുകൾ, *args, kwargs എന്നിവ ഒരുമിച്ച് ഉപയോഗിക്കാം — എപ്പോഴും ഈ ക്രമത്തിൽ** എഴുതണം.

def profile(name, *hobbies, **details):
	print("Name:", name)
	print("Hobbies:", hobbies)
	print("Details:", details)

profile("Anu", "reading", "cycling", city="Kochi", age=20)

റിക്കർഷൻ എന്താണ്?

റിക്കർഷൻ എന്നാൽ, ഒരു ഫംഗ്ഷൻ സ്വയം വിളിക്കുന്നത് ആണ്. ഒരു വലിയ പ്രശ്നത്തെ, അതേ തരത്തിലുള്ള ചെറിയ ഉപ-പ്രശ്നങ്ങളായി പരിഹരിക്കാൻ ഇത് ഉപയോഗിക്കാം.

ക്ലാസിക് ഉദാഹരണം: ഫാക്ടോറിയൽ (5! = 5 × 4 × 3 × 2 × 1).

def factorial(n):
	if n == 1:          # ബേസ് കേസ്
		return 1
	return n * factorial(n - 1)   # റിക്കർസീവ് കേസ്

print(factorial(5))

ഓരോ റിക്കർസീവ് ഫംഗ്ഷനും രണ്ട് ഭാഗങ്ങൾ വേണം:

  • ബേസ് കേസ് — എപ്പോൾ നിർത്തണം എന്ന് പറയുന്ന കണ്ടീഷൻ (ഇവിടെ n == 1)
  • റിക്കർസീവ് കേസ് — ഫംഗ്ഷൻ സ്വയം, ഒരു ചെറിയ ഇൻപുട്ടിനൊപ്പം വീണ്ടും വിളിക്കുന്നത്

ബേസ് കേസ് ഇല്ലെങ്കിൽ എന്ത് സംഭവിക്കും

ബേസ് കേസ് മറന്നാൽ എന്ത് സംഭവിക്കുമെന്ന് നോക്കൂ:

def countdown(n):
	print(n)
	return countdown(n - 1)   # ബേസ് കേസ് ഇല്ല!

countdown(5)

RecursionError: maximum recursion depth exceeded ലഭിക്കും. while ലൂപ്പിലെ അനന്ത ലൂപ്പ് പോലെ തന്നെ, ബേസ് കേസ് ഇല്ലാത്ത റിക്കർഷൻ ഒരിക്കലും നിർത്തില്ല — പൈത്തൺ ഒരു നിശ്ചിത ആഴത്തിന് ശേഷം സ്വയം നിർത്തി ഈ പിശക് കാണിക്കുന്നു.

യഥാർത്ഥ ജീവിത ഉദാഹരണം: ലിസ്റ്റിന്റെ തുക റിക്കർഷൻ ഉപയോഗിച്ച്

def sum_list(numbers):
	if len(numbers) == 0:   # ബേസ് കേസ്
		return 0
	return numbers[0] + sum_list(numbers[1:])

print(sum_list([1, 2, 3, 4, 5]))

ഇതേ ജോലി for ലൂപ്പ് ഉപയോഗിച്ചും ചെയ്യാം, പലപ്പോഴും അതാണ് ലളിതം. റിക്കർഷൻ ഉപയോഗപ്രദമാകുന്നത്, ഒരു പ്രശ്നം സ്വാഭാവികമായി തന്നെ ചെറിയ ഉപ-പ്രശ്നങ്ങളായി പിരിയുന്ന സന്ദർഭങ്ങളിലാണ് (ഉദാ: ഫയൽ ഫോൾഡറുകൾക്കുള്ളിലെ ഫോൾഡറുകൾ പരിശോധിക്കുമ്പോൾ).

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

  • റിക്കർസീവ് ഫംഗ്ഷനിൽ ബേസ് കേസ് ഇടാൻ മറക്കുന്നു (RecursionError)
  • *args, **kwargs എന്നിവ ഫംഗ്ഷൻ പാരാമീറ്ററുകളിൽ തെറ്റായ ക്രമത്തിൽ എഴുതുന്നു
  • *args-നെ ഒരു ലിസ്റ്റ് ആണെന്ന് കരുതുന്നു — യഥാർത്ഥത്തിൽ അത് ഒരു ട്യൂപ്പിൾ ആണ്

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

  • *args ഉപയോഗിച്ച് ഏത് എണ്ണം ആർഗ്യുമെന്റുകളും സ്വീകരിച്ചു
  • **kwargs ഉപയോഗിച്ച് ഏത് എണ്ണം കീവേഡ് ആർഗ്യുമെന്റുകളും സ്വീകരിച്ചു
  • റിക്കർഷൻ എന്താണെന്നും, ബേസ് കേസ് എന്തിനാണെന്നും പഠിച്ചു
  • ബേസ് കേസ് ഇല്ലാതെ വന്നാൽ RecursionError ലഭിക്കും എന്ന് നേരിട്ട് കണ്ടു

വ്യായാമങ്ങൾ

  • *args ഉപയോഗിച്ച്, ഏത് എണ്ണം സംഖ്യകളും സ്വീകരിച്ച് അവയിലെ ഏറ്റവും വലിയ സംഖ്യ return ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക
  • **kwargs ഉപയോഗിച്ച്, ഒരു വ്യക്തിയുടെ വിവരങ്ങൾ (പേര്, പ്രായം, നാട്) ഒരു വരി വീതം പ്രിന്റ് ചെയ്യുന്ന ഫംഗ്ഷൻ എഴുതുക
  • ഒരു സംഖ്യ n വരെയുള്ള എല്ലാ സംഖ്യകളുടെയും തുക കണ്ടെത്തുന്ന ഒരു റിക്കർസീവ് ഫംഗ്ഷൻ എഴുതുക (ബേസ് കേസ്: n == 0)

Quiz & Self Assessment

ചോദ്യം 1 / 4
*args ഒരു ഫംഗ്ഷനുള്ളിൽ ഏത് ഡാറ്റാ തരമായാണ് ലഭിക്കുന്നത്?

അടുത്ത അധ്യായത്തിൽ, ചെറിയ ജോലികൾക്കായി ഒറ്റ വരിയിൽ എഴുതാവുന്ന ലാംഡ ഫംഗ്ഷനുകൾ നിങ്ങൾ പഠിക്കും.