Understanding the Rejection of PEP 736: Shorthand Syntax for Keyword Arguments in Python

Carlos Souza at 2025-03-18

Introduction

Python is continually evolving, adapting to the needs of its community and addressing language usability issues. Recently, PEP 736, which proposed a shorthand syntax for keyword arguments at invocation, was rejected by the Python Steering Council. In this article, we will explore what PEP 736 entailed, why it was introduced, and how you can handle keyword arguments effectively in your Python code.

What is Keyword Argument Syntax?

In Python, keyword arguments allow you to pass parameters to functions using specific names, improving readability and clarity. This is especially useful when functions take multiple parameters or when default values are used.

Basic Example of Keyword Arguments

Let's start with a simple function that takes keyword arguments:

def greet(name, age):
    print(f"Hello {name}, you are {age} years old.")

greet(name="Alice", age=30)  # Using keyword arguments

In this example, we define a function greet that takes two parameters: name and age. We invoke this function with keyword arguments, making our intent clear.

Overview of PEP 736

PEP 736 aimed to provide a shorthand syntax for passing keyword arguments at invocation, which was intended to streamline function calls. This proposal suggested that users could invoke functions by specifying keywords in a more compact format, potentially improving the conciseness of certain function calls.

PEP 736 Syntax Example

While the PEP was not accepted, it is helpful to illustrate what the shorthand syntax would have looked like. Here's a hypothetical representation:

# Hypothetical syntax from PEP 736
foo(name="Bob", age=25)  # current syntax

# Proposed shorthand (not accepted)
foo(name: "Bob", age: 25)  # shorthand with colons

In this hypothetical example, using colons instead of equal signs was suggested. However, the proposal faced criticism regarding readability and potential misuse.

Practical Alternatives for Handling Keyword Arguments

Using Dictionaries for Dynamic Keyword Arguments

Although PEP 736 was rejected, you can still employ various techniques to manage keyword arguments efficiently. One effective approach is using dictionaries to handle dynamic keyword arguments. Here’s how:

def describe_person(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

person_info = {"name": "Charlie", "age": 28, "city": "New York"}

describe_person(**person_info)

Explanation:

1. Function Definition: The function describe_person uses **kwargs to accept any number of keyword arguments.
2. Looping Through Arguments: The function iterates through the items of the kwargs dictionary, printing each key-value pair.
3. Dynamic Invocation: The person_info dictionary is defined with personal details, which are unpacked and passed to the function.

Leveraging Named Tuples for Improved Code Clarity

Another strategy is using namedtuple from the collections module, enabling clear and structured keyword argument usage:

from collections import namedtuple

Person = namedtuple('Person', ['name', 'age', 'city'])

bob = Person(name='Bob', age=32, city='Los Angeles')

print(bob)

Explanation:

1. Define Named Tuple: A Person namedtuple is defined, specifying the fields.
2. Creation and Use: An instance of Person is created using keyword arguments, providing clarity through named fields.
3. Output: Printing the bob instance outputs a clean, readable representation of the information.

Conclusion

Despite the rejection of PEP 736, understanding keyword argument syntax is essential for writing clean and maintainable Python code. By leveraging dictionaries and named tuples, developers can effectively manage and utilize keyword arguments in their applications. This ensures that code remains readable and adaptable to changing requirements.

As Python continues to evolve, staying informed about PEP proposals and understanding the reasons behind their acceptance or rejection is vital for any Python developer.