Which is the preferred way to concatenate a string in Python?

python

string-concatenation

performance

best-practices

byAnton Shumikhin·Dec 14, 2024

For efficiency, merge multiple strings using str.join, as it's faster and more memory-friendly than concatenating with + in loops. Here's an example:

# Don't just join a gym, join strings!
concatenated_string = ''.join(['Hello, ', 'world!'])

For a small number of strings, + is simple and readable:

# '+' isn't just for mathematicians!
concatenated_string = 'Hello, ' + 'world!'

Use str.join when interacting with an iterable or loop to bypass performance issues.

Deeper into the Python concatenation valley

Concatenating with '+'

The + and += operators might seem attractive for their readability and speed when dealing with a few strings. However, they might not always be the best choice. For concatenating extensive sequences, the str.join() function is generally more efficient in terms of speed and memory.

Breakdance with `str.join()`

Recommend using str.join() when dealing with an iterable collection of strings, especially if a separator is needed. It's memory-efficient since it calculates the total length of the resulting string once, instead of expanding the string piece by piece.

# Join the party, bring sentences together
sentences = ['Python is fun,', 'fast,', 'and fabulous.']
paragraph = ' '.join(sentences)

Exquisite flavored f-strings

When you have the liberty to insert variables within strings or need strings with dynamic expressions, the f-string (available in Python 3.6+) is your savior. They are not only readable but also fast because Python's interpreter evaluates them at runtime.

# Injecting life into strings with f-strings
name = "Ada"
greeting = f"Salut, {name}! Welcome to Python wonderland."

Beware of in-place concatenation

Try to avoid using += in loops when your code needs to be performance-sensitive. As strings in Python are immutable, this could lead to the creation of a new string object with every concatenation, leading to quadratic performance.

Monster-sized concatenation with StringIO

If your string operations are extensive, especially with large data, using StringIO from the io module is the way to go. It serves a memory buffer.

from io import StringIO

# Build a StringIO dam to flood your code with data
output = StringIO()
for part in large_data:
    output.write(part)
concatenated_string = output.getvalue()
output.close()

The byte whisperer: bytearray

Working with bytes? The bytearray method can rescue you from multiple memory copies.

# Bytearray, the master of bytes
byte_array = bytearray(b'Python, ')
byte_array.extend(b'rules!')

Choose wisely, young coder

While f-strings, +, or += are good for readability or small string operations, consider join(), StringIO, or bytearray if you're dealing with heavy data processing.

Practice your spells

When in doubt, use a tool like ipython to run performance tests and see which method stands the test of reality in your specific case.

Dictionary of string concatenation

Turning tables with list and bytearray

In cases where strings need to undergo transformations frequently, alternate mutable options like list, bytearray, or StringIO can be helpful. They dodge the process of creating a new string with each modification.

Complying with PEP 8

The respected PEP 8 guide recommends readability and clarity over speed and brevity, so make sure to strike a balance when choosing a concatenation method.

Add spice with custom functions

Creating custom functions can help manage more complex scenarios where you might require flexibility with arguments or specific concatenation behaviors.