Learning Python – Positional Arguments

Positional Arguments are the most basic and simplest type of parameters in Python functions, matched and passed based on positional order.

1. Basic Concepts

Positional arguments refer to:

• Parameters passed in the order defined during the function call

• The value of the parameter is determined by its position in the parameter list

• Must be passed in the correct order and quantity

2. Basic Syntax Example

def greet(name, message):  # name and message are positional arguments    print(f"{message}, {name}!")
greet("Alice", "Hello")  # Pass parameters in order

Output:

Hello, Alice!

3. Characteristics of Positional Arguments

1. Order Sensitive:

def divide(a, b):    return a / b
print(divide(10, 2))  # 5.0
print(divide(2, 10))  # 0.2 - Completely different results

2. Quantity Must Match:

def power(base, exponent):    return base ** exponent
# power(2)  # Error: missing 1 positional argument
# power(2, 3, 4)  # Error: too many positional arguments

3. Cannot Be Skipped:

def info(name, age, city):    print(f"{name}, {age} years old, from {city}")
# info("Alice", , "NY")  # Syntax error, cannot skip age

4. Best Practices for Positional Arguments

1. Place the most commonly used parameters first:

# Good design
def find_books(author, genre=None, year=None):    pass

2. Avoid too many positional arguments (usually no more than 3-4):

# Difficult to use design
def create_user(name, age, email, phone, address, gender, occupation):    pass
# Better design
def create_user(name, **user_info):    pass

3. Important parameters should be positional (forcing the caller to pass explicitly):

def save_document(filename, content, *, overwrite=False):    """filename and content must be explicitly passed"""    pass

4. Use type annotations in complex functions:

def calculate(    principal: float,     rate: float,     years: int) -> float:    return principal * (1 + rate) ** years

5. New Features of Positional Arguments in Python 3.8+

Python 3.8 introduced the <span>/</span> syntax, which enforces that certain parameters must be passed as positional arguments:

def create_user(username, /, email, *, api_key):    """username must be passed as a positional argument"""    pass
create_user("alice", email="[email protected]", api_key="123")
# create_user(username="alice", ...)  # Error: username cannot be a keyword argument

This design is commonly used for:

• Preventing API users from confusing parameter order

• Retaining flexibility for future modifications of parameter names

• When parameter names are not important but position is

Positional arguments are the foundation of the Python function parameter system, and understanding how they work is crucial for writing clear and maintainable functions. Proper use of positional arguments can make your API more intuitive and less prone to misuse.