Concatenar Strings

Concatenação de string é o processo de unir duas ou mais strings em uma só. Python oferece várias abordagens — do simples operador + ao eficiente método join() — e escolher a certa é importante para legibilidade e desempenho.

Este capítulo aborda:

• Os operadores + e +=
• Unir uma lista de strings com join()
• Incorporar valores com f-strings
• Repetir uma string com *
• Concatenar valores não-string (e a armadilha comum do TypeError)
• Quando usar join() em vez de +

Capítulos relacionados: Python Strings · Modificar Strings · Formatar Strings · Métodos de String

Usando o Operador +

O operador + é a forma mais direta de unir duas strings. Python cria uma nova string que contém todos os caracteres dos dois operandos, em ordem.

Concatenar duas strings com +

Hello World

Você pode encadear quantas strings precisar em uma única expressão:

greeting = "Good" + " " + "morning" + ", " + "Python!"
print(greeting)

Good morning, Python!

Atenção — somente strings são permitidas. O operador + não converte outros tipos automaticamente. Tentar concatenar uma string com um número gera um TypeError:

age = 30
# This raises TypeError: can only concatenate str (not "int") to str
# message = "I am " + age + " years old."

# Correct: convert the number to a string first
message = "I am " + str(age) + " years old."
print(message)

I am 30 years old.

Sempre chame str() em um valor não-string antes de usar +.

Usando o Operador +=

O operador += acrescenta uma string a uma variável existente. É uma forma abreviada de variable = variable + new_string e é prático quando você constrói uma string passo a passo.

Construir uma frase de forma incremental com +=

Hello, World!

Um caso de uso comum é acumular linhas dentro de um loop:

words = ["one", "two", "three"]
result = ""
for word in words:
    result += word + " "
print(result.strip())

one two three

Nota sobre desempenho. O uso repetido de += dentro de um loop cria um novo objeto string a cada iteração. Para listas pequenas isso é aceitável, mas para coleções grandes join() (veja abaixo) é significativamente mais rápido.

Usando join() para Concatenar uma Lista de Strings

str.join(iterable) une todas as strings de um iterável, colocando a string sobre a qual é chamado entre cada par. É a forma idiomática em Python de construir uma string a partir de uma coleção.

Unir palavras com um separador de espaço

Hello World

O separador pode ser qualquer coisa — uma vírgula, uma quebra de linha ou até mesmo uma string vazia:

letters = ["P", "y", "t", "h", "o", "n"]

print(", ".join(letters))   # comma-separated
print("".join(letters))     # no separator — merges into one word
print("\n".join(letters))   # one letter per line

P, y, t, h, o, n
Python
P
y
t
h
o
n

Por que preferir join() em vez de + em loops?

Cada chamada de + aloca uma string completamente nova. join() calcula o comprimento total uma vez, aloca memória uma vez e copia todas as partes em uma única passagem — tornando-o O(n) em vez de O(n²) para entradas grandes.

# Slow for large collections
parts = ["a"] * 10_000
result = ""
for p in parts:
    result += p   # 10,000 allocations

# Fast — single allocation
result = "".join(parts)

Usando f-Strings para Concatenar Valores

f-strings (disponíveis desde Python 3.6) permitem incorporar variáveis e expressões diretamente dentro de um literal de string, sem precisar de chamadas explícitas a + ou str().

first_name = "Ada"
last_name  = "Lovelace"
birth_year = 1815

bio = f"{first_name} {last_name} was born in {birth_year}."
print(bio)

Ada Lovelace was born in 1815.

f-strings costumam ser mais claras do que + quando você mistura várias variáveis com texto literal. Consulte o capítulo Formatar Strings para ver a sintaxe completa de f-strings e as opções de formatação.

Repetindo uma String com *

O operador * repete uma string um determinado número de vezes, sendo uma alternativa concisa a um loop de concatenação.

line = "-" * 20
print(line)

echo = "ha" * 3
print(echo)

--------------------
hahaha

Concatenação de Strings em Múltiplas Linhas

Python une automaticamente literais de string adjacentes que aparecem em linhas consecutivas dentro de parênteses — sem precisar de +. Isso é útil para strings longas codificadas diretamente no código.

message = (
    "This is the first part. "
    "This is the second part. "
    "And this is the third."
)
print(message)

This is the first part. This is the second part. And this is the third.

Você também pode quebrar uma concatenação longa em linhas usando uma barra invertida:

long_url = "https://example.com/products" \
           "?category=books" \
           "&sort=price"
print(long_url)

https://example.com/products?category=books&sort=price

Escolhendo o Método Correto

Para mais operações com strings, consulte Modificar Strings, Fatiamento de Strings e Métodos de String.

Prática