Qual é a diferença entre objetos mutáveis e imutáveis?

Question

Accepted Answer

Um objeto **imutável** não pode ser alterado após sua criação; um objeto **mutável** pode ser. Essa distinção é central em Python e afeta aliasing, chaves de dicts, argumentos de função e uma classe de bugs sutis.

## As duas categorias

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray, and most custom objects
```

## Imutável: "alterar" cria um novo objeto

```python
x = "hello"
x.upper()       # returns a NEW string "HELLO" — x is unchanged
x += " world"   # rebinds x to a NEW string; the original "hello" is untouched

n = 5
n += 1          # creates a new int 6; doesn't modify the int object 5
```

Com imutáveis, operações que parecem "alterar" o valor na verdade produzem um novo objeto e rebindem a variável. O original nunca é alterado.

## Mutável: modificado no local

```python
lst = [1, 2, 3]
lst.append(4)   # modifies the SAME list object → [1, 2, 3, 4]
lst[0] = 99     # in-place change
```

## A armadilha de aliasing (o perigo prático)

```python
# mutable — two names point to the SAME object
a = [1, 2, 3]
b = a            # b is NOT a copy — it's the same list
b.append(4)
print(a)         # [1, 2, 3, 4] ← a changed too! (they're aliases)

# to actually copy:
b = a.copy()     # or list(a), or a[:]
```

Atribuir um objeto mutável não o copia — ambos os nomes referenciam o mesmo objeto, então mutar através de um afeta o outro. Isso surpreende muitos e causa bugs reais.

## Por que imutáveis podem ser chaves de dict / membros de set

```python
d = {(1, 2): "point"}   # ✅ tuple key — immutable, hashable
d = {[1, 2]: "x"}       # ❌ TypeError — lists are unhashable (mutable)
```

Chaves de dict e membros de set devem ser **hashable**, o que requer imutabilidade (uma chave mutável poderia mudar e quebrar a hash table).

## Argumentos de função

```python
def modify(lst): lst.append(99)   # mutates the caller's list (passed by reference)
def rebind(n): n += 1             # rebinds locally; caller's int unchanged
```

## Por que isso importa

Mutabilidade é um conceito fundamental em Python que explica uma ampla gama de comportamentos e bugs: a armadilha de aliasing (atribuição não copia mutáveis), por que funções podem modificar uma lista passada mas não um int, por que apenas objetos imutáveis podem ser chaves de dict/membros de set, e a armadilha do argumento padrão mutável.

Compreender quais tipos são mutáveis vs imutáveis — e que mutar um objeto compartilhado afeta todas as referências a ele — é essencial para escrever Python correto e evitar algumas de suas surpresas mais comuns.