What Are Arguments in Python? Absolute Beginners Tutorial

Arguments are the values you hand a function when you call it. Without them, functions would be isolated — doing the same thing every time with no way to accept input from the outside. Once you understand how arguments work, you unlock the ability to write reusable, flexible code that can handle many different situations from a single function definition.

When you write a function in Python, you define what inputs it expects. Those expected inputs have names — those are called parameters. When you actually call the function and pass real values in, those real values are called arguments. Python gives you several ways to pass arguments, each with its own rules and use cases. This tutorial walks through all of them from the ground up.

Parameters vs. Arguments

The words "parameter" and "argument" are sometimes used interchangeably, but they refer to different things. A parameter is the name listed inside the parentheses when you define a function. An argument is the actual value you supply when you call that function.

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

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

When Python runs greet("Alice"), it assigns the argument "Alice" to the parameter name inside the function. The function then has access to that value through the name name.

Types of Arguments

Python recognizes four main types of arguments. Each one controls a different aspect of how values get matched to parameters when you call a function.

Positional Arguments

Positional arguments are the most common kind. Python matches them to parameters by position — left to right, in the order they appear. If a function expects two positional arguments and you pass three, Python raises a TypeError.

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

# Positional: 'dog' goes to animal, 'Rex' goes to name
describe_pet("dog", "Rex")
# Output: I have a dog named Rex.

# Swap the order and the meaning changes completely
describe_pet("Rex", "dog")
# Output: I have a Rex named dog.

Keyword Arguments

Keyword arguments let you name each value explicitly when calling a function. Because you supply the parameter name, order no longer matters. This makes calls to complex functions much easier to read and harder to get wrong.

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

# Keyword arguments — order does not matter
describe_pet(name="Rex", animal="dog")
# Output: I have a dog named Rex.

# Mixing positional and keyword (positional must come first)
describe_pet("dog", name="Rex")
# Output: I have a dog named Rex.

Default Arguments

A default argument provides a fallback value for a parameter. If the caller does not pass a value for that parameter, Python uses the default. Default parameters are written in the function definition using an equals sign. They must always appear after any parameters that have no default.

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

greet("Alice")              # Uses the default greeting
# Output: Hello, Alice!

greet("Bob", "Good morning") # Overrides the default
# Output: Good morning, Bob!

Here is a reference comparing the three argument types you have seen so far:

*args and **kwargs

Sometimes you do not know ahead of time how many arguments a function will receive. Python handles this with two special syntax patterns: *args for a variable number of positional arguments, and **kwargs for a variable number of keyword arguments.

*args — Variable Positional Arguments

Placing a single asterisk before a parameter name tells Python to collect all remaining positional arguments into a tuple. The name args is a convention — the asterisk is what matters syntactically.

def total(*numbers):
    result = 0
    for n in numbers:
        result += n
    return result

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

Inside the function, numbers is a regular tuple. You iterate over it, index it, or pass it to other functions just like any other tuple.

**kwargs — Variable Keyword Arguments

Placing two asterisks before a parameter name tells Python to collect all extra keyword arguments into a dictionary. Each key is the argument name the caller used; each value is what the caller passed.

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

show_profile(name="Alice", role="developer", level="junior")
# Output:
# name: Alice
# role: developer
# level: junior

Combining All Four Types

You can mix all four argument types in a single function definition. The rule is that they must appear in this specific order: regular positional parameters first, then *args, then keyword parameters with defaults, then **kwargs.

def build_report(title, *sections, separator="---", **metadata):
    print(f"Title: {title}")
    for section in sections:
        print(separator)
        print(section)
    print("\nMetadata:")
    for key, value in metadata.items():
        print(f"  {key}: {value}")

build_report(
    "Q1 Review",
    "Sales increased 12%",
    "Costs held steady",
    separator="===",
    author="Jamie",
    version="1.0"
)

"Functions are the primary and most important method of code organization and reuse in Python." — Wes McKinney, Python for Data Analysis

Python Learning Summary Points

1. A parameter is the name in the function definition; an argument is the actual value passed when the function is called. Python matches arguments to parameters positionally by default.
2. Keyword arguments let you pass values by name, making the call order irrelevant and the intent obvious. Default arguments let you skip a parameter entirely — Python fills in the preset value. Defaults must always follow required parameters in the definition.
3. *args captures any number of extra positional values into a tuple; **kwargs captures any number of extra keyword values into a dictionary. When combining all types, the required order is: positional params, *args, keyword-only params, **kwargs.

Arguments are one of the most used parts of Python. Every time you call a built-in like print(), range(), or sorted(), you are passing arguments. Knowing how each type works — and when to use which — gives you direct control over every function you write or consume.