Python *args and **kwargs

1. What are *args and **kwargs

*args and **kwargs allow a function to accept a variable number of arguments.

• *args → Variable positional arguments

• **kwargs → Variable keyword arguments (key-value pairs)

def demo(*args, **kwargs):
    print(args)
    print(kwargs)

demo(1, 2, 3, name="Alice", age=30)

Enables highly flexible function signatures.

---

2. Using *args (Variable Positional Arguments)

def add_numbers(*args):
    return sum(args)

print(add_numbers(1, 2, 3, 4))  # 10

All positional arguments are captured as a tuple.

---

3. Iterating Over *args

def display_values(*args):
    for value in args:
        print(value)

display_values("Python", "AI", "ML")

Ideal for functions handling unknown input sizes.

---

4. Using **kwargs (Variable Keyword Arguments)

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

display_profile(name="Alice", role="Engineer", location="Toronto")

All keyword arguments are captured as a dictionary.

---

5. Combining *args and **kwargs

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

process_data(10, 20, user="CSP", status="Active")

Supports highly dynamic functions.

---

6. Order of Parameters

Correct function signature order:

1. Normal parameters

2. *args

3. Default parameters

4. **kwargs

def example(a, b, *args, c=10, **kwargs):
    print(a, b, args, c, kwargs)

example(1, 2, 3, 4, key="value")

Violating this order causes syntax errors.

---

7. Unpacking Arguments with * and **

def greet(name, age):
    print(f"{name} is {age} years old")

data = ("Alice", 30)
greet(*data)

info = {"name": "Bob", "age": 25}
greet(**info)

Used for data-driven function execution.

---

8. Forwarding Arguments to Another Function

def wrapper(*args, **kwargs):
    return calculate(*args, **kwargs)

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

print(wrapper(5, 10))

Common in decorators and middleware.

---

9. Dynamic API Handler Example

def api_handler(endpoint, *args, **kwargs):
    print(f"Calling {endpoint}")
    print("Params:", args)
    print("Options:", kwargs)

api_handler("/users", 1, 2, limit=10, sort="asc")

Used in REST clients and flexible service routers.

---

10. Enterprise-Grade Example

def log_event(event_type, *args, **kwargs):
    print(f"Event: {event_type}")
    if args:
        print("Details:", args)
    if kwargs:
        print("Metadata:", kwargs)

log_event("LOGIN", "UserID:101", ip="192.168.1.1", status="success")

Ideal for dynamic logging, analytics, and telemetry systems.

---

Comparison: *args vs **kwargs

Feature	*args	**kwargs
Type	Tuple	Dictionary
Purpose	Variable positional parameters	Variable named parameters
Invocation	f(1,2,3)	f(a=1,b=2)

---

Common Use Cases

• Decorators and wrappers

• API request builders

• Plugin systems

• Logging frameworks

• Middleware pipelines

• Event handlers

---

Common Mistakes

• Assuming args is a list (it is a tuple)

• Forgetting correct parameter order

• Overusing when fixed parameters suffice

• Naming differently but expecting same semantics

---

Best Practices

• Use descriptive parameter names when possible

• Use *args for extensibility, not ambiguity

• Document expected parameters clearly

• Combine with type hints for clarity

• Validate arguments where applicable

---

Enterprise Value

*args and **kwargs power:

• Extensible APIs

• Dynamic execution engines

• Framework development

• Modular application design

• Reusable utility functions

They are foundational for building flexible, scalable Python systems.

---