Positional arguments in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What are positional arguments in Python functions?

Positional arguments are values passed to a function in the exact order the function expects them. The position of each argument matters and matches the function's parameters.

beginner

How does Python match positional arguments to parameters?

Python assigns each positional argument to the function parameter in the same order they are given. The first argument goes to the first parameter, the second to the second, and so on.

beginner

What happens if you change the order of positional arguments when calling a function?

Changing the order of positional arguments changes which parameter each value is assigned to. This can cause unexpected results or errors if the order does not match the function's design.

beginner

Example: def greet(name, age): print(f"Hello {name}, you are {age} years old.")
Call greet('Alice', 30). What is the output?

The output is: Hello Alice, you are 30 years old.
Because 'Alice' is assigned to name and 30 to age by position.

intermediate

Can you mix positional and keyword arguments in a function call?

Yes, you can mix them. Positional arguments must come first, then keyword arguments. For example: func(1, 2, c=3).

What does Python use to assign values to parameters when calling a function with positional arguments?

A The order of the arguments

B The names of the arguments

C The data type of the arguments

D The size of the arguments

Python assigns positional arguments to parameters based on the order they are given.

What will happen if you call a function with fewer positional arguments than parameters?

A Python will swap arguments automatically

B Python will fill missing arguments with zeros

C Python will ignore missing parameters

D Python will raise an error

Python requires all positional parameters to be given values unless they have default values; otherwise, it raises a TypeError.

Which of these calls uses positional arguments correctly for def add(x, y): return x + y?

A add(5, y=3)

B add(5, 3)

C add(y=3, x=5)

D add(x=5, y=3)

add(5, 3) uses positional arguments in the correct order.

If a function is defined as def f(a, b, c):, which call is invalid?

A f(1, 2, 3, 4)

B f(1, 2, c=3)

C f(1, 2, 3)

D f(a=1, b=2, c=3)

Calling with more arguments than parameters causes an error.

Can you use keyword arguments before positional arguments in a function call?

A Yes, always

B Only if the function has default parameters

C No, positional arguments must come first

D Only in Python 3.12+

Positional arguments must come before keyword arguments in a function call.

Explain what positional arguments are and why their order matters in Python functions.

Think about how you give directions in a specific order.

Describe what happens if you swap the order of positional arguments when calling a function.

Imagine mixing up ingredients in a recipe.

Practice

1.

What are positional arguments in Python functions?

easy

A. Arguments passed in the exact order the function expects

B. Arguments passed with their names explicitly stated

C. Arguments that have default values

D. Arguments passed as a list or tuple

Solution

1. Step 1: Understand argument passing

   Positional arguments are passed to a function in the order the function defines its parameters.

2. Step 2: Differentiate from other argument types

   Unlike keyword arguments, positional arguments do not specify parameter names explicitly.

3. Final Answer:

   Arguments passed in the exact order the function expects -> Option A

4. Quick Check:

   Positional arguments = ordered values [OK]

Hint: Remember: order matters in positional arguments [OK]

Common Mistakes:

• Confusing positional with keyword arguments
• Thinking default values are positional arguments
• Assuming order doesn't matter

2.

Which of the following function calls uses positional arguments correctly?

def greet(name, age):
    return f"Hello {name}, you are {age} years old."

easy

A. greet(age=30, name='Alice')

B. greet(30, name='Alice')

C. greet('Alice', name=30)

D. greet('Alice', 30)

Solution

1. Step 1: Identify positional argument usage

   Positional arguments are passed without naming, in the order parameters are defined.

2. Step 2: Check each option

   greet('Alice', 30) passes 'Alice' then 30 matching (name, age) order correctly.

3. Final Answer:

   greet('Alice', 30) -> Option D

4. Quick Check:

   Positional call = values in order [OK]

Hint: Positional means no names, just order [OK]

Common Mistakes:

• Mixing keyword and positional arguments incorrectly
• Passing arguments in wrong order
• Using parameter names with positional arguments

3.

What is the output of this code?

def multiply(a, b):
    return a * b

result = multiply(3, 4)
print(result)

medium

A. 7

B. 34

C. 12

D. Error

Solution

1. Step 1: Understand function call with positional arguments

   Arguments 3 and 4 are passed as a and b respectively.

2. Step 2: Calculate the return value

   3 multiplied by 4 equals 12, so the function returns 12.

3. Final Answer:

   12 -> Option C

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply arguments in order given [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Confusing argument order

4.

Find the error in this function call:

def divide(x, y):
    return x / y

print(divide(10))

medium

A. Missing one positional argument in the call

B. Division by zero error

C. Syntax error in function definition

D. No error, prints 10

Solution

1. Step 1: Check function parameters and call

   Function divide expects two positional arguments: x and y.

2. Step 2: Analyze the call with one argument

   Calling divide(10) provides only one argument, missing the second required positional argument y.

3. Final Answer:

   Missing one positional argument in the call -> Option A

4. Quick Check:

   Function needs 2 args, got 1 [OK]

Hint: Count arguments to match parameters [OK]

Common Mistakes:

• Assuming missing arguments default to zero
• Thinking one argument is enough
• Ignoring error messages

5.

Given this function:

def create_greeting(greeting, name, punctuation):
    return f"{greeting}, {name}{punctuation}"

Which call correctly uses positional arguments to produce Hello, Bob!?

hard

A. create_greeting('Bob', 'Hello', '!')

B. create_greeting('Hello', 'Bob', '!')

C. create_greeting(name='Hello', punctuation='!', 'Bob')

D. create_greeting(name='Bob', greeting='Hello', punctuation='!')

Solution

1. Step 1: Identify parameter order

   The function parameters are greeting, name, punctuation in that order.

2. Step 2: Match arguments to parameters positionally

   create_greeting('Hello', 'Bob', '!') passes 'Hello' to greeting, 'Bob' to name, and '!' to punctuation, producing the desired output.

3. Final Answer:

   create_greeting('Hello', 'Bob', '!') -> Option B

4. Quick Check:

   Order matches parameters for correct output [OK]

Hint: Match argument order to parameter order exactly [OK]

Common Mistakes:

• Swapping argument order
• Mixing positional and keyword incorrectly
• Assuming keyword arguments are positional