As **asserções** em [[Linguagem de programação Python|Python]] são declarações usadas para verificar se uma condição específica é verdadeira. Elas são ferramentas de depuração e verificação de consistência interna do código, projetadas para detectar erros de programação que não deveriam ocorrer.
# Como Funcionam
A sintaxe básica de uma asserção é:
```python
assert condicao, "Mensagem de erro (opcional)"
```
* Se a `condicao` for avaliada como `True`, a execução do programa continua normalmente.
* Se a `condicao` for avaliada como `False`, uma exceção `AssertionError` é levantada.
* A `mensagem de erro` é opcional e será exibida como parte da `AssertionError` se a asserção falhar, fornecendo mais contexto sobre o problema.
**Exemplo Simples:**
```python
assert 1 + 1 == 2
print("1 + 1 é igual a 2. Asserção bem-sucedida.")
# Com mensagem de erro
assert 1 + 1 == 3, "Erro: 1 + 1 deveria ser igual a 2, mas não foi!"
print("Esta linha não será executada se a asserção acima falhar.")
```
Se você executar o código acima, a segunda asserção falhará e você verá uma saída como:
```
1 + 1 é igual a 2. Asserção bem-sucedida.
Traceback (most recent call last):
File "<stdin>", line 5, in <module>
AssertionError: Erro: 1 + 1 deveria ser igual a 2, mas não foi!
```
# Quando Usar Asserções
As asserções são ideais para:
1. **Verificar Pré-condições**: Garantir que os argumentos passados para uma função ou método atendam aos requisitos antes que a lógica principal seja executada.
```python
def dividir(a, b):
assert b != 0, "O divisor não pode ser zero!"
return a / b
print(dividir(10, 2)) # Saída: 5.0
# dividir(10, 0) # Levantaria AssertionError
```
2. **Verificar Pós-condições**: Confirmar que o resultado de uma operação ou função está dentro das expectativas.
```python
def smallest_item(xs):
# Assumimos que xs não é vazio para simplificar, mas uma asserção poderia verificar isso.
assert isinstance(xs, list) and len(xs) > 0, "A entrada deve ser uma lista não vazia."
resultado = min(xs)
assert resultado in xs, "O menor item deve estar na lista original."
return resultado
assert smallest_item([10, 20, 5, 40]) == 5
assert smallest_item([1, 0, -1, 2]) == -1
```
3. **Verificar Invariantes**: Assegurar que certas condições permaneçam verdadeiras em pontos críticos do código, como dentro de loops ou após modificações de estado.
4. **Detecção de Erros de Programação**: Identificar situações que _nunca_ deveriam acontecer se o código estiver correto. Se uma asserção falha, isso indica um bug no próprio código.
# Quando NÃO Usar Asserções
É crucial entender que as asserções **não são** para:
* **Validação de Entrada do Usuário**: Para entradas externas (de usuários, arquivos, rede), use blocos `if/else` e exceções como `ValueError`, `TypeError`, etc. Asserções podem ser desativadas em produção, o que deixaria seu programa vulnerável a entradas inválidas.
* **Tratamento de Erros Esperados**: Eventos como falhas de rede, arquivos não encontrados ou permissões negadas são condições que podem ocorrer em um ambiente de produção e devem ser tratadas com blocos `try-except`.
* **Substituir Testes Unitários**: Asserções são para verificações _internas_ do código durante o desenvolvimento. Testes unitários são para verificações _externas_ da funcionalidade e comportamento do sistema.
# Desativando Asserções
As asserções podem ser desativadas em tempo de execução usando a opção `-O` (de "optimize") ao iniciar o interpretador Python:
```bash
python -O seu_script.py
```
Quando as asserções são desativadas, as declarações `assert` são ignoradas, e o código dentro delas não é executado. Isso significa que qualquer lógica crítica ou efeitos colaterais que você possa ter colocado em uma asserção (o que é uma má prática) não ocorrerão. Por isso, as asserções devem ser usadas _apenas_ para verificar condições que, se falsas, indicam um bug no programa.
:: **Referência** :: [Python assert keyword (w3schools.com)](https://www.w3schools.com/python/ref_keyword_assert.asp)