Why Operators Are Useful in Python: Cognitive Benefits and Practical Readability

This post, originally published on a Python ideas blog, reflects on the usefulness of operators—especially the dictionary merge operator introduced by PEP‑584 and later integrated into Python 3.9.

It begins with a reminder of the commutative law for addition, expressed both as a function and with the + operator:

add(x, y) == add(y, x) → x + y == y + x

The discussion then moves to the associative law, showing how the nested function form can be simplified to a single expression using operators:

add(x, add(y, z)) == add(add(x, y), z) → x + (y + z) == (x + y) + z → x + y + z

Similarly, the identity element for addition is presented:

add(x, 0) == add(0, x) == x → x + 0 == 0 + x == x

The author argues that operator notation is easier for the visual brain to process, making mathematical relationships more immediately apparent compared to function notation, which requires a more abstract mental path.

Further examples include the distributive law, first written with explicit function calls:

mul(n, add(x, y)) == add(mul(n, x), mul(n, y))

and then shown in the familiar compact operator form:

n * (x + y) == n * x + n * y → n(x + y) == nx + ny

The article notes that while Python’s parser cannot handle some of the more compact notations, the underlying principle remains valuable across different data types—vectors, matrices, scalars, and even functions.

By choosing appropriate operators, programmers can exploit visual cognition to discover patterns faster, similar to how mathematicians use symbols on a blackboard.

In Python, operator overloading enhances readability: using + for string or list concatenation is clearer than calling explicit methods like .copy() or .update() . The author emphasizes a "readability first, performance second" philosophy, noting that in many cases (e.g., d = d1 + d2 ) there is no performance penalty compared to more verbose alternatives.

When performance does become critical, the operator form can be replaced after profiling, but the default should favor the clearer operator syntax.

Overall, the piece advocates for thoughtful operator use to improve code clarity, leveraging both mathematical elegance and cognitive ergonomics.