Addition

The + operator in Python is a polymorphic operator primarily responsible for numeric addition and sequence concatenation. Its specific behavior is dynamically resolved at runtime based on the data types of the operands being evaluated.

# Binary syntax
result = left_operand + right_operand


# Unary syntax
result = +operand

Internal Mechanics and Data Model

When the Python interpreter evaluates a binary + expression, it translates the operation into a method call on the underlying objects. To ensure correctness and prevent instances from shadowing special methods, Python looks up dunder methods on the class type, bypassing the instance dictionary entirely. The standard resolution order invokes the left operand’s __add__ special (dunder) method.

# Standard internal evaluation of: a + b
result = type(a).__add__(a, b)

However, Python enforces a strict subclass priority rule. If the right operand’s type is a strict subclass of the left operand’s type and the subclass overrides the __radd__ (reverse add) method, the interpreter will bypass the left operand and invoke the right operand’s __radd__ method before attempting the left operand’s __add__ method. If the subclass inherits but does not override the __radd__ method, the interpreter does not bypass the left operand, and standard left-to-right evaluation is preserved.

# Evaluation if type(b) is a strict subclass of type(a) 

# AND type(b) overrides __radd__
result = type(b).__radd__(b, a)

During standard evaluation, if the left operand’s __add__ method does not recognize or support the type of the right operand, it returns the NotImplemented singleton. The interpreter then attempts a reverse addition by invoking the __radd__ method on the right operand’s type. If both __add__ and __radd__ return NotImplemented, or if the methods do not exist, the interpreter raises a TypeError.

Type Coercion and Compatibility

Because Python is strongly typed, the + operator enforces strict type compatibility rules:

• Numeric Types: Python performs implicit type promotion (coercion) across the numeric tower. If an int and a float are operated on, the int is promoted to a float at the C-API level before the addition is computed.
• Sequence Types: Operands generally must belong to compatible sequence families. The operator will not implicitly cast types across distinct sequence boundaries (e.g., list + tuple raises a TypeError). However, strict type equality is not universally required; certain differing sequence types can be concatenated if supported by their underlying implementation. For example, a bytes object can be added to a bytearray (e.g., bytearray(b"a") + b"b"), which evaluates to a new bytearray.

Memory Allocation and Mutability

By standard convention, the binary + operator evaluates to a newly allocated object in memory and does not mutate either the left or right operand in place. However, because the + operator simply delegates to the __add__ dunder method, Python does not strictly enforce immutability at the language level. A user-defined class can technically implement __add__ to mutate the object in place, though doing so violates standard Python design principles.

For built-in sequence types, evaluating the + operator requires allocating a new contiguous block of memory large enough to hold the combined contents of both operands, followed by copying the values or references from both original sequences. Consequently, using the + operator on sequences results in a time and space complexity of $O(N + M)$, where $N$ and $M$ are the lengths of the respective operands.

Unary Plus

When used as a unary operator (a single operand to the right of the +), the interpreter invokes the __pos__ dunder method on the operand’s type.

# Internal evaluation of: +a
result = type(a).__pos__(a)

While unary + leaves standard integers and floats unchanged, it does not guarantee an identical return value or type. For example, booleans are a standard numeric subtype of integers in Python; evaluating +True returns the integer 1, modifying its type. Furthermore, for standard library types like decimal.Decimal, unary + applies the current thread’s arithmetic context (such as precision limits), which can alter the actual value of the operand.

Master Python with Deep Grasping Methodology!

Learn More