Function Arguments

Introduction

In the previous lesson you defined simple functions with plain parameters. Python actually offers several flexible ways to pass arguments into a function — default values, named keyword arguments, and even a variable number of arguments using *args and **kwargs.

Understanding these tools lets you write functions that are flexible and convenient to call, which is why nearly every real Python library — from print() itself to major frameworks — relies heavily on them.

Positional Arguments

Positional arguments are matched to parameters purely by their order — the first argument fills the first parameter, the second fills the second, and so on.

def describe_pet(species, name):
    print(f"{name} is a {species}.")

describe_pet("dog", "Rex")

Rex is a dog.

Here "dog" fills species and "Rex" fills name because of their position. Swapping the order of the arguments would swap their meaning too, which can cause subtle bugs.

def describe_pet(species, name):
    print(f"{name} is a {species}.")

describe_pet("Rex", "dog")

dog is a Rex.

Default Parameter Values

You can give a parameter a default value by writing = value after its name in the function definition. If the caller does not supply that argument, the default is used automatically.

def make_coffee(size="medium", extra_shot=False):
    shot_text = " with an extra shot" if extra_shot else ""
    print(f"Making a {size} coffee{shot_text}.")

make_coffee()
make_coffee("large")
make_coffee("large", True)

Making a medium coffee.
Making a large coffee.
Making a large coffee with an extra shot.

def add_item(item, cart=None):
    if cart is None:
        cart = []
    cart.append(item)
    return cart

print(add_item("apple"))
print(add_item("banana"))

['apple']
['banana']

Keyword Arguments

A keyword argument is passed using name=value at the call site, matching the parameter by name instead of position. This makes calls clearer and lets you supply arguments in any order.

def describe_pet(species, name):
    print(f"{name} is a {species}.")

describe_pet(name="Rex", species="dog")

Rex is a dog.

Even though name is written first at the call site, Python matches each value by name, so the output is still correct regardless of order.

*args: Variable Positional Arguments

Sometimes you do not know in advance how many positional values a function should accept. Prefixing a parameter with a single asterisk (*args) collects any number of extra positional arguments into a tuple.

def total(*args):
    print("Received:", args)
    return sum(args)

print(total(1, 2, 3))
print(total(10, 20, 30, 40))

Received: (1, 2, 3)
6
Received: (10, 20, 30, 40)
100

The name args is just a convention — what matters is the single asterisk (*), which tells Python to gather every extra positional argument into a tuple.

**kwargs: Variable Keyword Arguments

Similarly, prefixing a parameter with two asterisks (**kwargs) collects any number of extra keyword arguments into a dictionary, where each key is the argument name and each value is what was passed.

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

build_profile(name="Maya", age=17, city="Pune")

Received: {'name': 'Maya', 'age': 17, 'city': 'Pune'}
name: Maya
age: 17
city: Pune

def order_summary(customer, *items, **details):
    print("Customer:", customer)
    print("Items:", items)
    print("Details:", details)

order_summary("Riya", "book", "pen", gift_wrap=True, express=False)

Customer: Riya
Items: ('book', 'pen')
Details: {'gift_wrap': True, 'express': False}

Required Parameter Order

When a function definition mixes several parameter types, Python enforces a strict order: standard positional/default parameters first, then *args, then any keyword-only parameters, then **kwargs last.

def process(action, *args, verbose=False, **kwargs):
    print("Action:", action)
    print("Args:", args)
    print("Verbose:", verbose)
    print("Kwargs:", kwargs)

process("save", 1, 2, 3, verbose=True, path="/tmp")

Action: save
Args: (1, 2, 3)
Verbose: True
Kwargs: {'path': '/tmp'}

Unpacking Into a Call

The * and ** operators also work at the call site, in reverse: they unpack an existing list or dictionary into separate arguments automatically.

def add(a, b, c):
    return a + b + c

values = [10, 20, 30]
print(add(*values))

60

*values unpacks the list [10, 20, 30] into three separate positional arguments, exactly as if you had written add(10, 20, 30).

def describe_pet(species, name):
    print(f"{name} is a {species}.")

pet_info = {"species": "cat", "name": "Milo"}
describe_pet(**pet_info)

Milo is a cat.

**pet_info unpacks the dictionary into keyword arguments, matching species and name by key. The dictionary's keys must match the function's parameter names exactly.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Python offers a rich set of tools for passing arguments: plain positional arguments, default values for optional parameters, named keyword arguments, and the flexible *args/**kwargs for accepting a variable number of values.

Mastering these patterns lets you design functions that are both powerful and pleasant to call. Next, you will learn how Python decides which variables a function can actually see — variable scope.