Python Parameter vs Argument: The Real Difference
Learn the precise difference between parameters and arguments in Python, how they interact, and why the distinction improves code clarity.

In Python, the terms "parameter" and "argument" are often used interchangeably, but they refer to distinct parts of a function. Understanding the difference is essential for writing clear code and communicating effectively with other developers. This article explains the exact roles of each, how they interact during a function call, and why the distinction matters in real-world codebases.
Parameters and Arguments: The Core Distinction
A parameter is a name in a function definition that stands for an input the function expects. An argument is the actual value you pass to the function when you call it. The function definition declares parameters; the function call supplies arguments. This is not a trivial semantic point—it affects how you reason about scope, defaults, and error messages.
def greet(name): # name is a parameter
return f"Hello, {name}"
greet("Alice") # "Alice" is an argumentHere, name is a parameter because it exists only inside the function definition. "Alice" is an argument because it is the concrete value passed during the call. The parameter receives the argument's value when the function executes.
What a Parameter Is in a Python Function Definition
A parameter is a local name in a function's signature. It determines how many inputs the function can accept and how those inputs may be supplied. Parameters can be positional, keyword-only, or variadic. The declaration determines how the function can be called.
def add(left, right=0): # left and right are parameters
return left + rightleft is a required parameter; right has a default value and is optional. The default is evaluated once at definition time, which matters when the default is a mutable object—a common source of bugs.
Parameters are bound to arguments at call time. The binding follows Python's call-by-object-reference semantics: the parameter becomes a reference to the argument object. For immutable objects like integers, this behaves like call-by-value; for mutable objects like lists, changes inside the function affect the original object.
What an Argument Is When Calling a Function
An argument is an expression you pass in a function call. It can be a literal, a variable, or a more complex expression. Arguments are evaluated before the call, and their resulting objects are assigned to the corresponding parameters.
def multiply(a, b):
return a * b
x = 3
multiply(x, x + 1) # arguments are x and x+1, evaluated to 3 and 4Arguments can be passed positionally, by keyword, or as a mix. Positional arguments are matched to parameters in order; keyword arguments are matched by name. This flexibility is part of Python's design but requires care to avoid confusion.
Positional, Keyword, and Default Arguments in Practice
Python supports several argument-passing styles. Understanding them helps you read and write function calls correctly.
def describe(name, age, city="Unknown"):
return f"{name} ({age}) from {city}"
# Positional arguments
describe("Bob", 30)
# Keyword arguments
describe(name="Bob", age=30, city="Paris")
# Mixed: positional first, then keyword
describe("Bob", age=30, city="Paris")The rules are simple: positional arguments must appear before keyword arguments, and each parameter can receive only one value. If you pass a keyword argument that was already filled positionally, Python raises TypeError: got multiple values for argument 'name'.
Default parameters allow a function to be called with fewer arguments than declared parameters. The default value is used when no argument is supplied. This is a powerful feature, but it also means the distinction between a missing argument and an explicit None can be meaningful.
*args and **kwargs: When Parameters and Arguments Get Confusing
The variadic parameters *args and **kwargs blur the line further. *args collects extra positional arguments into a tuple; **kwargs collects extra keyword arguments into a dictionary. These are still parameters in the definition, but they accept an arbitrary number of arguments at call time.
def log(message, *args, **kwargs):
print(message)
print("args:", args)
print("kwargs:", kwargs)
log("start", 1, 2, level="debug")In the call, 1 and 2 are positional arguments captured by *args, and level="debug" is a keyword argument captured by **kwargs. This pattern is common in decorators, wrappers, and framework code where the function must forward unknown arguments.
Confusion arises because people say "args" when they mean arguments, but *args is a parameter name. The asterisk is part of the syntax that tells Python to pack extra arguments into a tuple. Similarly, **kwargs is a parameter that receives a dictionary of keyword arguments.
Why the Distinction Matters for Readable and Maintainable Code
Using the terms precisely improves code review and debugging. When a function signature says def fetch_data(url, timeout=30), url and timeout are parameters. A reviewer can immediately see what the function expects. When a call site says fetch_data(api_url, timeout=10), the arguments are api_url and 10. Mixing these terms in discussion can lead to misunderstandings about what the function actually accepts.
In large codebases, functions with many parameters become hard to call correctly. The distinction helps you decide when to refactor: if a function has too many parameters, you might group them into a data class or use keyword-only arguments to force clarity. For example, using keyword-only parameters (after a *) makes the call site self-documenting:
def configure(*, host, port, ssl=True):
pass
configure(host="localhost", port=443)This forces callers to use keyword arguments, which reduces positional mistakes. The parameters are now explicit about their meaning.
Common Mistakes That Mix Up Parameters and Arguments
One frequent error is using a parameter name as if it were a global variable. Inside the function, the parameter is a local name; outside, it does not exist. Another mistake is assuming that default arguments are evaluated at call time. They are evaluated once at definition time, which can cause unexpected behavior with mutable defaults.
def append_to_list(item, lst=[]):
lst.append(item)
return lst
print(append_to_list(1)) # [1]
print(append_to_list(2)) # [1, 2] # surprising!The default list [] is created once and reused. The same parameter lst refers to the same object across calls. The fix is to use None as the default and create a new list inside the function:
def append_to_list(item, lst=None):
if lst is None:
lst = []
lst.append(item)
return lstThis is a classic pitfall that only makes sense when you understand that the default value belongs to a parameter, not an argument. The argument is what you pass on each call; the default is a single object created at definition time and reused across calls.
Another common mistake is placing a positional argument after a keyword argument, which raises a SyntaxError. Python's grammar is strict: all positional arguments must precede keyword arguments. This rule exists to keep the mapping from arguments to parameters unambiguous.
Understanding the parameter-argument distinction also helps when reading tracebacks. A TypeError like missing 1 required positional argument: 'b' refers to a parameter b that was not supplied an argument. Knowing that the error names a parameter from the function definition, not a value from the call, speeds up debugging.
Finally, the distinction is crucial when using introspection tools like inspect.signature. It returns parameters, not arguments. If you are writing a decorator that inspects a function's signature, you are working with parameters. The actual values passed at runtime are arguments. This separation is fundamental to how Python's function model works.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.