# How to concatenate strings in Python

Python offers different ways to combine strings, including the `+` operator, `str.join()` and the `format()` function. In Python, string concatenation allows for the **flexible and efficient manipulation of strings**, which is essential for various software development tasks and projects.

## What is string concatenation in Python?

In Python, concatenating strings is a technique that **combines** strings into a single string. This process is crucial for modifying or formatting text in Python. There are several ways to concatenate strings in Python, with the two most common methods being the `+` operator and the `str.join()` method.

Efficient string concatenation is essential, particularly when dealing with large text volumes or performance-sensitive applications. Selecting the **most appropriate concatenation method** is key to avoiding performance bottlenecks and optimising code efficiency.

## What are the different methods for concatenating strings in Python?

You can concatenate strings in Python in several ways. Here are the most common ones:

- The `+` operator
- The `*` operator
- The `join()` method
- The `%` operator
- The `format()` function
- f strings

### The`+` operator

In Python, you can join strings together using the `+` operator. This operator joins the strings together to create a new string.

```python
str1 = "Hello, "
str2 = "World!"
result = str1 + str2
print(result)  # Output: Hello, World!
```

The `+` operator links `str1` and `str2` together, and the resulting string is stored in the `result` variable. The output is `Hello, World!

It’s important to remember that every time you use the `+` operator, a new string is generated. This is because **strings in Python are immutable**. This can cause performance problems if you are concatenating numerous strings. In such situations, more efficient methods like `str.join()` are often the better choice.

### The `*` operator

When the `*` operator is applied to a string, the string is\* *multiplied by the number specified*\*, resulting in a repeated concatenation of the original string.

```python
str1 = "Hello! "
multiplier = 3
result = str1 * multiplier
print(result)  # Output: Hello! Hello! Hello!
```

In this example, ‘str1’ is multiplied by 3. The result is `str1` three times in a row.

### The `join()` method

The `join()` method is typically invoked on a **separator string** and accepts a sequence of strings as its argument.

```python
words = ["Python", "is", "great"]
separator = " "
result = separator.join(words)
print(result)  # Output: Python is great
```

In this example, `words` is a list of strings. The `join()` method is applied to the separator string `separator`, which is a **space** here. It combines the elements of the `words` list with the specified separator and creates a new string in which each element of the list is separated by the space character. The result is saved in the variable `result` and then output.

### The `%` method

The `%` method is also known as **string formatting with `%`**. More commonly used in older versions of Python, it has been replaced in newer ones by the `str.format()` method and f-string formatting. The `%` method allows values to be inserted into a predefined string.

```python
name = "Alice"
age = 30
greeting = "My name is %s and I am %d years old." % (name, age)
print(greeting)  # Output: My name is Alice and I am 30 years old.
```

In this example, `%s` indicates a string and `%d` an integer. The `%` method inserts the values of `name` and `age` into the predefined string. The values are passed within brackets **as tuples** and inserted into the corresponding placeholders in the string.

### The `format()` function

The `format()` function concatenates Python strings by substituting placeholders in a string with values. It’s a more flexible and readable way of inserting values into a string. The **placeholders can be defined by positions or names**.

```python
name = "Alice"
age = 30
greeting = "My name is {} and I am {} years old.".format(name, age)
print(greeting)  # Output: My name is Alice and I am 30 years old.
```

Here, the `format()` function takes the values of `name` and `age` as arguments and inserts them into the placeholders in the string in the order that they are passed in the function.

### f strings

F-strings are another Python string formatting method, which is also useful for Python string concatenation.

```python
name = "Alice"
age = 30
greeting = f"My name is {name} and I am {age} years old."
print(greeting)  # Output: My name is Alice and I am 30 years old.
```

In our example, an f-strings is defined by placing `f` in front of the string. We place the variables `name` and `age` inside of the string in curly brackets. During execution, Python replaces these placeholders with the actual values of the variables `name` and `age`.

To learn more about editing strings in Python, check out our tutorials on Python substrings, Python split, Python string index and Python compare strings in our guide.


This is a markdown version of: [https://www.ionos.com/en-ie/digitalguide/websites/web-development/python-string-concatenation/](https://www.ionos.com/en-ie/digitalguide/websites/web-development/python-string-concatenation/) for AI/LLM consumption.