Python Functions: def Keyword, Parameters, Arguments

Functions are the building block of reusable code, and understanding the def keyword, the distinction between parameters and arguments, and how to pass data to functions is essential for writing clean, maintainable Python. This article dives into the mechanics of function definition, focusing on the syntax of the def keyword and the critical—but often confused—difference between parameters (placeholders defined in the function signature) and arguments (the actual values passed when calling the function).

Key Takeaways

def keyword starts every function definition and tells Python to create a reusable block of code with a name.
Parameters are placeholders listed in the function definition's parentheses; arguments are the concrete values passed during the call.
Positional arguments are matched by order to parameters, making them simple but order-dependent.
Keyword arguments use explicit names (parameter=value), improving readability and flexibility at the cost of slightly more verbose syntax.
Mixed arguments are allowed as long as positional arguments come before keyword arguments.

What is a Function Definition and How Do You Structure It?

Every Python function is built from the same basic structure: the def keyword, a function name, parameters in parentheses, a colon, and an indented code block. This structure is non-negotiable—Python's parser expects exactly this order.

def function_name(parameter1, parameter2):
    # The code to be executed is in this indented block
    # ...
    return "A value to send back"

Let's break down each component:

def Keyword: This tells Python you are defining a new function. It is a reserved word you cannot use as a variable name. def is the entry point for every function in Python.
function_name: A descriptive identifier following snake_case convention (lowercase with underscores). Good names are verbs or descriptive phrases: calculate_tax, send_email, is_prime(), fetch_user_data(). Poor names like process() or do_stuff() hide the function's intent from future readers.
Parentheses (): Always present, even if there are no parameters. These delimit the parameter list and distinguish a function definition from a simple variable assignment.
Parameters: The names you give to inputs your function will receive. They act as local variables within the function's scope. A function can have zero parameters, one, or many. Parameters are not data—they are placeholders for the data that will be provided when the function is called.
Colon :: Required syntax that signals the end of the function's header and the start of the code block.
Indented Body: The block of Python code (typically 4 spaces or 1 tab indentation) that contains the function's logic. Python uses indentation—not braces or keywords like end—to define scope.
return Statement (Optional): This statement exits the function and sends a value back to the caller. If a function does not have an explicit return, Python returns None by default.

# A complete, minimal function
def greet(name):
    """A docstring explaining what the function does."""
    message = f"Hello, {name}!"
    return message

# Another example: a function with no parameters
def get_current_year():
    import datetime
    return datetime.datetime.now().year

# A function with multiple parameters
def calculate_area(length, width):
    return length * width

The docstring (the string immediately after the def line) is optional but recommended. It documents the function's purpose, parameters, and return value, and is accessible via the help() function and IDE autocompletion.

What is the Difference Between Parameters and Arguments?

The terms "parameter" and "argument" are often used interchangeably in casual speech, but they have distinct technical meanings. This distinction is crucial for understanding how data flows into and through functions.

A parameter is the variable listed in the function definition—a placeholder name. An argument is the actual value passed to the function during the call—the concrete data. Think of parameters as the recipe's ingredient list, and arguments as the actual ingredients you pull from your pantry.

# 'name' and 'location' are PARAMETERS (defined in the signature)
def generate_greeting(name, location):
    """Generate a greeting string."""
    return f"Hello {name}, welcome to {location}!"

# "Alice" and "Python City" are ARGUMENTS (actual values passed to the function)
greeting = generate_greeting("Alice", "Python City")
print(greeting)  # Output: Hello Alice, welcome to Python City!

In this example, when generate_greeting is called with arguments "Alice" and "Python City", Python assigns:

The argument "Alice" to the parameter name
The argument "Python City" to the parameter location

Inside the function, name and location behave like normal variables, scoped to the function. If you try to access name outside the function, Python raises a NameError.

# name and location do not exist outside the function
def greet(name, location):
    print(f"Hello {name} in {location}")

greet("Bob", "Code Valley")
# print(name)  # NameError: name 'name' is not defined

This parameter-argument distinction matters because it clarifies where data comes from and how it moves through your program. Parameters define a contract ("this function expects 2 inputs"); arguments fulfill that contract ("here are the 2 inputs").

How Do You Pass Arguments to Functions?

Python provides multiple ways to pass arguments, each with trade-offs between simplicity, readability, and flexibility. The two most common patterns are positional and keyword arguments.

Positional Arguments: Order-Dependent

Positional arguments are matched to parameters based on their order (position). The first argument goes to the first parameter, the second argument to the second parameter, and so on.

def create_user_profile(username, age, city):
    """Creates a user profile string."""
    return f"User: {username}, Age: {age}, Location: {city}"

# Arguments matched by position
profile = create_user_profile("dev_dave", 35, "Codeville")
print(profile)
# Output: User: dev_dave, Age: 35, Location: Codeville

In this call:

"dev_dave" (1st argument) → username (1st parameter)
35 (2nd argument) → age (2nd parameter)
"Codeville" (3rd argument) → city (3rd parameter)

Positional arguments are simple but dangerous: if you mix up the order, Python won't complain—it will just assign values to the wrong parameters and produce incorrect or nonsensical results.

# Wrong order leads to a logical error Python cannot catch
wrong_profile = create_user_profile(35, "Codeville", "dev_dave")
print(wrong_profile)
# Output: User: 35, Age: Codeville, Location: dev_dave
# This is syntactically valid but semantically wrong

For functions with many parameters or when calling code elsewhere in your codebase, positional-only arguments make refactoring risky: reordering parameters breaks all call sites.

Keyword Arguments: Self-Documenting

Keyword arguments (also called named arguments) explicitly name each parameter when passing its value. The syntax is parameter_name=value. With keyword arguments, order does not matter.

def create_user_profile(username, age, city):
    """Creates a user profile string."""
    return f"User: {username}, Age: {age}, Location: {city}"

# Keyword arguments; order does not matter
profile1 = create_user_profile(username="dev_dave", age=35, city="Codeville")
profile2 = create_user_profile(city="Codeville", username="dev_dave", age=35)
profile3 = create_user_profile(age=35, city="Codeville", username="dev_dave")

print(profile1)  # Output: User: dev_dave, Age: 35, Location: Codeville
print(profile2)  # Output: User: dev_dave, Age: 35, Location: Codeville
print(profile3)  # Output: User: dev_dave, Age: 35, Location: Codeville

All three calls produce the same result because the argument names explicitly map to parameters.

Benefits of keyword arguments:

Readability: The function call becomes self-documenting. A reader immediately understands which value is being assigned to which parameter without consulting the function definition.
Flexibility: You don't have to memorize the parameter order. This is especially helpful for functions with many inputs or functions you haven't used recently.
Refactoring Safety: If you add new parameters to a function, existing keyword argument calls still work as long as you don't remove or rename parameters.

Mixing Positional and Keyword Arguments

You can combine both approaches in a single call, but there is a strict rule: positional arguments must come before keyword arguments. This is a language syntax requirement—Python will raise a SyntaxError otherwise.

def create_user_profile(username, age, city):
    """Creates a user profile string."""
    return f"User: {username}, Age: {age}, Location: {city}"

# This works: positional args first, then keyword args
profile = create_user_profile("dev_dave", age=35, city="Codeville")
print(profile)  # Output: User: dev_dave, Age: 35, Location: Codeville

# This also works: only keyword args
profile = create_user_profile(username="dev_dave", age=35, city="Codeville")

# This raises SyntaxError: keyword arg before positional arg
# profile = create_user_profile(username="dev_dave", 35, "Codeville")

Best practice for readability: use positional arguments for the first 1–2 parameters, especially if they are required and unambiguous (like open(filepath, mode)). Use keyword arguments for optional parameters or when the function has many inputs.

Default Parameters

Functions can provide default values for parameters, making them optional. A parameter with a default value does not need to be provided in the call.

def greet(name, greeting="Hello"):
    """Greet someone with an optional custom greeting."""
    return f"{greeting}, {name}!"

print(greet("Alice"))  # Output: Hello, Alice!
print(greet("Bob", "Hi"))  # Output: Hi, Bob!
print(greet("Charlie", greeting="Hey"))  # Output: Hey, Charlie!

Parameters with defaults must come after parameters without defaults in the function definition. This prevents ambiguity: Python evaluates arguments left-to-right and needs to know which positional arguments map to which parameters.

# Correct: required params first, optional params second
def register_user(username, email, newsletter=False):
    return f"User {username} registered with {email}. Newsletter: {newsletter}"

# Incorrect: optional param before required param
# def register_user(newsletter=False, username, email):
#     # SyntaxError: non-default argument follows default argument

Frequently Asked Questions

What is a *args parameter and when should I use it?

*args allows a function to accept a variable number of positional arguments, packed into a tuple. For example, def add(*numbers) can be called as add(1), add(1, 2), or add(1, 2, 3, 4, 5). This is useful for wrapper functions or functions like print() that take any number of inputs. However, overusing *args makes code less explicit about what arguments are expected. Prefer explicit parameters when possible; use *args for truly variable-length input or when forwarding arguments to another function.

def add(*numbers):
    return sum(numbers)

print(add(1, 2, 3))  # Output: 6
print(add(10, 20))  # Output: 30

What is **kwargs and when should I use it?

**kwargs (keyword arguments) allows a function to accept arbitrary keyword arguments as a dictionary. For example, def configure(**options) can be called as configure(debug=True, timeout=30), and options inside the function is {'debug': True, 'timeout': 30}. This is useful for wrapper functions, configuration builders, or functions that forward arguments to other functions. Like *args, overuse of **kwargs reduces code clarity, so prefer explicit parameters when the set of arguments is known.

Why can't I have a parameter without a default after one with a default?

Python evaluates arguments left-to-right. If you define def func(required, optional=5), Python knows to assign the first positional argument to required and the second (if provided) to optional. But if you swap the order to def func(optional=5, required), Python cannot determine which arguments are positional and which are defaults. To avoid ambiguity, all optional parameters must come after all required parameters.

What is the difference between returning a value and printing a value?

return sends a value back to the caller (the code that invoked the function). print() displays text to the console. A function can return a value that the caller uses, while printing happens as a side effect. You should almost always return rather than print inside functions—let the caller decide whether to print, save, or process the result.

def calculate_sum(a, b):
    return a + b  # Return to caller

def bad_sum(a, b):
    print(a + b)  # Prints to console; returns None
    # return None

result = calculate_sum(3, 4)
print(result)  # Prints 7; caller has the value

bad_result = bad_sum(3, 4)  # Prints 7; but bad_result is None

Key Takeaways​

What is a Function Definition and How Do You Structure It?​

What is the Difference Between Parameters and Arguments?​

How Do You Pass Arguments to Functions?​

Positional Arguments: Order-Dependent​

Keyword Arguments: Self-Documenting​

Mixing Positional and Keyword Arguments​

Default Parameters​

Frequently Asked Questions​

What is a *args parameter and when should I use it?​

What is **kwargs and when should I use it?​

Why can't I have a parameter without a default after one with a default?​

What is the difference between returning a value and printing a value?​

Further Reading​