Why .join() Beats + for Fast String Concatenation in Python

Start

For beginners or developers transitioning from languages that use the + operator for string concatenation, it is natural to write code like:

str1 = "I love "
str2 = "Python."

As you use Python more, you may notice many prefer the .join() method, for example:

print(''.join([str1, str2]))

Initially this may look less intuitive.

Concatenating Multiple Strings

When you need to join several strings from a list:

strs = ['Life', 'is', 'short,', 'I', 'use', 'Python']

A manual approach uses a loop and the + operator:

def join_strs(strs):
    result = ''
    for s in strs:
        result += ' ' + s
    return result[1:]

This requires handling extra spaces and an explicit loop.

Using .join() simplifies the task to a single line:

def join_strs_better(strs):
    return ' '.join(strs)

The method is called on the separator string, automatically handling spacing without extra logic.

Logic Behind join()

Performance can be measured with Jupyter's %timeit magic. Tests with 100,000 iterations show that .join() is about four times faster than using +.

Why? The + approach repeatedly allocates memory for each concatenation step. A conceptual diagram shows that each loop iteration creates new objects for the space and the string, resulting in many allocations.

Each loop iteration finds a string from the list.

The interpreter evaluates result += ' ' + s, allocating memory for the space.

It then allocates memory for the string s.

This repeats, leading to multiple memory allocations (12 in the example).

In contrast, .join() first counts the number of strings (6), determines that the separator needs to be repeated 5 times, allocates the required memory once (11 slots), and then copies the strings sequentially.

The interpreter counts the strings in the list.

It knows the separator will be used n‑1 times.

It allocates a single block of memory for the final result.

It copies each string into the block and returns the concatenated result.

The reduced number of memory allocations explains the performance gain, which becomes even more pronounced with larger numbers of strings.

Conclusion

This short article compared the + operator and the .join() method for string concatenation in Python. The .join() method is preferred because it delivers clearer code and significantly better performance.