Python args और kwargs - Functions में Arguments Pass करने का Complete Guide

Python में *args और **kwargs दो सबसे powerful और useful features हैं जो आपको flexible functions बनाने में मदद करते हैं। अगर आप Python सीख रहे हैं तो यह concepts बहुत जरूरी हैं, खासकर जब आप real-world projects, libraries या frameworks का code पढ़ते हैं। इस tutorial में हम इन दोनों को step-by-step, ढेर सारे real examples के साथ समझेंगे — बिल्कुल शुरुआत से लेकर advanced use cases तक।

args और kwargs क्या हैं?

args का मतलब है "Arguments" और kwargs का मतलब है "Keyword Arguments"। ये दोनों आपको एक function में variable number of arguments pass करने की सुविधा देते हैं — यानी आपको पहले से fix नहीं करना पड़ता कि function को कितने arguments मिलेंगे। यह खासकर तब काम आता है जब आप ऐसा function बना रहे हों जो अलग-अलग situations में अलग-अलग number of inputs handle करे।

• *args - Non-keyword (positional) arguments को tuple के रूप में pass करता है
• **kwargs - Keyword arguments को dictionary के रूप में pass करता है

Normal function में parameters की संख्या fix होती है — अगर आपने 2 parameters define किए, तो call करते समय exactly 2 arguments ही देने होंगे, वरना Python error देगा। यही limitation *args और **kwargs से दूर हो जाती है।

Normal Function की Limitation पहले समझें

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

print(add_two(5, 10))       # ठीक चलेगा — Output: 15
print(add_two(5, 10, 15))   # Error! TypeError: add_two() takes 2 positional arguments but 3 were given

यहाँ problem clear है — function सिर्फ 2 values के लिए design हुआ है। अगर हमें 2, 5 या 100 numbers जोड़ने हों, तो हमें एक flexible तरीका चाहिए। यहीं से *args काम आता है।

*args को समझते हैं

*args का use तब करते हैं जब आपको पहले से पता नहीं होता कि function को कितने arguments मिलेंगे। Python इन सभी arguments को एक tuple में convert कर देता है, जिसे आप loop करके आसानी से access कर सकते हैं।

*args का Basic Example:

def print_args(*args):
    print("Arguments type:", type(args))
    print("Arguments:", args)
    
    for arg in args:
        print(f"Argument: {arg}")

# Function को call करते हैं
print_args(10, 20, 30, "Python")
print_args("Hello", "World")

Output:

Arguments type: <class 'tuple'>
Arguments: (10, 20, 30, 'Python')
Argument: 10
Argument: 20
Argument: 30
Argument: Python

Arguments type: <class 'tuple'>
Arguments: ('Hello', 'World')
Argument: Hello
Argument: World

*args के साथ Sum का Example:

def add_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

# अलग-अलग arguments के साथ call करते हैं
print(add_numbers(5, 10))              # Output: 15
print(add_numbers(1, 2, 3, 4, 5))      # Output: 15
print(add_numbers(100, 200, 300))      # Output: 600
print(add_numbers())                   # Output: 0 (empty tuple)

यह example बताता है कि *args के अंदर हम एक normal loop चलाकर हर value को आसानी से access कर सकते हैं, चाहे arguments की संख्या कुछ भी हो — यहाँ तक कि zero arguments भी valid है।

*args का एक और Real Example — Maximum Number निकालना:

def find_max(*args):
    if not args:
        return None
    biggest = args[0]
    for num in args[1:]:
        if num > biggest:
            biggest = num
    return biggest

print(find_max(4, 9, 2, 7))      # Output: 9
print(find_max(15, 3, 100, 22))  # Output: 100

**kwargs को समझते हैं

**kwargs keyword arguments को handle करता है। इसका use तब करते हैं जब आप named arguments pass करना चाहते हैं। ये सभी keyword arguments को एक dictionary में convert कर देता है, जिसमें key argument का नाम होता है और value उसकी value।

**kwargs का Basic Example:

def print_kwargs(**kwargs):
    print("Kwargs type:", type(kwargs))
    print("Kwargs:", kwargs)
    
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# Function को call करते हैं
print_kwargs(name="Raj", age=25, city="Delhi")
print_kwargs(subject="Python", level="Beginner", duration="2 months")

Output:

Kwargs type: <class 'dict'>
Kwargs: {'name': 'Raj', 'age': 25, 'city': 'Delhi'}
name: Raj
age: 25
city: Delhi

Kwargs type: <class 'dict'>
Kwargs: {'subject': 'Python', 'level': 'Beginner', 'duration': '2 months'}
subject: Python
level: Beginner
duration: 2 months

**kwargs का Practical Example — Student Profile:

def student_profile(**kwargs):
    for key, value in kwargs.items():
        print(f"{key.capitalize()}: {value}")
    print("-" * 30)

student_profile(name="Ankit", course="Python", city="Lucknow")
student_profile(name="Priya", course="Data Analyst", marks=92)

यहाँ हर बार function को अलग-अलग keys के साथ call किया जा सकता है, बिना function की definition बदले — यही **kwargs की असली ताकत है। अगर आप normal parameters से यही चीज़ करना चाहें, तो हर student के लिए अलग-अलग number of parameters की जरूरत पड़ेगी, जो possible नहीं है।

**kwargs से Default Values Handle करना (get method):

def create_user(**kwargs):
    username = kwargs.get("username", "Guest")
    role = kwargs.get("role", "User")
    print(f"Username: {username}, Role: {role}")

create_user(username="ankit123", role="Admin")
create_user(username="raj99")   # role नहीं दिया, default "User" use होगा
create_user()                   # दोनों default values use होंगी

Output:

Username: ankit123, Role: Admin
Username: raj99, Role: User
Username: Guest, Role: User

*args और **kwargs को एक साथ Use करना

Real projects में अक्सर दोनों को साथ use किया जाता है। Python में rule यह है कि पहले *args आता है, फिर **kwargs।

def create_employee(*args, **kwargs):
    print("Positional Arguments:", args)
    print("Keyword Arguments:", kwargs)

create_employee("Ankit", "Maurya", role="Developer", experience=3)

Output:

Positional Arguments: ('Ankit', 'Maurya')
Keyword Arguments: {'role': 'Developer', 'experience': 3}

Normal Parameters के साथ Order:

अगर आप normal parameters, *args और **kwargs तीनों साथ use कर रहे हैं, तो order fix होता है:

def full_example(a, b, *args, **kwargs):
    print("a:", a)
    print("b:", b)
    print("args:", args)
    print("kwargs:", kwargs)

full_example(1, 2, 3, 4, 5, city="Lucknow", country="India")

Output:

a: 1
b: 2
args: (3, 4, 5)
kwargs: {'city': 'Lucknow', 'country': 'India'}

Order हमेशा यही रहता है: normal parameters → *args → **kwargs। अगर आप order बदलेंगे — जैसे **kwargs को *args से पहले लिखेंगे — तो Python SyntaxError देगा।

Function Call करते समय *args और **kwargs (Unpacking)

*args और **kwargs सिर्फ function define करते समय ही नहीं, बल्कि function call करते समय भी use होते हैं — इसे unpacking कहते हैं। इसका फायदा तब मिलता है जब आपका data पहले से एक list, tuple या dictionary में मौजूद हो।

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

numbers = [10, 20, 30]
print(add(*numbers))     # List को unpack करके pass किया — Output: 60

data = {"a": 1, "b": 2, "c": 3}
print(add(**data))       # Dictionary को unpack करके pass किया — Output: 6

यह pattern खासतौर पर तब बहुत useful होता है जब आपका data पहले से किसी list या string से process होकर आ रहा हो और उसे सीधे function में pass करना हो — बिना हर value manually लिखे।

*args, **kwargs और Class Inheritance (super())

एक बहुत common real-world use case है — जब हम किसी parent class को inherit करते हैं और उसके __init__ method को अलग-अलग तरह के arguments pass करने होते हैं, तो *args, **kwargs बहुत काम आते हैं।

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Employee(Person):
    def __init__(self, *args, salary, **kwargs):
        super().__init__(*args, **kwargs)
        self.salary = salary

emp = Employee("Ankit", 28, salary=45000)
print(emp.name, emp.age, emp.salary)

Output:

Ankit 28 45000

यहाँ Employee class को यह जानने की जरूरत नहीं कि Person class को exactly कितने या कौन-से arguments चाहिए — *args, **kwargs उन्हें automatically आगे pass कर देते हैं।

*args, **kwargs और Decorators

Decorators में भी यह concept बहुत जरूरी है, क्योंकि decorator को नहीं पता होता कि जिस function को वो wrap कर रहा है, उसके parameters क्या हैं।

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Function शुरू हो रहा है...")
        result = func(*args, **kwargs)
        print("Function खत्म हुआ।")
        return result
    return wrapper

@my_decorator
def greet(name, greeting="Namaste"):
    print(f"{greeting}, {name}!")

greet("Ankit")
greet("Priya", greeting="Hello")

Output:

Function शुरू हो रहा है...
Namaste, Ankit!
Function खत्म हुआ।
Function शुरू हो रहा है...
Hello, Priya!
Function खत्म हुआ।

इसी वजह से लगभग हर generic decorator में आपको *args, **kwargs जरूर दिखेगा — यह decorator को किसी भी तरह के function के साथ काम करने लायक बना देता है।

*args और **kwargs — Common Mistakes

• Wrong order: **kwargs को *args से पहले लिखना — यह हमेशा SyntaxError देगा।
• Naming confusion: असल में जरूरी सिर्फ * और ** symbols हैं, नाम कुछ भी हो सकता है (जैसे *values, **info) — पर convention के हिसाब से args / kwargs ही use करें ताकि code बाकियों को भी readable लगे।
• Keyword argument दो बार देना: जैसे create_employee(name="Ankit", name="Raj") — यह TypeError देगा।
• Positional argument keyword के बाद देना: जैसे func(a=1, 2) — यह भी SyntaxError है, keyword arguments हमेशा positional arguments के बाद ही आते हैं।
• *args में index से over-access करना: अगर args में सिर्फ 2 values हैं और आप args[5] access करेंगे, तो IndexError आएगा — इसीलिए loop या length check करना safe रहता है।

*args और **kwargs कब Use करें?

• जब function को कितने arguments मिलेंगे, यह पहले से पता न हो
• Wrapper functions और decorators बनाते समय (हर तरह के arguments आगे pass करने के लिए)
• जब आप एक flexible API या utility function design कर रहे हों
• Class के __init__ method में जब parent class को dynamic arguments pass करने हों
• जब आप किसी existing function के ऊपर एक extra layer बना रहे हों (जैसे logging, caching, validation)

Quick Summary Table

Feature	*args	**kwargs
Data Type	Tuple	Dictionary
Use Case	Positional arguments	Keyword (named) arguments
Symbol	Single star (*)	Double star (**)
Access	Index / loop	Key-value pair (.items())
Order in Function	Normal params के बाद	*args के बाद, सबसे last में
Unpacking Symbol (call time)	* (list/tuple)	** (dictionary)

FAQ - Python args और kwargs से जुड़े सवाल

1. args और kwargs का नाम क्या fix होता है?

नहीं। सिर्फ * और ** symbols जरूरी हैं, नाम आप कुछ भी रख सकते हैं जैसे *values या **data। पर community convention में args और kwargs ही सबसे ज्यादा use होते हैं ताकि code readable रहे।

2. एक ही function में *args और **kwargs दोनों use कर सकते हैं?

हाँ, बिल्कुल। बस order fix रहेगा — पहले normal parameters, फिर *args, और सबसे आखिर में **kwargs।

3. *args को call करते समय list क्यों use करते हैं?

List या tuple को * के साथ unpack करने पर उसके हर element को अलग-अलग positional argument की तरह भेजा जा सकता है, बिना manually हर value लिखे।

4. **kwargs में duplicate keys दे सकते हैं क्या?

नहीं। अगर आप same keyword argument दो बार दोगे तो Python TypeError throw करेगा, क्योंकि dictionary में एक key सिर्फ एक बार valid होती है।

5. *args और **kwargs decorators में क्यों जरूरी हैं?

Decorators को पता नहीं होता कि जिस function को वो wrap कर रहे हैं, उसे कितने और किस तरह के arguments मिलेंगे। इसलिए *args, **kwargs use करके सभी arguments आगे pass कर दिए जाते हैं, चाहे original function का signature कुछ भी हो।

6. क्या *args हमेशा tuple ही return करेगा?

हाँ, function के अंदर *args हमेशा एक tuple की तरह behave करता है, चाहे आप कितने भी या किसी भी data type के arguments pass करें।

7. क्या हम *args या **kwargs के बिना भी कोई function flexible बना सकते हैं?

Technically default parameters से थोड़ी flexibility मिल सकती है, लेकिन truly unlimited/unknown number of arguments को handle करने का सबसे clean और Pythonic तरीका सिर्फ *args और **kwargs ही है।

8. super().__init__(*args, **kwargs) क्यों use करते हैं?

Inheritance में child class को parent class के exact parameters याद रखने की जरूरत नहीं पड़ती। *args, **kwargs सारे received arguments को automatically parent के __init__ तक pass कर देते हैं, जिससे code maintainable रहता है।

Related Tutorials

• Python Recursion क्या है? Recursive Function & Base Case
• Global vs Local Variables in Python
• Python Function में pass क्यों लगाते हैं?
• Python Advanced Tutorials
• Python Interview Questions