When to Use Arguments in Python: Absolute Beginners Tutorial

Python functions become genuinely reusable only when they accept data from the outside world. Arguments are how that data gets in. Knowing which argument type to reach for — and when — is one of the first skills that separates code that works once from code that works everywhere.

Every time you define a function in Python, you decide what information it needs to do its job. That decision shapes how flexible, readable, and reusable your code becomes. This tutorial walks through each argument type from scratch, shows you exactly when each one belongs in your code, and includes hands-on exercises to cement the patterns.

Parameters vs. Arguments: the distinction that matters

These two words get used interchangeably in conversation, but they refer to different things in the code itself. A parameter is the name you list inside the parentheses when you write a def statement. An argument is the concrete value you supply when you call the function. The parameter is the slot; the argument fills the slot.

# 'name' is a parameter — it exists in the function definition
def greet(name):
    print(f"Hello, {name}!")

# "Alice" is an argument — it is the value passed at call time
greet("Alice")
# Output: Hello, Alice!

The five argument types and when to use each

Python gives you five distinct argument styles. Each solves a different problem. The table below summarizes them before each is covered in depth.

Positional arguments

Positional arguments are the simplest form. The caller passes values in the exact order the parameters appear in the definition. If the order is wrong, the values land in the wrong slots — Python has no way to know you made a mistake.

def describe_planet(name, diameter_km, moons):
    print(f"{name}: {diameter_km:,} km wide, {moons} moon(s)")

describe_planet("Mars", 6_779, 2)
# Output: Mars: 6,779 km wide, 2 moon(s)

# Wrong order — no error, but the output is nonsense
describe_planet(2, "Mars", 6_779)
# Output: 2: Mars km wide, 6779 moon(s)

Keyword arguments

Any function that accepts positional arguments can also be called using the parameter names explicitly. When you supply argument names at the call site, order no longer matters. This is especially useful for functions with several parameters where the correct order is not obvious.

def create_user(username, email, role):
    return {"username": username, "email": email, "role": role}

# Positional call — relies on caller knowing the order
create_user("jdoe", "jdoe@example.com", "admin")

# Keyword call — order does not matter, intent is explicit
create_user(email="jdoe@example.com", role="admin", username="jdoe")

Default arguments

A default argument gives a parameter a value to fall back on when the caller does not supply one. This makes certain inputs optional without requiring you to write separate versions of the function.

def send_message(recipient, message, priority="normal"):
    print(f"[{priority.upper()}] To {recipient}: {message}")

# Caller does not care about priority — default applies
send_message("alice", "Your report is ready")
# Output: [NORMAL] To alice: Your report is ready

# Caller overrides the default
send_message("bob", "Server is down", priority="urgent")
# Output: [URGENT] To bob: Server is down

# Dangerous — the list is shared across all calls
def add_item_bad(item, container=[]):
    container.append(item)
    return container

# Safe — a new list is created each time
def add_item_good(item, container=None):
    if container is None:
        container = []
    container.append(item)
    return container

*args — variable positional arguments

When you prefix a parameter with a single asterisk, Python collects all extra positional arguments into a tuple under that name. The name args is a convention; the asterisk is what matters. Use *args when you genuinely cannot predict how many values the caller will pass.

def total_score(*scores):
    # 'scores' is a tuple of whatever the caller passes
    return sum(scores)

print(total_score(88, 92, 76))          # 256
print(total_score(100))                  # 100
print(total_score(70, 80, 90, 85, 95))  # 420

**kwargs — variable keyword arguments

Two asterisks collect any extra named arguments into a dictionary. Each key is the argument name the caller used; each value is what was passed. **kwargs appears frequently in wrapper functions and in code that forwards options to another function.

def build_profile(**details):
    # 'details' is a dict of whatever named args the caller passed
    for key, value in details.items():
        print(f"  {key}: {value}")

build_profile(name="Sam", role="engineer", team="infra")
# Output:
#   name: Sam
#   role: engineer
#   team: infra

"The best interface is one where each argument name reads like documentation." — Python community convention

Argument ordering rules

Python enforces a strict ordering rule for function signatures. When you combine multiple argument types, they must appear in this sequence: positional arguments first, then default arguments, then *args, then keyword-only arguments (those defined after *args), and finally **kwargs. Any other arrangement is a SyntaxError.

# Valid signature combining all five argument types
def process(
    source,          # positional — required
    dest="output",   # default — optional
    *files,          # *args — zero or more extra positional values
    verbose=False,   # keyword-only (comes after *args)
    **options        # **kwargs — zero or more extra named values
):
    pass

# Valid calls
process("data.csv")
process("data.csv", "results/", "extra1.csv", verbose=True)
process("data.csv", compression="gzip", encoding="utf-8")

Python Learning Summary Points

1. A parameter is the name in the function definition; an argument is the value passed at the call site. The distinction matters when reading error messages.
2. Positional arguments are required and order-dependent. Default arguments are optional with a fallback. Keyword style is a calling convention that works with any positional or default parameter.
3. *args collects extra positional values into a tuple. **kwargs collects extra named values into a dictionary. Both handle an unknown number of inputs.
4. The valid signature order is: positional, default, *args, keyword-only, **kwargs. Deviating raises a SyntaxError.
5. Never use a mutable object as a default argument value. Use None and create the object inside the function body.

Choosing the right argument type is a design decision. Positional arguments keep required inputs obvious. Defaults reduce boilerplate for callers who share the common case. Keyword style makes long call sites readable. *args and **kwargs keep your functions open to inputs you have not anticipated. Applying each at the right time produces functions that are both flexible and easy to reason about.