Python supports five key types of function parameters. Let’s look at each parameter type and discuss the specific rules on how they work and when to use them. We’ll examine each with examples, focusing on real-world applications.

The Five Types of Function Parameters

1. Positional-Only Parameters (/)
2. Positional-Or-Keyword Parameters (default)
3. Keyword-Only Parameters (*)
4. Variable-Length Positional Arguments (*args)
5. Variable-Length Keyword Arguments (**kwargs)

1. Positional-Only Parameters

Positional-only parameters are defined using the / symbol in the function signature. These parameters must be passed by their position when calling the function. You cannot use their names as keywords.

Why Use Positional-Only Parameters?

• They enforce simplicity, especially in functions where parameter names don’t add value.
• They prevent unintended behavior caused by keyword arguments.

Example: A Simple Discount Calculator

def calculate_discount(price, discount_rate, /):
    """Calculate the discounted price given a price and a discount rate."""
    return price - (price * discount_rate)

# Correct usage
print(calculate_discount(100, 0.2))  # Output: 80.0

# Incorrect usage (will raise a TypeError)
# print(calculate_discount(price=100, discount_rate=0.2))

Explanation:

• The / in the function signature specifies that price and discount_rate can only be passed as positional arguments.
• If you try to pass them as keyword arguments (e.g., price=100), Python will raise a TypeError.

Real-World Scenario: You might use positional-only parameters when creating utility functions like math operations or logging, where the parameter names don’t contribute to clarity.

2. Positional-Or-Keyword Parameters

By default, Python allows you to pass arguments to functions either by position or by name. This is the most commonly used parameter type.

Example: User Registration Function

def register_user(username, email, is_active=True):
    """Register a new user with an optional active status."""
    return {
        "username": username,
        "email": email,
        "is_active": is_active,
    }

# Passing arguments by position
print(register_user("johndoe", "john@example.com"))

# Passing arguments by keyword
print(register_user(username="janedoe", email="jane@example.com", is_active=False))

Explanation:

• You can pass username and email either by position ("johndoe", "john@example.com") or by keyword (username="janedoe").
• The is_active parameter has a default value (True), so it’s optional unless explicitly provided.

Real-World Scenario: Functions like these are used for creating objects or configuring settings, where default values make the function easier to use.

3. Keyword-Only Parameters

Keyword-only parameters are defined after a * in the function signature. These parameters must be passed by name, ensuring clarity.

Example: Scheduling a Meeting

def schedule_meeting(*, day, time):
    """Schedule a meeting with specific day and time."""
    return f"Meeting scheduled on {day} at {time}."

# Correct usage
print(schedule_meeting(day="Monday", time="2 PM"))

# Incorrect usage (will raise a TypeError)
# print(schedule_meeting("Monday", "2 PM"))

Explanation:

• The * enforces that day and time must be passed as keyword arguments.
• This avoids confusion in calls, especially in functions with multiple parameters.

Real-World Scenario: Keyword-only parameters are ideal for APIs or configuration functions where argument names improve readability.

4. Variable-Length Positional Arguments (*args)

Use *args when you need to handle an arbitrary number of positional arguments. These are collected into a tuple.

Example: Logging Multiple Messages

def log_messages(log_level, *messages):
    """Log multiple messages with a specific log level."""
    print(f"Log Level: {log_level}")
    for message in messages:
        print(f"- {message}")

# Passing multiple messages
log_messages("INFO", "Server started", "Connection established", "Ready to accept requests")

Explanation:

• The first argument (log_level) is a regular positional argument.
• The *messages collects all additional arguments into a tuple, allowing the function to handle any number of messages.

Real-World Scenario: Functions like this are often used in logging or data aggregation, where the number of inputs isn’t fixed.

5. Variable-Length Keyword Arguments (**kwargs)

Use **kwargs to accept an arbitrary number of keyword arguments. These are collected into a dictionary.

Example: Configuring an Application

def configure_app(**settings):
    """Configure an application with dynamic settings."""
    print("App Configuration:")
    for key, value in settings.items():
        print(f"{key}: {value}")

# Passing dynamic settings
configure_app(debug=True, database_url="sqlite:///:memory:", port=8080)

Explanation:

• The **settings collects all keyword arguments into a dictionary.
• This makes the function flexible, accommodating varying configuration needs.

Real-World Scenario: You might use **kwargs in settings loaders, form handlers, or dynamic APIs.

Combining Parameter Types

You can mix these parameter types in a single function, but they must follow this order:

1. Positional-only (/)
2. Positional-or-keyword
3. Variable-length positional (*args)
4. Keyword-only (*)
5. Variable-length keyword (**kwargs)

Example: A Versatile API Request Function

def api_request(method, endpoint, *args, headers=None, **params):
    """Make an API request with flexible arguments."""
    print(f"Method: {method}")
    print(f"Endpoint: {endpoint}")
    if args:
        print("Additional Arguments:", args)
    if headers:
        print("Headers:", headers)
    if params:
        print("Parameters:", params)

# Making a flexible API request
api_request(
    "GET",
    "/users",
    "pagination",
    headers={"Authorization": "Bearer token"},
    sort="name",
    filter="active",
)

Explanation:

• method and endpoint are positional-or-keyword parameters.
• *args collects additional positional arguments (e.g., "pagination").
• headers is a keyword-only parameter.
• **params collects dynamic keyword arguments (e.g., sort="name", filter="active").

Thank you for reading this article. I hope you found it helpful and informative. If you have any questions, or if you would like to suggest new Python code examples or topics for future tutorials, please feel free to reach out. Your feedback and suggestions are always welcome!

Happy coding!
C. C. Python Programming

You can also find this article at Medium.com