പൈത്തൺ ഫംഗ്‌ഷൻ നിർവചനങ്ങളിൽ *ആർഗുകളും **ക്വാർഗുകളും മനസ്സിലാക്കുന്നു

പൈത്തണിൻ്റെ പ്രവർത്തന പാരാമീറ്ററുകൾ പര്യവേക്ഷണം ചെയ്യുന്നു

പൈത്തണിൽ, *ആർഗ്‌സ്, **ക്വാർഗുകൾ എന്നിവയുടെ ഉപയോഗം മനസ്സിലാക്കുന്നത് വഴക്കമുള്ളതും ചലനാത്മകവുമായ പ്രവർത്തനങ്ങൾ എഴുതുന്നതിന് നിർണായകമാണ്. ഈ പ്രത്യേക വാക്യഘടന ഘടകങ്ങൾ ഒരു ഫംഗ്‌ഷനിലേക്ക് ഒരു വേരിയബിൾ ആർഗ്യുമെൻ്റുകൾ കൈമാറാൻ ഡവലപ്പർമാരെ അനുവദിക്കുന്നു, ഇത് കോഡ് കൂടുതൽ പുനരുപയോഗിക്കാവുന്നതും കാര്യക്ഷമവുമാക്കുന്നു.

ഈ ലേഖനത്തിൽ, ഫംഗ്‌ഷൻ പാരാമീറ്ററുകളിൽ ഉപയോഗിക്കുമ്പോൾ * (സിംഗിൾ സ്റ്റാർ), ** (ഇരട്ട നക്ഷത്രം) ചിഹ്നങ്ങൾ എന്താണ് അർത്ഥമാക്കുന്നതെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. നിങ്ങളുടെ കോഡിലെ വിവിധ സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യാൻ *args, **kwargs എന്നിവ എങ്ങനെ ഉപയോഗിക്കാമെന്നതിൻ്റെ പ്രായോഗിക ഉദാഹരണങ്ങളും ഞങ്ങൾ പരിശോധിക്കും.

പൈത്തണിലെ *ആർഗുകളിലേക്കും **ക്വാർഗുകളിലേക്കും ആഴത്തിൽ മുങ്ങുക

നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് കാണിക്കുന്നു *args ഒപ്പം **kwargs പൈത്തൺ ഫംഗ്‌ഷൻ നിർവചനങ്ങളിൽ. ആദ്യത്തെ സ്ക്രിപ്റ്റ് ഒരു ഫംഗ്ഷനെ നിർവചിക്കുന്നു foo അത് ആവശ്യമായ രണ്ട് വാദങ്ങൾ എടുക്കുന്നു, x ഒപ്പം y, പ്രതിനിധീകരിക്കുന്ന ഏതെങ്കിലും അധിക പൊസിഷണൽ ആർഗ്യുമെൻ്റുകൾ പിന്തുടരുന്നു *args. വിളിക്കുമ്പോൾ foo അധിക ആർഗ്യുമെൻ്റുകൾക്കൊപ്പം, ഇവ ഒരു ട്യൂപ്പിൾ ആയി ക്യാപ്‌ചർ ചെയ്യുകയും പ്രിൻ്റ് ചെയ്യുകയും ചെയ്യുന്നു. വ്യത്യസ്ത സംഖ്യകളുടെ ആർഗ്യുമെൻ്റുകൾ ഭംഗിയായി കൈകാര്യം ചെയ്യാൻ ഇത് ഫംഗ്ഷനെ അനുവദിക്കുന്നു. രണ്ടാമത്തെ പ്രവർത്തനം, bar, ആവശ്യമായ രണ്ട് ആർഗ്യുമെൻ്റുകളും കീവേഡ് ആർഗ്യുമെൻ്റുകളും സ്വീകരിക്കുന്നു **kwargs. ഈ കീവേഡ് ആർഗ്യുമെൻ്റുകൾ ഒരു നിഘണ്ടുവിൽ ശേഖരിക്കുന്നു, ഇത് ഫ്ലെക്സിബിൾ നാമമുള്ള ഇൻപുട്ടുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് ഫംഗ്ഷനെ പ്രാപ്തമാക്കുന്നു.

രണ്ടാമത്തെ ഉദാഹരണം സ്ക്രിപ്റ്റ് അവതരിപ്പിക്കുന്നു example_function ഒപ്പം greet ഉപയോഗത്തെ കൂടുതൽ ചിത്രീകരിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ *args ഒപ്പം **kwargs. ദി example_function പൊസിഷനൽ, കീവേഡ് ആർഗ്യുമെൻ്റുകൾ പ്രിൻ്റ് ചെയ്യുന്നു, അവയുടെ ശേഖരം യഥാക്രമം ട്യൂപ്പിളുകളിലേക്കും നിഘണ്ടുക്കളിലേക്കും പ്രദർശിപ്പിക്കുന്നു. ദി greet ഫംഗ്ഷൻ ഒരു പ്രായോഗിക ഉപയോഗ കേസ് എടുത്തുകാണിക്കുന്നു **kwargs ഇഷ്ടാനുസൃതമാക്കാവുന്ന ആശംസാ സന്ദേശം പോലെയുള്ള ഓപ്ഷണൽ കീവേഡ് ആർഗ്യുമെൻ്റുകൾ അനുവദിക്കുന്നു. പ്രയോജനപ്പെടുത്തുന്നതിലൂടെ get() ന് kwargs നിഘണ്ടുവിൽ, ഗ്രീറ്റിംഗ് കീവേഡ് നൽകാത്തപ്പോൾ ഫംഗ്‌ഷന് സ്ഥിരസ്ഥിതി മൂല്യം നൽകാൻ കഴിയും, ഇത് യഥാർത്ഥ ലോക സാഹചര്യങ്ങളിൽ ഈ നിർമ്മാണങ്ങൾ ഉപയോഗിക്കുന്നതിൻ്റെ വഴക്കവും ശക്തിയും പ്രകടമാക്കുന്നു.

def foo(x, y, *args):
    print("Required arguments:", x, y)
    print("Additional arguments:", args)

def bar(x, y, **kwargs):
    print("Required arguments:", x, y)
    print("Keyword arguments:", kwargs)

foo(1, 2, 3, 4, 5)
# Output:
# Required arguments: 1 2
# Additional arguments: (3, 4, 5)

bar(1, 2, a=3, b=4, c=5)
# Output:
# Required arguments: 1 2
# Keyword arguments: {'a': 3, 'b': 4, 'c': 5}

def example_function(*args, **kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

example_function(1, 2, 3, a="apple", b="banana")
# Output:
# Positional arguments: (1, 2, 3)
# Keyword arguments: {'a': 'apple', 'b': 'banana'}

def greet(name, *args, **kwargs):
    greeting = kwargs.get('greeting', 'Hello')
    print(f"{greeting}, {name}!")
    if args:
        print("Additional names:", ', '.join(args))

greet("Alice")
# Output: Hello, Alice!

greet("Alice", "Bob", "Charlie", greeting="Hi")
# Output:
# Hi, Alice!
# Additional names: Bob, Charlie

*ആർഗുകളുടെയും **ക്വാർഗുകളുടെയും വിപുലമായ ഉപയോഗം

അടിസ്ഥാന ഉദാഹരണങ്ങൾക്കപ്പുറം, *args ഒപ്പം **kwargs വിപുലമായ പൈത്തൺ പ്രോഗ്രാമിംഗിൽ അവിശ്വസനീയമാംവിധം ശക്തമായ ടൂളുകളാകാം. ഒരു വിപുലമായ ഉപയോഗ കേസ് ഫംഗ്‌ഷൻ ഡെക്കറേറ്ററിലാണ്. ഫംഗ്‌ഷനുകൾ അല്ലെങ്കിൽ രീതികൾ അവയുടെ യഥാർത്ഥ കോഡ് മാറ്റാതെ തന്നെ പരിഷ്‌ക്കരിക്കാനോ മെച്ചപ്പെടുത്താനോ ഉള്ള ഒരു മാർഗമാണ് ഡെക്കറേറ്റർമാർ. ഉപയോഗിച്ച് *args ഒപ്പം **kwargs, ഡെക്കറേറ്ററുകൾക്ക് എത്രമാത്രം ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ കഴിയും, അവ വളരെ അയവുള്ളതും പുനരുപയോഗിക്കാവുന്നതുമാക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു ലോഗിംഗ് ഡെക്കറേറ്റർ ഏതെങ്കിലും ഫംഗ്‌ഷൻ സ്വീകരിക്കുകയും അതിൻ്റെ ആർഗ്യുമെൻ്റുകളും റിട്ടേൺ മൂല്യവും ലോഗ് ചെയ്യുകയും തുടർന്ന് ആ ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ച് യഥാർത്ഥ ഫംഗ്‌ഷനിലേക്ക് കൈമാറുകയും ചെയ്‌തേക്കാം. *args ഒപ്പം **kwargs. മാറ്റങ്ങളൊന്നും കൂടാതെ തന്നെ വ്യത്യസ്തമായ ഒപ്പുകളുടെ ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് ഡെക്കറേറ്ററിനെ ഉപയോഗിക്കാൻ ഇത് അനുവദിക്കുന്നു.

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

*ആർഗുകളും **ക്വാർഗുകളും ഉപയോഗിച്ച് പൊതിയുന്നു

മനസ്സിലാക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നു *args ഒപ്പം **kwargs പൈത്തൺ ഫംഗ്‌ഷനുകളിൽ നിങ്ങളുടെ പ്രോഗ്രാമിംഗ് കഴിവുകൾ ഗണ്യമായി മെച്ചപ്പെടുത്താൻ കഴിയും. കൂടുതൽ ചലനാത്മകവും പുനരുപയോഗിക്കാവുന്നതുമായ കോഡ് എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഫംഗ്‌ഷൻ നിർവചനങ്ങളിൽ ഈ ഉപകരണങ്ങൾ ഉയർന്ന അളവിലുള്ള വഴക്കം വാഗ്ദാനം ചെയ്യുന്നു. ഈ ആശയങ്ങളിൽ പ്രാവീണ്യം നേടുന്നതിലൂടെ, നിങ്ങളുടെ ഫംഗ്‌ഷനുകളിൽ നിങ്ങൾക്ക് വിപുലമായ ആർഗ്യുമെൻ്റുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയും, ഇത് നിങ്ങളുടെ കോഡ് കൂടുതൽ അനുയോജ്യമാക്കുകയും പരിപാലിക്കാൻ എളുപ്പമാക്കുകയും ചെയ്യുന്നു.

നിങ്ങൾ ഡെക്കറേറ്ററുകൾ എഴുതുകയാണെങ്കിലും, ക്ലാസുകളിൽ പാരമ്പര്യം കൈകാര്യം ചെയ്യുകയാണെങ്കിലും അല്ലെങ്കിൽ അജ്ഞാതമായ നിരവധി വാദങ്ങൾ പാസാക്കാൻ ആഗ്രഹിക്കുകയാണെങ്കിലും, *args ഒപ്പം **kwargs ആവശ്യമായ പ്രവർത്തനം നൽകുക. കൂടുതൽ കാര്യക്ഷമവും ശക്തവുമായ പൈത്തൺ പ്രോഗ്രാമിംഗിനായി ഈ ഫീച്ചറുകളുടെ മുഴുവൻ സാധ്യതകളും കണ്ടെത്തുന്നതിനും നിങ്ങളുടെ കോഡിംഗ് സമ്പ്രദായങ്ങളിലേക്ക് അവയെ സംയോജിപ്പിക്കുന്നതിനും ഈ ഫീച്ചറുകൾ പരീക്ഷിക്കുന്നത് തുടരുക.