Unary Plus

The + operator in Python is a polymorphic operator that functions as both a unary prefix and a binary infix operator. As a binary operator, it performs arithmetic addition on numeric data types and concatenation on supported sequence types. As a unary operator, it represents the identity operation for numerics. While it generally evaluates its operand(s) and returns a newly allocated object leaving the original operands unmutated, Python’s memory optimization may return a reference to an existing object for certain immutable types (such as interned strings or empty tuples).

# Unary syntax
result = +operand


# Binary syntax
result = operand_left + operand_right

Internal Mechanism (The Python Data Model)

When the Python interpreter evaluates the + operator, it relies on the object data model and specific magic (dunder) methods depending on the operator’s arity.

Unary Evaluation The unary expression +x is internally translated to a method call on the operand:

# Internal unary evaluation equivalent
result = x.__pos__()

Binary Evaluation The binary expression x + y is generally translated to a method call on the left operand:

# Internal binary evaluation equivalent
result = x.__add__(y)

However, Python enforces a critical priority rule for subclasses: if the right operand y is an instance of a strict subclass of the left operand x’s type, Python prioritizes the right operand and calls its reverse addition method before attempting the left operand’s __add__:

# Evaluated first if type(y) is a strict subclass of type(x)
result = y.__radd__(x)

If the strict subclass rule does not apply, and the left operand x does not implement __add__, or if its __add__ method returns the NotImplemented singleton (indicating it does not know how to handle the type of y), Python falls back to the right operand’s reverse addition method:

# Fallback binary evaluation
result = y.__radd__(x)

If neither method yields a supported operation, Python raises a TypeError.

Behavior by Operand Category

Unary Operation For standard numeric types (int, float, complex), the unary + operator calls __pos__ and returns the numerical value unchanged. However, for certain standard library types, it enforces invariants. For example, applying + to a collections.Counter instance returns a new Counter with all zero and negative counts stripped, and applying it to a decimal.Decimal applies the current thread’s decimal context precision.

Binary Numeric Addition For numerics, the binary + operator executes mathematical addition. The Python interpreter does not perform implicit type coercion or widening before evaluating the operator. Instead, it delegates type checking and conversion entirely to the __add__ and __radd__ magic methods.

For example, in the expression 1 + 2.0 (int + float), the call to int.__add__(float) returns NotImplemented. The interpreter then falls back to float.__radd__(int), which internally handles the conversion of the integer to a float and performs IEEE 754 double-precision floating-point addition.

Binary Sequence Concatenation For supported sequences (str, list, tuple), the binary + operator performs concatenation. This operation typically requires allocating a new contiguous block of memory large enough to hold both operands, followed by copying the references (or characters) from the left operand and then the right operand into the new structure. Because it creates a completely new object in memory, repeated use of + in a loop for sequence building has an $O(N^2)$ time complexity.

Note: Not all sequence types support concatenation. The built-in range object is a sequence type but does not implement __add__ and will raise a TypeError. Other iterable types, such as set, dict, and generators, also do not support the + operator.

Type Strictness

Python is strongly typed regarding the binary + operator. It strictly requires operand type compatibility. Unlike some dynamically typed languages that perform implicit stringification, Python will not implicitly coerce a numeric type to a sequence type or vice versa.

While sequence types generally require matching types for concatenation (e.g., concatenating a list and a tuple raises a TypeError), Python does allow concatenation between certain mixed sequence types. For instance, a bytearray can be concatenated with bytes or memoryview objects. Furthermore, subclasses of sequences can typically be concatenated with their base classes.

# Raises TypeError rather than coercing types
"String" + 10 


# Generally requires matching sequence types
[1, 2] + (3, 4) # Raises TypeError: can only concatenate list (not "tuple") to list


# Exceptions exist for specific buffer protocols and subclasses
bytearray(b'a') + b'b' # Valid, returns bytearray(b'ab')

Operator Overloading

Developers can define the behavior of the + operator for custom classes by explicitly implementing the __pos__, __add__, and __radd__ methods.

class CustomObject:
    def __pos__(self):
        # Implementation logic for +self
        pass

    def __add__(self, other):
        # Implementation logic for self + other
        pass

    def __radd__(self, other):
        # Implementation logic for other + self
        pass

Master Python with Deep Grasping Methodology!

Learn More