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
*args ഒരു ഫംഗ്ഷനുള്ളിൽ ഏത് ഡാറ്റാ തരമായാണ് ലഭിക്കുന്നത്?അടുത്ത അധ്യായത്തിൽ, ചെറിയ ജോലികൾക്കായി ഒറ്റ വരിയിൽ എഴുതാവുന്ന ലാംഡ ഫംഗ്ഷനുകൾ നിങ്ങൾ പഠിക്കും.