Python Functions — Complete Guide

Why Functions Exist — The Core Idea

In Python, a function is a named, reusable block of code that takes zero or more inputs (called arguments), does some work, and optionally gives back a result using return. Functions are the smallest unit of abstraction in Python — every serious program is a tree of them.

The Anatomy of a Function — def, Parameters, return

Every Python function has the same skeleton. Learn this once and you know all of them.

Minimal Example — Greeting a User

def greet(name):
    # Body indented with 4 spaces
    message = f"Hello, {name}!"
    return message

# Calling the function
result = greet("Aarav")
print(result)

Functions Without return — What Actually Happens

def shout(word):
    print(word.upper() + "!")
    # No return statement

result = shout("hello")
print("result is:", result)
print("type is:", type(result))

Positional Arguments — Order Is Everything

When you call a function with values but no names, Python matches them by position — first argument to first parameter, second to second, and so on. Swap the order and you get a bug, not an error.

def divide(numerator, denominator):
    return numerator / denominator

# Positional — order matters
print(divide(10, 2))   # 10 / 2 = 5.0   correct
print(divide(2, 10))   # 2 / 10 = 0.2   silent bug!

Keyword Arguments — Name Them and Sleep Well

You can pass arguments by name instead of position using the parameter=value syntax. Keyword arguments are self-documenting and immune to the order-swap bug above.

def divide(numerator, denominator):
    return numerator / denominator

# Keyword calls — order does not matter
print(divide(numerator=10, denominator=2))   # 5.0
print(divide(denominator=2, numerator=10))   # 5.0 — same!

# Mix positional then keyword (positional MUST come first)
print(divide(10, denominator=2))          # 5.0  OK

# This raises SyntaxError — keyword before positional
# print(divide(numerator=10, 2))

Default Arguments — Sensible Fallbacks

You can give a parameter a default value in the function definition using parameter=default. If the caller doesn't supply it, Python uses the default. This makes functions flexible without forcing callers to specify every option.

def connect(host, port=8080, timeout=30, use_ssl=True):
    print(f"Connecting to {host}:{port}")
    print(f"  timeout={timeout}s, ssl={use_ssl}")

# Only the required argument — rest use defaults
connect("api.example.com")

# Override just the port
connect("api.example.com", 9000)

# Override port and timeout, keep ssl=True
connect("api.example.com", 9000, 60)

Calling Default Arguments Using Keywords — The Skip Trick

Here's where defaults and keyword calls combine into a superpower. What if you want to keep the default for port and timeout, but change only use_ssl? Without keyword arguments, you'd have to re-specify every earlier value. With them, you skip straight to the one you care about.

def connect(host, port=8080, timeout=30, use_ssl=True):
    print(f"{host}:{port} ssl={use_ssl} t={timeout}")

# Keep port & timeout defaults, only change ssl
connect("api.example.com", use_ssl=False)

# Skip port, change timeout only
connect("api.example.com", timeout=60)

# Any combination — order does not matter
connect("api.example.com", use_ssl=False, timeout=60, port=443)

Variable-Length Arguments — *args

Prefixing a parameter with a single asterisk * tells Python: "catch all remaining positional arguments and pack them into a tuple". The name args is convention — you could call it *numbers or anything else. The magic is the *.

def sum_all(*args):
    print("args is:", args)
    print("type is:", type(args))
    total = 0
    for n in args:
        total += n
    return total

print(sum_all(1, 2, 3))
print(sum_all(10, 20, 30, 40, 50))
print(sum_all())          # zero args is fine — empty tuple

Mixing Regular Parameters with *args

def log_event(level, *messages):
    for msg in messages:
        print(f"[{level}] {msg}")

log_event("INFO", "server started", "port 8080 open", "ready")

Keyworded Arguments — **kwargs

Double-asterisk ** is *args's cousin — it catches all remaining keyword arguments and packs them into a dictionary. This lets your function accept an open-ended set of named options without you having to declare each one.

def create_user(username, **kwargs):
    print(f"Creating user: {username}")
    print("kwargs is:", kwargs)
    print("type is: ", type(kwargs))
    for key, value in kwargs.items():
        print(f"  {key} = {value}")

create_user(
    "priya_92",
    email="priya@example.com",
    age=28,
    country="India",
    is_admin=False
)

The Full Parameter Order — Putting It All Together

When a function uses every kind of parameter at once, Python enforces a strict order in the definition. Memorize this sequence — every Python function you'll ever write follows it.

def register(username, email, role="user", *permissions, **profile):
    print(f"username    : {username}")
    print(f"email       : {email}")
    print(f"role        : {role}")
    print(f"permissions : {permissions}")
    print(f"profile     : {profile}")

register(
    "rahul_dev",                     # username (positional)
    "rahul@example.com",              # email    (positional)
    "admin",                         # role     (overrides default)
    "read", "write", "delete",        # *permissions -> tuple
    country="India",                  # **profile -> dict
    joined="2024-01-15"
)

Argument Pass by Reference — How Python Actually Works

Case 1 — Immutable Objects (int, str, tuple, float, bool)

def try_change(x):
    print(f"  inside before: x = {x}, id = {id(x)}")
    x = x + 100                     # rebinds LOCAL x to a new int
    print(f"  inside after : x = {x}, id = {id(x)}")

number = 5
print(f"before call: number = {number}, id = {id(number)}")
try_change(number)
print(f"after call : number = {number}, id = {id(number)}")

Notice the ids. The parameter x started pointing at the very same integer as number. But x = x + 100 created a new integer and rebound the local name x to it. The caller's number was never touched because integers are immutable — you can't modify 5 in place; you can only create a new object.

Case 2 — Mutable Objects (list, dict, set, custom classes)

def add_item(cart):
    print(f"  inside before: cart = {cart}, id = {id(cart)}")
    cart.append("laptop")          # MUTATES the object in place
    print(f"  inside after : cart = {cart}, id = {id(cart)}")

my_cart = ["book", "pen"]
print(f"before call: cart = {my_cart}, id = {id(my_cart)}")
add_item(my_cart)
print(f"after call : cart = {my_cart}, id = {id(my_cart)}")

Case 3 — Mutable Object, but Rebinding Instead of Mutating

def replace_cart(cart):
    cart = ["phone", "charger"]     # REBINDS local name to a NEW list
    print(f"  inside: cart = {cart}")

my_cart = ["book", "pen"]
replace_cart(my_cart)
print(f"after : cart = {my_cart}")     # unchanged!

Same object type (list, which is mutable), but a completely different outcome. The assignment cart = [...] did not modify the caller's list — it just made the local name cart point at a brand-new list. The original survived untouched.

The Mutable Default Argument Trap

This is the single most infamous Python gotcha. Every Python developer meets it at least once — usually in production, at 2 AM.

# The trap:
def append_to(item, target=[]):     # mutable default!
    target.append(item)
    return target

print(append_to(1))
print(append_to(2))
print(append_to(3))

Each call was expected to return a fresh [item]. Instead, the same list is reused and grows across calls. Why? Because default values are evaluated once, at function-definition time. That one list object is bound as the default forever — every call that doesn't supply target mutates the same object.

# The correct pattern:
def append_to(item, target=None):
    if target is None:
        target = []                    # fresh list every call
    target.append(item)
    return target

print(append_to(1))
print(append_to(2))
print(append_to(3))

A Complete Real-World Example — Building a Flexible Logger

Let's combine everything: required parameters, defaults, keyword calls, *args, **kwargs, and safe handling of mutable inputs.

import datetime

def log(message, *tags, level="INFO", timestamp=True, **metadata):
    """
    Log a message with optional tags, level, timestamp, and metadata.

    - message   : required, the log body
    - *tags     : any number of string tags
    - level     : keyword-only defaulted string (INFO, WARN, ERROR)
    - timestamp : whether to prepend a timestamp
    - **metadata: any extra key=value context (user_id, request_id, ...)
    """
    parts = []

    if timestamp:
        now = datetime.datetime.now().strftime("%H:%M:%S")
        parts.append(f"[{now}]")

    parts.append(f"[{level}]")

    if tags:
        parts.append("#" + " #".join(tags))

    parts.append(message)

    if metadata:
        meta_str = " ".join(f"{k}={v}" for k, v in metadata.items())
        parts.append(f"| {meta_str}")

    print(" ".join(parts))


# Simple call — only the required argument
log("Server started")

# With tags (variable positional)
log("Cache miss", "redis", "user-profile")

# Override defaults using KEYWORDS — skip timestamp change
log("Login failed", level="WARN")

# Everything at once
log(
    "Payment declined",
    "stripe", "billing",             # *tags
    level="ERROR",                     # overrides default
    timestamp=True,                     # keeps default
    user_id=4821,                        # **metadata
    request_id="req-9f3a",
    amount=2500
)

Golden Rules