How to Concatenate Strings in Python: str and String-Like Values

By the end of this page, you will understand how string concatenation works in Python, how to join normal string values using +, what to do when values are not both plain str, and how to avoid common type-related mistakes.

In Python, string concatenation means combining text values into a single string.

The most common way to concatenate two strings is with the + operator:

first = "Hello, "
second = "world"
result = first + second
print(result)

This produces:

Hello, world

The important rule

Both values must be strings for + to work directly in string concatenation.

Python's built-in text type is str. So when you concatenate text in Python, you are usually working with str objects.

a = "foo"
b = "bar"
print(a + b)  # foobar

What about String?

In Python, String with a capital S is not a built-in type like it is in some other languages such as Java or C#. The real built-in string type is str.

Think of a Python string as a strip of text on paper.

• Concatenation means taping two strips together end to end.
• If both pieces are already text, Python can join them easily.
• If one piece is not actually text, Python first needs you to turn it into text.

So:

• str + str → tape works immediately
• non-str + str → convert first, then tape

If you try to tape a number or custom object directly onto a text strip, Python stops and asks you to be explicit.

Basic syntax

result = string1 + string2

Both string1 and string2 should be str values.

Example: str and str

first_name = "Ada"
last_name = "Lovelace"
full_name = first_name + " " + last_name

print(full_name)

Output:

Ada Lovelace

This works because all parts are strings.

Example: converting another type to str

age = 28
message = "Age: " + str(age)

print(message)

Output:

Age: 28

Without str(age), Python would raise an error because is an integer, not a string.

Consider this example:

class String:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return self.value

left = String("Hello")
right = " there"
result = str(left) + right
print(result)

Step by step

1. A custom class named String is defined.
2. The __init__ method stores the text in self.value.
3. The __str__ method tells Python how to turn the object into a normal string.
4. left = String("Hello") creates a String object.
5. right = " there" creates a normal Python str.
6. str(left) calls left.__str__() and returns "Hello".

String concatenation is used constantly in real programs.

Building messages

username = "maria"
message = "Welcome, " + username

Used in command-line tools, web apps, and notifications.

Creating log output

status = "OK"
log_line = "Service status: " + status

Useful for debugging and monitoring.

Combining file name parts

name = "report"
extension = ".txt"
filename = name + extension

Common in scripts that generate files.

Formatting data for display

city = "Paris"
country = "France"
label = city + ", " + country

Used in UI labels, exports, and reports.

Joining API or database values

first = "Grace"
last = "Hopper"
full = first + " " + last

Useful when displaying structured data as readable text.

In real projects, developers often concatenate strings in a few common ways.

Simple + for small, direct cases

error_prefix = "Error: "
message = error_prefix + "invalid input"

This is fine when combining only a small number of string values.

F-strings for readability

user = "alice"
count = 3
text = f"User {user} has {count} notifications"

This is very common in production code because it is clear and concise.

''.join(...) for many pieces

parts = ["Py", "thon", "3"]
result = "".join(parts)

This is preferred when joining many strings from a list or loop.

Validation before concatenation

Developers often check values before building strings:

def greet(name):
    if name is :
         
      + (name)

1. Concatenating a string with a non-string

Broken code:

age = 30
text = "Age: " + age

This raises:

TypeError

Fix:

text = "Age: " + str(age)

2. Assuming String is a built-in Python type

Broken idea:

value = String("hello")

This fails unless String was defined somewhere.

In Python, the built-in string type is:

str

3. Forgetting spaces when concatenating

first = "Hello"
second = "World"
print(first + second)

Output:

HelloWorld

Quick rules

• Python's built-in string type is str
• Concatenate strings with +
• Both sides of + must be strings for string concatenation
• Use str(value) to convert non-string values
• Use f-strings for cleaner mixed-value formatting
• Use "".join(list_of_strings) for many string parts

Common patterns

"Hello" + "World"

"Hello " + name

"Age: " + str(age)

f"Age: {age}"

"".join(["a", "b", "c"])

If you see String

• It is a built-in Python type

Is String a built-in type in Python?

No. Python's built-in text type is str. String is not a standard built-in type.

How do I concatenate two strings in Python?

Use the + operator:

result = "Hello" + "World"

Why do I get a TypeError when using +?

Because one of the values is not a string. Convert it first with str(...) or use an f-string.

Should I use + or f-strings?

Use + for very simple string-to-string joining. Use f-strings when combining text with variables or other types.

What is the best way to join many strings?

Use "".join(...) when you have a list of strings.

Can custom objects be concatenated like strings?

Not directly unless they behave like strings. Usually you should convert them with str(obj) first.

Does Python automatically convert numbers to strings during concatenation?

• str type — the core built-in text type in Python.
• Type conversion — important when values are not already strings.
• f-strings — a cleaner way to build strings with variables.
• join() — useful for combining many strings efficiently.
• TypeError — the common error raised when concatenating incompatible types.
• Special methods like __str__ — used by custom objects to define string representation.