Python Positional-Only and Keyword-Only Arguments (With Examples)

Python, a versatile and widely used programming language, offers a variety of ways to pass arguments to functions. Among these are positional arguments and keyword arguments. In addition to these, Python 3.8 introduced the concept of positional-only and keyword-only arguments, allowing developers to have finer control over function parameter passing. This tutorial will delve deep into positional-only and keyword-only arguments, explaining their usage, benefits, and providing illustrative examples.

Table of Contents

1. Introduction to Function Arguments
2. Positional-Only Arguments
3. Keyword-Only Arguments
4. Using Both Positional-Only and Keyword-Only Arguments
5. Benefits of Using Positional-Only and Keyword-Only Arguments
6. Examples of Positional-Only and Keyword-Only Arguments

• Example 1: Mathematical Operations
• Example 2: Creating User Profiles

1. Conclusion

1. Introduction to Function Arguments

In Python, a function is a block of organized, reusable code that is used to perform a specific action. Functions can accept input arguments, which are values passed into the function when it’s called. There are two common ways to pass arguments to functions: positional arguments and keyword arguments.

• Positional Arguments: These are arguments that are matched to function parameters based on their order. The order of arguments matters, and the values are assigned to parameters in the same order as they are provided.
• Keyword Arguments: These are arguments where each parameter is identified by a keyword and its corresponding value. This allows you to pass arguments in any order and provides more clarity when calling functions with many arguments.

2. Positional-Only Arguments

Positional-only arguments are a feature introduced in Python 3.8 that allows you to specify that certain function parameters must be provided only through positional arguments. This means that when calling a function, you cannot use keyword arguments to assign values to these specific parameters.

To indicate that a parameter is positional-only, you use the forward slash / in the function definition before the parameter name. Let’s take a closer look at this with an example:

def greet(name, /, message):
    return f"Hello, {name}! {message}"

In this example, the name parameter is positional-only because it’s before the / in the parameter list. The message parameter can still be provided using either a positional or keyword argument.

3. Keyword-Only Arguments

Keyword-only arguments are parameters that can only be specified using keyword arguments when calling the function. This ensures that certain arguments are always assigned using their respective keywords, making the function call more explicit and self-documenting.

To define keyword-only arguments, you place an asterisk * before the parameter name in the function definition. Let’s illustrate this with an example:

def display_info(*, name, age):
    return f"Name: {name}, Age: {age}"

In this case, both name and age must be provided as keyword arguments when calling the display_info function.

4. Using Both Positional-Only and Keyword-Only Arguments

Python allows you to define functions that use both positional-only and keyword-only arguments, offering a flexible way to design function interfaces that meet specific requirements.

Consider the following function definition:

def complex_function(a, b, /, c, *, d):
    # Function logic here

In this example, a and b are positional-only arguments because they are before the /. c is a parameter that can be provided through either positional or keyword arguments. Finally, d is a keyword-only argument as it follows the *.

5. Benefits of Using Positional-Only and Keyword-Only Arguments

Using positional-only and keyword-only arguments offers several benefits:

• Explicitness: Positional-only and keyword-only arguments make function calls more explicit and self-documenting. This improves code readability and reduces ambiguity.
• Preventing Errors: By restricting certain arguments to be passed in specific ways, you reduce the likelihood of errors caused by incorrect argument assignments.
• Enforcing Interfaces: These argument styles allow you to design function interfaces that better match the intended usage and requirements.

6. Examples of Positional-Only and Keyword-Only Arguments

Now, let’s explore two detailed examples that showcase the use of positional-only and keyword-only arguments.

Example 1: Mathematical Operations

Suppose we want to create a function that performs various mathematical operations on a set of numbers. We’ll use positional-only arguments for the numbers and keyword-only arguments to specify the operations.

def math_operations(a, b, /, *, operation='add'):
    if operation == 'add':
        return a + b
    elif operation == 'subtract':
        return a - b
    elif operation == 'multiply':
        return a * b
    elif operation == 'divide':
        return a / b
    else:
        raise ValueError("Invalid operation")

# Using positional-only and keyword-only arguments
result = math_operations(10, 5, operation='multiply')
print(result)  # Output: 50

In this example, a and b are positional-only arguments, ensuring that the numbers are provided in the correct order. The operation argument is keyword-only, allowing us to specify the desired operation using a keyword.

Example 2: Creating User Profiles

Imagine we’re developing a user management system, and we want to create user profiles with various attributes. We’ll use positional-only arguments for required information and keyword-only arguments for optional attributes.

def create_user_profile(first_name, last_name, /, *, age=None, email=None):
    profile = {
        'first_name': first_name,
        'last_name': last_name,
    }
    if age is not None:
        profile['age'] = age
    if email is not None:
        profile['email'] = email
    return profile

# Using positional-only and keyword-only arguments
user = create_user_profile('John', 'Doe', age=30, email='john@example.com')
print(user)

Here, first_name and last_name are positional-only arguments, ensuring that these required attributes are provided. The age and email parameters are keyword-only arguments, allowing us to add optional information using keyword arguments.

7. Conclusion

Positional-only and keyword-only arguments are powerful tools that enhance the clarity and control of function parameter passing in Python. They make function calls more explicit, prevent errors, and allow developers to design function interfaces that align closely with their intended usage. By mastering the usage of positional-only and keyword-only arguments, you can write more robust and maintainable code.