Argument order rules in Python - Mini Project: Build & Apply

Argument order rules

📖 Scenario: Imagine you are creating a simple program to greet people with their name and age. You want to learn how to write functions with different types of arguments in the right order.

🎯 Goal: You will build a function that takes arguments in the correct order: positional, default, and keyword-only arguments. Then you will call this function correctly to print a greeting message.

📋 What You'll Learn

Create a function with one positional argument called name

Add one default argument called age with default value 30

Add one keyword-only argument called city without a default

Call the function with correct argument order and print the greeting

💡 Why This Matters

🌍 Real World

Functions with clear argument order are used in real programs to avoid confusion and bugs when many options are needed.

💼 Career

Understanding argument order is important for writing clean, maintainable code in any software development job.

1

Create the greeting function with positional and default arguments

Define a function called greet that takes one positional argument name and one default argument age set to 30. Inside the function, write a print statement that says: "Hello {name}, you are {age} years old."

Python

# Define the greet function with name and age
# Your code here

Hint

Remember, positional arguments come first, then default arguments with an equals sign.

2

Add a keyword-only argument called city

Modify the greet function to add a keyword-only argument called city after a * symbol. Inside the function, update the print statement to say: "Hello {name} from {city}, you are {age} years old."

Python

def greet(name, age=30, *):
    # Update the print statement
    # Your code here

Hint

Use * to mark the start of keyword-only arguments.

3

Call the greet function with correct argument order

Write a call to the greet function with name as "Alice", age as 25, and city as "Paris". Use positional arguments for name and age, and keyword argument for city.

Python

def greet(name, age=30, *, city):
    print(f"Hello {name} from {city}, you are {age} years old.")

# Call greet with name 'Alice', age 25, city 'Paris'
# Your code here

Hint

Remember to pass city as a keyword argument after the *.

4

Print the greeting message

Run the program and print the greeting message from the greet function call.

Python

def greet(name, age=30, *, city):
    print(f"Hello {name} from {city}, you are {age} years old.")

greet("Alice", 25, city="Paris")

# The greeting is printed by the function call above

Hint

The function call already prints the greeting. Just run the program.

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