# Python concatenate strings: como concatenar strings

Em Python, pode unir cadeias utilizando diferentes métodos, como o operador `+`, `str.join()` ou o formatamento de cadeias. Concatenar cadeias em Python permite **manipular cadeias de forma flexível e eficiente**, o que é fundamental em muitas aplicações de desenvolvimento de software.

## O que é concatenar cadeias em Python?

Concatenar strings em Python é uma técnica que consiste em **unir várias strings** (também chamadas de cadeias de caracteres) **numa única**. Este processo é decisivo quando é necessário modificar ou formatar texto em Python. Existem várias formas de concatenar strings em Python, mas os dois métodos mais comuns são o operador `+` e o método `str.join()`.

Realizar uma concatenação de cadeias eficaz é importante, especialmente quando se trabalha com grandes quantidades de texto ou em aplicações onde o desempenho é crucial. É importante escolher o **método de concatenação mais adequado** para evitar possíveis problemas de desempenho e garantir que o código funcione com a maior eficiência possível.

## Métodos para concatenar cadeias em Python

Existem várias formas de concatenar cadeias em Python. Estas são as formas mais conhecidas:

- o operador `+`,
- o operador `*`,
- o método `join()`,
- o operador `%`,
- a função `format()` e
- f strings.

### O operador `+`

Você pode unir cadeias no Python usando o operador `+` entre as strings. Dessa forma, cria-se uma nova cadeia.

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

No exemplo anterior, o operador `+` é usado para unir as strings `str1` e `str2`. A string resultante é armazenada na variável `result` (resultado). Quando essa nova string é emitida, obtém-se `Hello, World!` (Olá, Mundo!).

Tenha em atenção que cada vez que executar o operador `+` será gerada uma nova cadeia, pois as **strings em Python são imutáveis**. Ao concatenar muitas cadeias, isso pode causar perdas de desempenho, pelo que seria melhor utilizar métodos mais eficientes, como `str.join()`.

### O operador `*`

Quando o operador `*` é aplicado a uma cadeia, ele *multiplica-a pelo número indicado* e resulta numa concatenação repetida da cadeia original.

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

Neste exemplo, a string `str1` é multiplicada pelo valor 3. O resultado é concatenar strings em Python de `str1` três vezes seguidas.

### O método `join()`

Em geral, o método `join()` é chamado sobre uma **cadeia separadora** e utiliza uma sequência de cadeias como argumento.

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

Neste código de exemplo, `words` é uma lista de cadeias. O método `join()` é aplicado à cadeia separadora `separator`, que aqui é um **espaço**. Através do método, os elementos da lista `words` são unidos com o separador indicado e é criada uma nova cadeia na qual cada elemento da lista é separado por um espaço. O resultado é armazenado na variável `result` e depois emitido.

### O método `%`

O método `%`, também conhecido como **formatação de strings com `%`**, permite inserir valores numa string predefinida. Embora fosse utilizado em versões antigas do Python, nas versões mais recentes foi substituído pelo método `str.format()` e pela formatação f 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.
```

Neste exemplo, escolheu-se `%s` para denotar uma cadeia e `%d` para um número inteiro. Utilizou-se o método `%` para inserir os valores das variáveis `name` (nome) e `age` (idade) na cadeia predefinida. Os valores são passados entre parênteses **como tuplas** e inseridos nos marcadores de posição correspondentes da cadeia.

### A função `format()`

A função `format()` pode concatenar strings em Python ao substituir os marcadores de posição de uma string por valores específicos. É uma forma mais flexível e legível de inserir valores numa string em comparação com outras formas de unir strings. Os marcadores de posição **podem ser definidos por posições ou nomes**, o que facilita a manipulação das strings.

```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.
```

A função `format()` utiliza os valores `name` e `age` como argumentos e insere-os nos marcadores de posição da cadeia na ordem em que são passados na função.

### f strings

F strings é outro método de formatação de strings do Python que pode ser utilizado para realizar uma concatenação de strings no Python.

```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.
```

Neste exemplo, as cadeias f foram definidas colocando a letra «f» à frente da cadeia. As variáveis `name` e `age` foram colocadas dentro da cadeia entre chaves. Durante a execução, o Python substitui esses marcadores de posição pelos valores reais das variáveis `name` e `age`.

Se quiser saber mais sobre strings em Python, recomendamos que consulte os tutoriais sobre substrings em Python, split em Python, índice de strings em Python e comparação de strings em Python no nosso Guia Digital.


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/concatenacao-de-strings-em-python/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/concatenacao-de-strings-em-python/) for AI/LLM consumption.