Argument order rules in Python - Step-by-Step Execution

Concept Flow - Argument order rules

Define function with parameters

↓

Call function with arguments

↓

Match arguments to parameters

↓

Positional

↓

Execute function body with matched values

This flow shows how Python matches arguments to function parameters by order: positional first, then keyword, and uses defaults if needed.

Execution Sample

Python

def greet(name, age=30, city='NY'):
    print(f"Name: {name}, Age: {age}, City: {city}")

greet('Alice', city='LA')

Calls greet with one positional and one keyword argument, showing how arguments match parameters.

Execution Table

Step	Parameter	Argument Provided	Value Assigned	Reason
1	name	'Alice'	'Alice'	Positional argument matches first parameter
2	age	None	30	No argument given, uses default value
3	city	'LA'	'LA'	Keyword argument overrides default
4	Function body	N/A	Prints: Name: Alice, Age: 30, City: LA	Execution with assigned values

💡 All parameters matched by positional, keyword, or default; function executes.

Variable Tracker

Parameter	Initial	After Assignment	Final
name	None	'Alice'	'Alice'
age	30 (default)	30	30
city	'NY' (default)	'LA'	'LA'

Key Moments - 3 Insights

Why can't we put a positional argument after a keyword argument in the call?

Because Python assigns positional arguments first in order, then keyword arguments. The execution_table shows 'name' assigned positionally first, then 'city' by keyword. Placing positional after keyword causes confusion in matching.

What happens if we omit an argument with a default value?

The default value is used. In the execution_table, 'age' has no argument provided, so it uses the default 30.

Can keyword arguments override positional arguments?

No, positional arguments are assigned first by order. Keyword arguments can only override parameters not already assigned positionally, as shown by 'city' in the table.

Visual Quiz - 3 Questions

Look at the execution_table, what value is assigned to 'age' parameter?

A 'LA'

B 'Alice'

C 30

D None

💡 Hint

Check the row where parameter is 'age' and see the 'Value Assigned' column.

At which step does the keyword argument get assigned?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look for the row where 'Argument Provided' is a keyword argument like 'city'.

If we call greet('Bob', 25), what value will 'city' have?

A 'NY'

B 'LA'

C 25

D 'Bob'

💡 Hint

Refer to variable_tracker for default values and how missing arguments use defaults.

Concept Snapshot

def func(pos1, pos2=default, *, kw1, kw2=default):
- Positional args fill parameters in order
- Keyword args assigned by name after positionals
- Default values used if no argument given
- Positional args cannot follow keyword args in call
- Mixing order correctly is required to avoid errors

Full Transcript

This visual trace shows how Python matches function call arguments to parameters. First, positional arguments are assigned in order to parameters. Then keyword arguments assign by name, overriding defaults if given. Parameters with default values use those defaults if no argument is provided. The example function greet has three parameters: name (required), age (default 30), and city (default 'NY'). The call greet('Alice', city='LA') assigns 'Alice' to name positionally, uses default 30 for age, and overrides city with 'LA' keyword. The execution table tracks each step of assignment and the final print output. Key points include that positional arguments must come before keyword arguments in calls, default values fill missing arguments, and keyword arguments cannot override positional assignments. The quiz tests understanding of these rules by referencing the execution steps and variable states.

Practice

1.

Which of the following correctly describes the order of arguments in a Python function definition?

easy

A. Positional-only, positional-or-keyword, keyword-only

B. Keyword-only, positional-only, positional-or-keyword

C. Positional-or-keyword, keyword-only, positional-only

D. Positional-or-keyword, positional-only, keyword-only

Solution

1. Step 1: Recall argument order rules

   Python functions must define arguments in the order: positional-only, positional-or-keyword, then keyword-only.

2. Step 2: Match the correct order

   Positional-only, positional-or-keyword, keyword-only matches this exact order, others do not.

3. Final Answer:

   Positional-only, positional-or-keyword, keyword-only -> Option A

4. Quick Check:

   Argument order = Positional-only, positional-or-keyword, keyword-only [OK]

Hint: Remember: positional-only first, then normal, then keyword-only [OK]

Common Mistakes:

• Confusing keyword-only and positional-only order
• Thinking positional-or-keyword comes first
• Ignoring positional-only arguments

2.

Which of the following function definitions is syntactically correct in Python?

def example(a, /, b, *, c):
    pass

easy

A. def example(a, /, b, *, c): pass

B. def example(a, b, *, /, c): pass

C. def example(a, *, b, /, c): pass

D. def example(/, a, b, *, c): pass

Solution

1. Step 1: Understand syntax for positional-only and keyword-only

   The slash (/) marks positional-only arguments before it, and the asterisk (*) marks keyword-only arguments after it.

2. Step 2: Check each option's order

   def example(a, /, b, *, c): pass correctly places a before / (positional-only), b as positional-or-keyword, and c after * (keyword-only). Others have invalid order or misplaced / and *.

3. Final Answer:

   def example(a, /, b, *, c): pass -> Option A

4. Quick Check:

   Syntax with / and * correct = def example(a, /, b, *, c): pass [OK]

Hint: Slash (/) before positional-only, star (*) before keyword-only [OK]

Common Mistakes:

• Placing / after positional-or-keyword arguments
• Putting * before /
• Using / as a standalone argument

3.

What is the output of this code?

def func(a, /, b, *, c):
    print(a, b, c)

func(1, 2, c=3)

medium

A. TypeError: missing required keyword-only argument 'c'

B. 1 2 3

C. TypeError: positional argument after keyword argument

D. SyntaxError

Solution

1. Step 1: Understand argument passing

   a is positional-only, so must be passed by position (1). b is positional-or-keyword, passed by position (2). c is keyword-only, passed as c=3.

2. Step 2: Check function call validity and output

   All arguments are passed correctly. The print outputs the values: 1 2 3.

3. Final Answer:

   1 2 3 -> Option B

4. Quick Check:

   func(1, 2, c=3) prints 1 2 3 [OK]

Hint: Positional-only args by position, keyword-only by name [OK]

Common Mistakes:

• Passing positional-only argument by keyword
• Passing keyword-only argument positionally
• Confusing argument order in call

4.

Identify the error in this function call:

def f(x, /, y, *, z):
    return x + y + z

f(x=1, y=2, z=3)

medium

A. No error, returns 6

B. TypeError: missing required positional argument y

C. SyntaxError: invalid function call

D. TypeError: x is positional-only and cannot be passed as keyword

Solution

1. Step 1: Check argument types in definition

   x is positional-only (before /), y is positional-or-keyword, z is keyword-only (after *).

2. Step 2: Analyze function call

   Calling f(x=1, y=2, z=3) tries to pass x by keyword, which is not allowed for positional-only arguments, causing a TypeError.

3. Final Answer:

   TypeError: x is positional-only and cannot be passed as keyword -> Option D

4. Quick Check:

   Positional-only args cannot be keyword = TypeError [OK]

Hint: Positional-only args can't be named in calls [OK]

Common Mistakes:

• Passing positional-only argument by keyword
• Thinking all arguments can be named
• Ignoring the / marker meaning

5.

You want to define a function that takes exactly two positional-only arguments, one positional-or-keyword argument, and two keyword-only arguments. Which of these definitions is correct?

1. def func(a, b, /, c, *, d, e): pass
2. def func(a, /, b, c, *, d, e): pass
3. def func(a, b, c, /, *, d, e): pass
4. def func(a, b, /, *, c, d, e): pass

hard

A. Definition 3

B. Definition 2

C. Definition 1

D. Definition 4

Solution

1. Step 1: Identify argument categories

   Two positional-only args: before / (a, b). One positional-or-keyword: after / and before * (c). Two keyword-only: after * (d, e).

2. Step 2: Check each definition

   Definition 1 matches this order exactly: a, b before /, c after /, d, e after *. Others have wrong placement of / or * or argument counts.

3. Final Answer:

   Definition 1 -> Option C

4. Quick Check:

   Two positional-only, one normal, two keyword-only = Definition 1 [OK]

Hint: Two positional-only before /, one normal after, two keyword-only after * [OK]

Common Mistakes:

• Placing too many args before or after / or *
• Miscounting positional-only arguments
• Confusing keyword-only with positional-or-keyword