Why different argument types are needed in Python - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function with positional and keyword arguments

What is the output of this Python code?

Python

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))
print(greet("Bob", greeting="Hi"))

A TypeError

B Hello, Alice!\nHello, Bob!

C Hi, Alice!\nHi, Bob!

D Hello, Alice!\nHi, Bob!

💡 Hint

Check how default values work for keyword arguments.

The function greet has a default value for the greeting argument. When calling greet("Alice"), it uses the default "Hello". When calling greet("Bob", greeting="Hi"), it uses the provided keyword argument "Hi".

❓ Predict Output

intermediate

Output of function with *args and **kwargs

What will this code print?

Python

def show_args(*args, **kwargs):
    print(f"Positional: {args}")
    print(f"Keyword: {kwargs}")

show_args(1, 2, a=3, b=4)

A Positional: [1, 2]\nKeyword: {'a': 3, 'b': 4}

B Positional: (1, 2)\nKeyword: {'a': 3, 'b': 4}

C Positional: (1, 2)\nKeyword: [('a', 3), ('b', 4)]

D TypeError

💡 Hint

Remember that *args collects positional arguments as a tuple, and **kwargs collects keyword arguments as a dictionary.

The *args parameter collects all positional arguments into a tuple. The **kwargs parameter collects all keyword arguments into a dictionary.

❓ Predict Output

advanced

Output of function with mutable default argument

What is the output of this code?

Python

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item('apple'))
print(add_item('banana'))

A ['apple']\n['apple', 'banana']

B ['apple']\n['banana']

C ['apple']\n[]

D TypeError

💡 Hint

Think about how default mutable arguments behave in Python functions.

The default list is created once when the function is defined. Each call without an explicit items argument uses the same list, so items accumulate.

❓ Predict Output

advanced

Output of function with argument unpacking

What will this code print?

Python

def multiply(x, y, z):
    return x * y * z

values = (2, 3, 4)
print(multiply(*values))

A 24

B TypeError

C 9

D None

💡 Hint

Look at how the tuple is unpacked into function arguments.

The * operator unpacks the tuple values into separate arguments for the function multiply. So multiply(2, 3, 4) returns 24.

❓ Predict Output

expert

Output of function with positional-only and keyword-only arguments

What is the output of this code?

Python

def func(a, b, /, c, d, *, e, f):
    return a + b + c + d + e + f

print(func(1, 2, 3, d=4, e=5, f=6))

A 15

B TypeError

C 21

D SyntaxError

💡 Hint

Understand how positional-only (/) and keyword-only (*) arguments work in Python 3.8+.

The parameters a and b are positional-only, so they must be passed positionally. c and d can be positional or keyword. e and f are keyword-only and must be passed by name. The call matches these rules, so the sum is 1+2+3+4+5+6=21.

Practice

1. Why do Python functions use different types of arguments like positional, default, *args, and **kwargs?

easy

A. To make the code run faster by limiting inputs

B. To allow functions to accept varying numbers and types of inputs flexibly

C. To force users to always provide all arguments

D. To prevent functions from being reused

Solution

1. Step 1: Understand argument types purpose

   Different argument types let functions accept inputs in flexible ways, like fixed, optional, or many arguments.

2. Step 2: Match flexibility with function use

   This flexibility helps reuse functions with different input needs without errors or extra code.

3. Final Answer:

   To allow functions to accept varying numbers and types of inputs flexibly -> Option B

4. Quick Check:

   Argument flexibility = To allow functions to accept varying numbers and types of inputs flexibly [OK]

Hint: Think: flexibility in inputs means different argument types [OK]

Common Mistakes:

• Thinking all arguments must always be provided
• Confusing argument types with performance improvements
• Believing argument types limit function reuse

2. Which of the following is the correct syntax to define a function that accepts any number of positional arguments?

easy

A. def func(**args):

B. def func(args*):

C. def func(args):

D. def func(*args):

Solution

1. Step 1: Recall syntax for variable positional arguments

   In Python, *args collects any number of positional arguments into a tuple.

2. Step 2: Identify correct syntax

   Only 'def func(*args):' correctly uses the * before args to accept multiple positional arguments.

3. Final Answer:

   def func(*args): -> Option D

4. Quick Check:

   *args syntax = def func(*args): [OK]

Hint: Remember *args collects extra positional arguments [OK]

Common Mistakes:

• Placing * after the argument name
• Using **args for positional arguments
• Omitting the * for variable arguments

3. What will be the output of this code?

def greet(name, greeting='Hello'):
    print(f"{greeting}, {name}!")

greet('Alice')
greet('Bob', 'Hi')

medium

A. Hello, Alice!\nHi, Bob!

B. Hello, Alice!\nHello, Bob!

C. Hi, Alice!\nHi, Bob!

D. Error because greeting is missing

Solution

1. Step 1: Understand default argument behavior

   The function greet has a default greeting 'Hello'. If no greeting is given, it uses 'Hello'.

2. Step 2: Trace function calls

   First call: greet('Alice') uses default greeting 'Hello'. Second call: greet('Bob', 'Hi') uses provided greeting 'Hi'.

3. Final Answer:

   Hello, Alice!\nHi, Bob! -> Option A

4. Quick Check:

   Default argument used when missing = Hello, Alice!\nHi, Bob! [OK]

Hint: Default arguments fill in missing values automatically [OK]

Common Mistakes:

• Assuming default arguments must always be provided
• Confusing positional and default argument order
• Expecting an error when default is missing

4. Identify the error in this function definition:

def add_numbers(a, b=5, *args, c):
    return a + b + sum(args) + c

medium

A. Cannot use *args and default arguments together

B. Missing return statement

C. Positional argument after *args without default is invalid

D. No error in the function definition

Solution

1. Step 1: Analyze argument order rules

   In Python, after *args, following arguments are keyword-only and can lack defaults (required keyword args). Defaults like b=5 before *args are allowed.

2. Step 2: Check argument 'c' position

   'c' is a required keyword-only argument after *args without a default value, which is valid syntax in Python 3. However, if the function is intended to be called without specifying 'c' as a keyword argument, it will cause a TypeError. The error is not in syntax but in usage.

3. Final Answer:

   Positional argument after *args without default is invalid -> Option C

4. Quick Check:

   Keyword-only arguments without default must be provided when calling the function [OK]

Hint: Arguments after *args are keyword-only and must be provided if no default [OK]

Common Mistakes:

• Ignoring keyword-only argument rules
• Thinking *args forbids any following arguments
• Assuming missing return causes syntax error

5. You want to write a function that accepts a fixed first argument, any number of extra positional arguments, and any number of keyword arguments. Which function header is correct?

hard

A. def func(first, *args, **kwargs):

B. def func(*args, first, **kwargs):

C. def func(**kwargs, *args, first):

D. def func(first, **kwargs, *args):

Solution

1. Step 1: Recall argument order in function definitions

   Python requires positional arguments first, then *args, then keyword-only arguments, then **kwargs last.

2. Step 2: Match correct order

   def func(first, *args, **kwargs): follows correct order: fixed argument 'first', then *args, then **kwargs.

3. Final Answer:

   def func(first, *args, **kwargs): -> Option A

4. Quick Check:

   Correct argument order = def func(first, *args, **kwargs): [OK]

Hint: Order: fixed, *args, then **kwargs in function header [OK]

Common Mistakes:

• Placing *args after **kwargs
• Putting keyword-only arguments before *args incorrectly
• Mixing order of *args and **kwargs