Variable-length arguments (*args) in Python - Mini Project: Build & Apply

Using Variable-length Arguments (*args) in Python

📖 Scenario: Imagine you are creating a simple calculator function that can add any number of numbers given to it. Sometimes you want to add two numbers, sometimes five, or even ten. You want to write one function that can handle all these cases easily.

🎯 Goal: Build a Python function called add_numbers that uses variable-length arguments (*args) to add any amount of numbers given to it and returns the total sum.

📋 What You'll Learn

Create a function named add_numbers that accepts variable-length arguments using *args.

Inside the function, calculate the sum of all numbers passed in *args.

Return the total sum from the function.

Call the function with different numbers of arguments and print the results.

💡 Why This Matters

🌍 Real World

Functions with variable-length arguments are useful when you don't know how many inputs users will provide, like adding items to a shopping cart or calculating totals.

💼 Career

Understanding <code>*args</code> is important for writing flexible and reusable code, a key skill for software developers and data analysts.

1

Create the function add_numbers with *args

Write a function called add_numbers that accepts variable-length arguments using *args. Inside the function, create a variable called total and set it to 0.

Python

def add_numbers(*args):
    # Create a variable called total and set it to 0
    # Your code here

Hint

Use *args in the function definition to accept any number of arguments.

2

Add all numbers in *args using a for loop

Inside the add_numbers function, use a for loop with the variable number to iterate over args. Add each number to the total variable.

Python

def add_numbers(*args):
    total = 0
    # Use a for loop with variable number to add each number in args to total
    # Your code here

Hint

Use for number in args: to loop through all numbers passed to the function.

3

Return the total sum from the function

Add a return statement at the end of the add_numbers function to return the total variable.

Python

def add_numbers(*args):
    total = 0
    for number in args:
        total += number
    # Return the total sum
    # Your code here

Hint

Use return total to send the result back when the function is called.

4

Call the function with different numbers and print the results

Call the add_numbers function with these arguments and print the results exactly as shown:
print(add_numbers(1, 2))
print(add_numbers(5, 10, 15))
print(add_numbers(3, 4, 5, 6))

Python

def add_numbers(*args):
    total = 0
    for number in args:
        total += number
    return total

# Call the function with different numbers and print the results
# Your code here

Hint

Use print(add_numbers(...)) with the exact numbers given to see the sums.

Practice

1. What does *args do in a Python function?

easy

A. Allows the function to accept any number of extra positional arguments

B. Allows the function to accept only keyword arguments

C. Restricts the function to accept exactly one argument

D. Makes the function return multiple values

Solution

1. Step 1: Understand the role of *args

   *args collects extra positional arguments passed to a function into a tuple.

2. Step 2: Compare options with this behavior

   Only Allows the function to accept any number of extra positional arguments correctly describes this behavior; others describe different concepts.

3. Final Answer:

   Allows the function to accept any number of extra positional arguments -> Option A

4. Quick Check:

   *args = flexible positional inputs [OK]

Hint: Remember *args packs extra positions into a tuple [OK]

Common Mistakes:

• Confusing *args with **kwargs
• Thinking *args limits arguments
• Assuming *args returns multiple values

2. Which of the following is the correct syntax to define a function that accepts variable-length positional arguments?

easy

A. def func(args*):

B. def func(*args):

C. def func(**args):

D. def func(args**):

Solution

1. Step 1: Recall the syntax for variable-length positional arguments

   The correct syntax uses an asterisk before the parameter name: *args.

2. Step 2: Match options with correct syntax

   def func(*args): matches the correct syntax; others are invalid or for different purposes.

3. Final Answer:

   def func(*args): -> Option B

4. Quick Check:

   Star before name = variable positional args [OK]

Hint: Use * before parameter name for variable positional args [OK]

Common Mistakes:

• Using **args instead of *args
• Placing * after the parameter name
• Confusing syntax with keyword arguments

3. What is the output of the following code?

def add_numbers(*args):
    return sum(args)

print(add_numbers(1, 2, 3, 4))

medium

A. 10

B. 1234

C. TypeError

D. None

Solution

1. Step 1: Understand how *args works in the function

   The function collects all arguments into a tuple and sums them using sum().

2. Step 2: Calculate the sum of the arguments

   1 + 2 + 3 + 4 = 10, so the function returns 10.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Sum of (1,2,3,4) = 10 [OK]

Hint: Sum all *args values to get total [OK]

Common Mistakes:

• Concatenating numbers as strings
• Expecting a TypeError for multiple args
• Forgetting that *args is a tuple

4. Identify the error in this function definition:

def greet(*names):
    for name in names
        print(f"Hello, {name}!")

medium

A. print statement syntax error

B. Incorrect use of *args syntax

C. Missing colon after for loop

D. Function cannot have *args

Solution

1. Step 1: Check the for loop syntax

   The for loop line is missing a colon at the end, which is required in Python.

2. Step 2: Verify other parts of the function

   The *names syntax and print statement are correct; the function can have *args.

3. Final Answer:

   Missing colon after for loop -> Option C

4. Quick Check:

   For loops need a colon [:] [OK]

Hint: Check colons after for, if, while statements [OK]

Common Mistakes:

• Forgetting colon after for loop
• Confusing *args with **kwargs
• Incorrect indentation

5. How can you write a function that accepts any number of positional arguments and returns a list of their squares?

hard

A. def squares(args): return [x**2 for x in args]

B. def squares(*args): return x**2 for x in args

C. def squares(**args): return [x**2 for x in args]

D. def squares(*args): return [x**2 for x in args]

Solution

1. Step 1: Use *args to accept variable positional arguments

   The function parameter must be *args to accept any number of positional arguments.

2. Step 2: Return a list of squares using list comprehension

   Use [x**2 for x in args] to square each argument and collect results in a list.

3. Final Answer:

   def squares(*args): return [x**2 for x in args] -> Option D

4. Quick Check:

   Use *args and list comprehension for squares [OK]

Hint: Use *args and list comprehension for flexible squares [OK]

Common Mistakes:

• Using **args instead of *args
• Forgetting to return a list
• Incorrect comprehension syntax