Different ways to concatenate strings in Python

String concatenation and interpolation are two different approaches to combining strings in Python, each with its own advantages and use cases.

• String concatenation involves joining multiple strings together using operators like + or +=, straightforward and suitable for simple cases where you need to combine fixed strings or variables into a single string.
• String interpolation is a more modern and expressive way to embed variables or expressions within strings, allows you to embed expressions directly inside the string using placeholders {} and formatted string literals (f-strings).

Here we focus on different string concatenation methods in Python:

Using + operator

The plus + operator is simple for concatenating a few strings, highly readable and easy to understand, making it a good choice for simple concatenations.

str1 = "Hello"
str2 = "Beautiful"
str3 = "World"
result = str1 + " " + str2 + " " + str3
print(result)  # Output: Hello Beautiful World

Python does not implicitly convert non-string types to strings during concatenation. You must explicitly handle the conversion using the str() function.

str1 = "The answer is"
num = 42
result = str1 + " " + str(num)
print(result)  # Output: The answer is 42

If you attempt to concatenate strings with non-string types without converting them to strings, Python will raise a TypeError.

str1 = "The number is"
num = 42
result = str1 + num
# This will raise: TypeError: can only concatenate str (not "int") to str

For a small number of strings, the performance difference between the + operator and other methods is negligible. However, for a large number of concatenations, using the + operator repeatedly can be inefficient because it creates a new string object each time, which involves copying the entire string content.

Using the += operator for string concatenation follows the same rules as using the + operator, ensure each element is converted to a string.

result = "Values:"
values = [42, 3.14, True, None, [1, 2, 3]]

for value in values:
    result += " " + str(value)

print(result)
# Output: Values: 42 3.14 True None [1, 2, 3]

Using join() method

The join() method is called on a string (which serves as the separator) and takes an iterable (like a list or tuple) of strings to concatenate. It’s efficient for concatenating many strings with a separator.

str_list = ["apple", "banana", "cherry"]
comma_separated = ", ".join(str_list)
print(comma_separated)  # Output: apple, banana, cherry

If the iterable contains non-string types, you need to convert each element to a string before using join(). This can be done using a generator expression.

mixed_list = ["The number is", 42, "and the value is", 3.14]
result = " ".join(str(item) for item in mixed_list)
print(result)  # Output: The number is 42 and the value is 3.14

The join() method is more efficient than using the + or += operators for concatenating multiple strings because it avoids the repeated creation of new string objects.

Using * operator

The * operator in Python is a versatile operator with multiple uses depending on the context.

• The * operator is used to multiply two numbers in arithmetic operations.
• The * operator can be used to repeat a string a specified number of times.
• The * operator can repeat lists.
• The * operator can be used to unpack iterables such as function arguments, list operations.

Here’s how to repeat a string multiple times:

str1 = "Hello"
result = str1 * 3
print(result)  # Output: HelloHelloHello

You can combine the * operator with the join() method.

word = "Hello"
separator = ", "
result = separator.join([word] * 3)
print(result)  # Output: Hello, Hello, Hello