Variable-length arguments (*args) in Python - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a function that accepts any number of arguments.

Python

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

Drag options to blanks, or click blank then click option'

A&names

Bnames

C**names

D*names

Attempts:

3 left

💡 Hint

Common Mistakes

Using ** instead of * for positional arguments.

Forgetting the asterisk and just writing the parameter name.

The *names syntax allows the function to accept any number of positional arguments as a tuple.

2fill in blank

medium

Complete the code to call the function with multiple arguments.

Python

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

greet([1])

Drag options to blanks, or click blank then click option'

A["Alice", "Bob", "Charlie"]

B"Alice", "Bob", "Charlie"

C{"Alice", "Bob", "Charlie"}

DAlice, Bob, Charlie

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a list or set instead of separate arguments.

Not using quotes around string arguments.

When calling a function with *args, pass multiple arguments separated by commas inside the parentheses.

3fill in blank

hard

Fix the error in the function definition to correctly accept variable-length arguments.

Python

def add_numbers([1]):
    total = 0
    for num in numbers:
        total += num
    return total

Drag options to blanks, or click blank then click option'

A*numbers

Bnumbers

C**numbers

D&numbers

Attempts:

3 left

💡 Hint

Common Mistakes

Using ** instead of *.

Not using any asterisk.

The function must use *numbers to accept any number of positional arguments as a tuple.

4fill in blank

hard

Fill both blanks to create a function that sums only positive numbers from variable arguments.

Python

def sum_positive([1]):
    return sum(num for num in numbers if num [2] 0)

Drag options to blanks, or click blank then click option'

A*numbers

B>

C<

Dnumbers

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > to filter positive numbers.

Not using * to accept variable arguments.

The function uses *numbers to accept variable arguments and sums only those greater than zero.

5fill in blank

hard

Fill all three blanks to create a function that returns a dictionary with word lengths for words longer than 3 characters.

Python

def word_lengths([1]):
    return [2]: len(word) for word in words if len(word) [3] 3 }

Drag options to blanks, or click blank then click option'

A*words

Bword

C>

Dwords

Attempts:

3 left

💡 Hint

Common Mistakes

Not using * to accept variable arguments.

Using parentheses instead of curly braces for dictionary comprehension.

Using < instead of > for filtering.

The function accepts variable words with *words and returns a dictionary comprehension filtering words longer than 3 characters.

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