Learn Python Programming

Python Function Arguments

Python offers flexible ways to pass data into functions: positional arguments, keyword arguments, default values, and variable-length argument lists.

Positional and Keyword Arguments

# Positional arguments — order matters
def greet(name, greeting):
    return f"{greeting}, {name}!"

print(greet("Alice", "Hello"))  # Hello, Alice!

# Keyword arguments — order does not matter
print(greet(greeting="Hi", name="Bob"))  # Hi, Bob!

# Mix positional and keyword (positional must come first)
print(greet("Charlie", greeting="Hey"))  # Hey, Charlie!

Default Parameter Values

def create_user(name, role="viewer", active=True):
    return {"name": name, "role": role, "active": active}

# Use defaults
print(create_user("Alice"))
# {"name": "Alice", "role": "viewer", "active": True}

# Override defaults
print(create_user("Bob", role="admin"))
# {"name": "Bob", "role": "admin", "active": True}

# CAUTION: Never use mutable default arguments!
# BAD:
def append_to(item, lst=[]):  # shared across calls!
    lst.append(item)
    return lst

# GOOD: Use None as sentinel
def append_to_safe(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

*args — Variable Positional Arguments

# *args collects extra positional arguments into a tuple
def total(*numbers):
    return sum(numbers)

print(total(1, 2, 3))        # 6
print(total(10, 20, 30, 40)) # 100

# Practical: flexible logging function
def log(message, *tags):
    tag_str = " ".join(f"[{t}]" for t in tags)
    print(f"{tag_str} {message}")

log("Server started", "INFO", "SERVER")
# [INFO] [SERVER] Server started

**kwargs — Variable Keyword Arguments

# **kwargs collects extra keyword arguments into a dictionary
def build_profile(name, **details):
    profile = {"name": name}
    profile.update(details)
    return profile

user = build_profile("Alice", age=30, city="NYC", job="Engineer")
print(user)
# {"name": "Alice", "age": 30, "city": "NYC", "job": "Engineer"}

# Combining all argument types (order matters)
def full_example(required, *args, key="default", **kwargs):
    print(f"required: {required}")
    print(f"args: {args}")
    print(f"key: {key}")
    print(f"kwargs: {kwargs}")

full_example("hello", 1, 2, 3, key="custom", x=10, y=20)

Unpacking Arguments

# Unpack a list/tuple into positional arguments with *
def add(a, b, c):
    return a + b + c

numbers = [1, 2, 3]
print(add(*numbers))  # 6

# Unpack a dict into keyword arguments with **
config = {"host": "localhost", "port": 8080, "debug": True}

def start_server(host, port, debug=False):
    print(f"Starting {host}:{port} (debug={debug})")

start_server(**config)  # Starting localhost:8080 (debug=True)

Keyword-Only and Positional-Only Parameters

# Keyword-only: parameters after * must be passed by name
def fetch(url, *, timeout=30, verify=True):
    print(f"GET {url} (timeout={timeout}, verify={verify})")

fetch("https://api.example.com", timeout=10)  # OK
# fetch("https://api.example.com", 10)  # TypeError!

# Positional-only (Python 3.8+): parameters before / must be positional
def pow(base, exp, /):
    return base ** exp

print(pow(2, 10))  # 1024
# pow(base=2, exp=10)  # TypeError!

• Order of parameters: positional, *args, keyword with defaults, **kwargs.
• Never use mutable objects (lists, dicts) as default values — use None instead.
• Use * to unpack sequences and ** to unpack dicts when calling functions.
• Use keyword-only arguments (after *) for clarity in functions with many options.