Learn What Parameters Are in Python: Absolute Beginners Tutorial

Parameters are how Python functions receive information. Every time you write a function, parameters are the named slots inside the parentheses that let that function accept data from the outside world. Without them, a function can only ever do the same exact thing every time it runs. With them, one function can handle dozens of different situations.

Python draws a clear line between the variable name you define in a function and the value you hand in when calling it. Getting that distinction right early on prevents a lot of confusion. This tutorial works through each parameter type from the simplest case to the more flexible forms, with interactive challenges along the way to reinforce what you read.

Parameters vs. Arguments: The Key Distinction

When you write a function definition in Python, the names inside the parentheses are called parameters. When you actually call that function and pass in values, those values are called arguments. The two terms are not interchangeable even though people mix them up constantly.

# 'name' is a PARAMETER — it lives in the function definition
def greet(name):
    print("Hello,", name)

# 'Alice' is an ARGUMENT — it is the actual value passed at call time
greet("Alice")

Think of a parameter as a labeled box on a form. The form itself (the function definition) describes what kind of information goes in that box. The argument is the actual thing you write in the box when you fill the form out.

A function with no parameters looks like this. The parentheses are still required — they are just empty.

def say_hello():
    print("Hello, world!")

say_hello()   # Output: Hello, world!

A function with multiple parameters separates each name with a comma. When you call the function, you provide one argument for each parameter, in the same order they are listed.

def add(x, y):
    return x + y

result = add(3, 5)
print(result)   # Output: 8

Positional and Default Parameters

There are several ways to define and pass parameters. The most fundamental are positional parameters, where order determines which value goes to which name. Build on those with default parameters, which give a parameter a fallback value so it becomes optional when calling the function.

Positional Parameters

With positional parameters, Python assigns values left to right, matching the first argument to the first parameter, the second argument to the second parameter, and so on. If the order is wrong, the behavior will be wrong — Python does not detect this for you automatically.

def describe_pet(animal, name):
    print(f"I have a {animal} named {name}.")

describe_pet("cat", "Mochi")    # I have a cat named Mochi.
describe_pet("Mochi", "cat")    # I have a Mochi named cat. (wrong order!)

Default Parameters

A default parameter has a value pre-assigned in the function definition. If the caller does not supply an argument for it, Python uses the default. If the caller does supply a value, that value overrides the default.

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")              # Hello, Alice!
greet("Bob", "Good morning")  # Good morning, Bob!

A common mistake is using a mutable object such as a list as a default value. That default is created once and shared across all calls, which leads to surprising behavior.

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

print(add_item("apple"))   # ['apple']
print(add_item("banana"))  # ['apple', 'banana'] -- not what you expected!

# Safe — use None as the default and create a new list inside
def add_item_safe(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

Keyword Arguments and Parameter Types at a Glance

A keyword argument is not a new kind of parameter — it is a way of passing an argument at call time by naming the parameter you want it to bind to. This lets you pass arguments in any order and makes call sites more self-documenting.

def register(username, email, role="member"):
    print(f"Registering {username} ({email}) as {role}")

# Positional
register("alice", "alice@example.com")

# Keyword — order no longer matters
register(email="bob@example.com", username="bob", role="admin")

*args: Accepting Any Number of Positional Arguments

When you do not know in advance how many positional values a function will receive, use *args. The single asterisk tells Python to collect all remaining positional arguments into a tuple. The name args is a convention — the asterisk is what matters.

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

print(total(1, 2))          # 3
print(total(10, 20, 30))    # 60
print(total(5))             # 5
print(total())              # 0

# Inside the function, args is a tuple
def show_items(*args):
    for item in args:
        print(item)

**kwargs: Accepting Any Number of Keyword Arguments

The double-asterisk syntax collects extra keyword arguments into a dictionary. Each key is the argument name the caller used, and each value is the corresponding value passed.

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

show_info(name="Alice", age=30, city="Austin")
# name: Alice
# age: 30
# city: Austin

You can combine all of these in a single function definition. When you do, they must appear in a specific order: regular positional parameters first, then *args, then keyword-only parameters, then **kwargs last.

def full_example(a, b, *args, label="default", **kwargs):
    print("a:", a)
    print("b:", b)
    print("extra positional:", args)
    print("label:", label)
    print("extra keyword:", kwargs)

full_example(1, 2, 3, 4, label="test", x=10, y=20)
# a: 1
# b: 2
# extra positional: (3, 4)
# label: test
# extra keyword: {'x': 10, 'y': 20}

"Arguments are said to be passed to a function; parameters are local variables." — Python Documentation

Python Learning Summary Points

1. A parameter is a name in the function definition; an argument is the value passed when calling the function. The two words describe the same slot from different angles.
2. Positional parameters depend on order. Default parameters have fallback values and must appear after positional ones. Passing too many or too few required arguments raises a TypeError.
3. *args collects extra positional arguments into a tuple; **kwargs collects extra keyword arguments into a dictionary. Both are optional and consume any leftover values not matched by earlier parameters.
4. When combining parameter types, the required order is: positional, default, *args, keyword-only, **kwargs. Python enforces this order with a SyntaxError if violated.
5. Never use a mutable object such as a list or dictionary as a default parameter value. Use None as the default and create the mutable inside the function body instead.

Parameters are one of the most frequently used tools in any Python program. Understanding how they behave — especially how defaults, *args, and **kwargs interact — gives you a solid foundation for writing functions that are flexible, readable, and easy to call correctly. The interactive challenges above mirror the kind of thinking that becomes automatic with practice.