Function Arguments

There are several ways to pass arguments to a function: positional arguments, keyword arguments, and default arguments.

Positional Arguments

Positional arguments are passed based on their position (order) in the function call. They must be provided in the same order as the parameters:

1
def describe_pet(animal_type, pet_name):
2
    print(f"I have a {animal_type} named {pet_name}.")
3

4
describe_pet("dog", "Buddy")      # I have a dog named Buddy.
5
describe_pet("cat", "Whiskers")  # I have a cat named Whiskers.

The order matters! Swapping the arguments will produce incorrect results:

1
describe_pet("Buddy", "dog")  # I have a Buddy named dog. (Wrong!)

Keyword Arguments

We can also have keyword arguments, where the user can supply key=value. The order of the arguments does not matter:

1
def greeting(firstname, lastname, age):
2
    print(f"Welcome {firstname} {lastname}, you are {age} years old!")
3

4
greeting(age=10, firstname="Alice", lastname="Brown")
5
# Welcome Alice Brown, you are 10 years old!

Mixing Positional and Keyword Arguments

You can mix positional and keyword arguments, but positional arguments must come before keyword arguments:

1
def describe_pet(animal_type, pet_name, age):
2
    print(f"I have a {age}-year-old {animal_type} named {pet_name}.")
3

4
describe_pet("dog", pet_name="Buddy", age=5)
5
describe_pet("cat", age=3, pet_name="Whiskers")

Warning
You cannot use a positional argument after a keyword argument:

1
describe_pet(animal_type="dog", "Buddy", age=5)  # SyntaxError

Default Arguments

A default argument in a function is an argument in which a programmer is not required to specify. If it wasn’t specified, then this argument is given a default value.

Any number of arguments in a function can have a default value. But once we have a default argument, all the arguments to its right must also have default values. This means to say, non-default arguments cannot follow default arguments.

1
def greet(name, msg="Good morning!"):
2
    print("Hello", name + ', ' + msg)
3

4
greet("Jana")
5
# Hello Jana, Good morning!
6

7
greet("Sally", "How do you do?")
8
# Hello Sally, How do you do?

Multiple Arguments

Functions can accept any number of positional or keyword arguments using special syntax:

Arbitrary Positional Arguments (`*args`)

Python supports arbitrary arguments by appending one asterisk before the argument name in the function definition. Then all of the passed values will be stored in a tuple:

1
def sum_numbers(*args):
2
    total = 0
3
    for i in args:
4
        total += i
5
    return total
6

7
print(sum_numbers(1, 2, 3, 4))  # 10

Arbitrary Keyword Arguments (`**kwargs`)

If we do not know how many keyword arguments the user would pass, we could add two asterisks before the variable name in the function definition. Then all of the passed keyword arguments will be stored in a dictionary:

1
def log_message(message, **kwargs):
2
    print(f"Log: {message}")
3
    if kwargs:
4
        print("Additional metadata")
5
        for key, value in kwargs.items():
6
            print(f"{key}: {value}")
7

8
log_message("Error occurred", severity="high", timestamp="2023-01-05 10:30:00")
9
# Log: Error occurred
10
# Additional metadata
11
# severity: high
12
# timestamp: 2023-01-05 10:30:00
13

14
log_message("User logged in", user_id=123, ip_address="192.168.0.1")
15
# Log: User logged in
16
# Additional metadata
17
# user_id: 123
18
# ip_address: 192.168.0.1

Combining `*args` and `**kwargs`

You can use both together, but *args must come before **kwargs:

1
def function(*args, **kwargs):
2
    print("Positional:", args)
3
    print("Keyword:", kwargs)
4

5
function(1, 2, 3, name="Alice", age=25)
6
# Positional: (1, 2, 3)
7
# Keyword: {'name': 'Alice', 'age': 25}

Argument Unpacking

You can unpack sequences and dictionaries when calling functions:

1
def greet(name, age, city):
2
    print(f"{name}, {age}, from {city}")
3

4
person = ("Alice", 25, "New York")
5
greet(*person)  # Unpacking tuple
6

7
info = {"name": "Bob", "age": 30, "city": "Boston"}
8
greet(**info)  # Unpacking dictionary

Position-Only Arguments

We can force the user to enter positional-only arguments instead of keyword arguments by listing the positional arguments first, then add a / at the end:

1
def test(x, y, /, z, t=0):
2
    print(x, y, z, t)
3

4
test(1, 2, 3, 4)        # 1 2 3 4
5
test(1, 2, 3)           # 1 2 3 0
6
test(1, 2, t=4, z=3)    # 1 2 3 4
7
test(y=1, x=2, z=3, t=4)  # TypeError
8
test(t=1, z=2, x=3, y=4)  # TypeError
9
test(x=1, y=2, z=3, t=4)  # TypeError

If all arguments are position-only:

1
def test(x, y, /):
2
    print(x, y)
3

4
test(1, 2)  # 1 2

Keyword-Only Arguments

We can force the user to enter keyword-only arguments instead of positional arguments by adding an asterisk, followed by the arguments:

1
def test(x, y, *, z, t):
2
    print(x, y, z, t)
3

4
test(1, 2, z=3, t=4)    # 1 2 3 4
5
test(1, 2, t=4, z=3)    # 1 2 3 4
6
test(x=1, y=2, z=3, t=4)  # 1 2 3 4
7
test(1, 2, 3, 4)        # TypeError

If all arguments are keyword-only:

1
def test(*, z, t):
2
    print(z, t)
3

4
test(z=3, t=4)  # 3 4
5
test(t=4, z=3)  # 3 4

Combining Position-Only and Keyword-Only Arguments

We can combine positional-only and keyword-only arguments by having the / and * in the argument list. Any argument before the / is positional-only. Any argument after the * is keyword-only. The / is always before the * in the argument list:

1
def test(x, y, /, *, z, t):
2
    print(x, y, z, t)
3

4
test(1, 2, z=3, t=4)    # 1 2 3 4
5
test(1, 2, t=4, z=3)    # 1 2 3 4

Default Values with Argument Types

You can combine default values with position-only and keyword-only arguments:

1
def calculate(
2
    x, y,                    # Position-only, required
3
    /,
4
    operation="add",         # Regular with default
5
    *,
6
    round_result=False       # Keyword-only with default
7
):
8
    if operation == "add":
9
        result = x + y
10
    elif operation == "multiply":
11
        result = x * y
12
    else:
13
        result = x - y
14

15
    if round_result:
16
        return round(result)
17
    return result
18

19
print(calculate(5, 3))                           # 8
20
print(calculate(5, 3, "multiply"))               # 15
21
print(calculate(5, 3, round_result=True))         # 8
22
print(calculate(5, 3, "multiply", round_result=True))  # 15

Real-World Examples

Many built-in functions use these patterns:

1
def process_data(
2
    data,                    # Position-only: the main data
3
    /,
4
    format="json",          # Regular: common option
5
    *,
6
    validate=True,          # Keyword-only: advanced option
7
    cache=False,            # Keyword-only: advanced option
8
    timeout=30              # Keyword-only: advanced option
9
):
10
    """Process data with various options"""
11
    # Implementation here
12
    pass
13

14
# Clear and explicit calls
15
process_data(my_data)
16
process_data(my_data, format="xml")
17
process_data(my_data, format="json", validate=False, cache=True)

Exercises

Exercise 1: Default Arguments

Write a function called greet that takes a name and an optional greeting message. If no message is provided, it should default to “Good morning!”. Call it with and without the message argument.

Answer:

1
def greet(name, msg="Good morning!"):
2
    print("Hello", name + ', ' + msg)
3

4
greet("Jana")
5
greet("Sally", "How do you do?")

Exercise 2: Keyword Arguments

Write a function called create_profile that takes firstname, lastname, and age as parameters. Call it using keyword arguments in a different order than the parameter definition.

Answer:

1
def create_profile(firstname, lastname, age):
2
    print(f"{firstname} {lastname}, age {age}")
3

4
create_profile(age=25, lastname="Smith", firstname="John")

Exercise 3: Arbitrary Arguments (*args)

Write a function called calculate_average that takes any number of numbers using *args and returns their average. Read the number of values first, then read that many numbers.

Answer:

1
def calculate_average(*args):
2
    if len(args) == 0:
3
        return 0
4
    return sum(args) / len(args)
5

6
n = int(input())
7
numbers = []
8
for i in range(n):
9
    numbers.append(int(input()))
10

11
result = calculate_average(*numbers)
12
print(result)

Exercise 4: Arbitrary Keyword Arguments (**kwargs)

Write a function called print_info that takes a required title parameter and any number of keyword arguments. Print the title, then print all keyword arguments as “key: value” pairs.

Answer:

1
def print_info(title, **kwargs):
2
    print(f"Title: {title}")
3
    for key, value in kwargs.items():
4
        print(f"{key}: {value}")
5

6
print_info("User Profile", name="Alice", age=25, city="New York")

Exercise 5: Mixing Argument Types

What will be the output of the following code?

1
def test(a, b=2, *args, **kwargs):
2
    print(f"a={a}, b={b}")
3
    print(f"args={args}")
4
    print(f"kwargs={kwargs}")
5

6
test(1, 3, 4, 5, x=10, y=20)

Answer:

1
a=1, b=3
2
args=(4, 5)
3
kwargs={'x': 10, 'y': 20}

Exercise 6: Position-Only Arguments

Write a function called divide that takes two position-only arguments x and y, and returns x / y. Read two numbers from input and call the function with positional arguments.

Answer:

1
def divide(x, y, /):
2
    return x / y
3

4
x = int(input())
5
y = int(input())
6
result = divide(x, y)
7
print(result)

Exercise 7: Keyword-Only Arguments

Write a function called create_user that takes username as a regular argument, and email and age as keyword-only arguments. Call it correctly and incorrectly.

Answer:

1
def create_user(username, *, email, age):
2
    print(f"User: {username}, Email: {email}, Age: {age}")
3

4
create_user("alice", email="alice@example.com", age=25) # Correct
5

6
# create_user("alice", "alice@example.com", 25) # TypeError

Exercise 8: Combining Position-Only and Keyword-Only

Write a function called calculate that has two position-only arguments x and y, and two keyword-only arguments operation (default “add”) and round_result (default False). The function should perform the operation and optionally round the result.

Answer:

1
def calculate(x, y, /, *, operation="add", round_result=False):
2
    if operation == "add":
3
        result = x + y
4
    elif operation == "multiply":
5
        result = x * y
6
    else:
7
        result = x - y
8

9
    if round_result:
10
        return round(result)
11
    return result
12

13
print(calculate(5, 3, operation="multiply", round_result=True)) # 15

Exercise 9: Understanding Argument Order

What will happen when we try to call this function? Explain why.

1
def test(x, y, /, z, *, w):
2
    print(x, y, z, w)
3

4
test(1, 2, 3, w=4) # Will this work?
5
test(1, 2, z=3, w=4) # Will this work?
6
test(x=1, y=2, z=3, w=4) # Will this work?

Answer:

1
test(1, 2, 3, w=4)  # Works: 1 2 3 4
2
test(1, 2, z=3, w=4)  # Works: 1 2 3 4
3
test(x=1, y=2, z=3, w=4)  # TypeError: x and y are position-only

Function Arguments

Table of Contents

Table of Contents

Course Progress

Function Arguments

Positional Arguments

Keyword Arguments

Mixing Positional and Keyword Arguments

Default Arguments

Multiple Arguments

Arbitrary Positional Arguments (`*args`)

Arbitrary Keyword Arguments (`**kwargs`)

Combining `*args` and `**kwargs`

Argument Unpacking

Position-Only Arguments

Keyword-Only Arguments

Combining Position-Only and Keyword-Only Arguments

Default Values with Argument Types

Real-World Examples

Exercises

Exercise 1: Default Arguments

Exercise 2: Keyword Arguments

Exercise 3: Arbitrary Arguments (*args)

Calculate Average with *args

Exercise 4: Arbitrary Keyword Arguments (**kwargs)

Exercise 5: Mixing Argument Types

Exercise 6: Position-Only Arguments

Position-Only Arguments

Exercise 7: Keyword-Only Arguments

Exercise 8: Combining Position-Only and Keyword-Only

Exercise 9: Understanding Argument Order

Course Progress