O operador walrus (:=), oficialmente chamado de assignment expression (expressão de atribuição), foi introduzido no Python 3.8 através da PEP 572 e rapidamente se tornou uma das ferramentas mais comentadas — e controversas — da linguagem. Ele permite atribuir valores a variáveis dentro de uma expressão, algo que antes era impossível no Python.

Neste guia completo, você vai entender exatamente o que é o operador walrus, como usá-lo corretamente, quando ele realmente simplifica seu código e quando é melhor evitá-lo.

O Que é o Operador Walrus?

O operador walrus (:=) permite que você atribua um valor a uma variável e, ao mesmo tempo, use esse valor em uma expressão. O nome "walrus" (morsa) vem do fato de que o operador se parece com os olhos e presas de uma morsa deitada.

Sintaxe básica:

(variável := expressão)

Diferentemente do operador de atribuição tradicional (=), que é uma declaração e não retorna valor, o walrus operator é uma expressão que retorna o valor atribuído. Isso significa que você pode usá-lo dentro de outras expressões.

# Sem walrus operator
n = len(lista)
if n > 10:
    print(f"A lista tem {n} itens")

Com walrus operator


if (n := len(lista)) > 10:
print(f"A lista tem {n} itens")

Note que os parênteses em volta da expressão walrus são importantes. Embora nem sempre obrigatórios, são fortemente recomendados pela documentação oficial para evitar ambiguidades.

Casos de Uso Clássicos

1. Loop While com Atribuição

O caso de uso mais comum do operador walrus é em loops while, onde você precisa ler uma entrada e verificar se ela é válida na mesma linha:

# Clássico: ler linhas de um arquivo
with open("dados.txt") as arquivo:
    while (linha := arquivo.readline()):
        print(linha.strip())

Antes do Python 3.8, era necessário:


with open("dados.txt") as arquivo:
linha = arquivo.readline()
while linha:
print(linha.strip())
linha = arquivo.readline()

A segunda versão repete código e é mais propensa a erros (esquecer a linha linha = arquivo.readline() no final causa um loop infinito). O operador walrus elimina esse problema.

2. Compreensão de Listas (List Comprehension)

Em funções que são chamadas múltiplas vezes dentro de uma comprehension, o walrus operator evita processamento repetido:

# Sem walrus: a função caro_calculo() é chamada 2x para cada item
resultados_ruins = [caro_calculo(x) for x in dados if caro_calculo(x) > 0]

Com walrus: a função é chamada 1x por item


resultados = [valor for x in dados if (valor := caro_calculo(x)) > 0]

Isso é especialmente útil em filtros que dependem do resultado de um cálculo caro. Se você quer saber mais sobre como otimizar seu código Python, veja nosso guia sobre type hints em Python, que combinam perfeitamente com expressões de atribuição.

3. Validação com If

# Regex: capturar e verificar ao mesmo tempo
import re
texto = "Contato: [email protected]"
if (match := re.search(r'[\w.+-]+@[\w-]+\.[\w.-]+', texto)):
    print(f"Email encontrado: {match.group()}")

Processamento de dicionários


usuario = {"nome": "Ana", "idade": 25}
if (idade := usuario.get("idade")) and idade >= 18:
print(f"{usuario['nome']} é maior de idade")

Casos Avançados

Walrus em Match Case (Python 3.10+)

A partir do Python 3.10, o operador walrus pode ser combinado com structural pattern matching para criar código ainda mais expressivo:

match comando.split():
    case ["sair" | "quit" | "exit"]:
        print("Encerrando...")
    case ["ola" | "oi", (nome := str())]:
        print(f"Olá, {nome}!")
    case _:
        print("Comando não reconhecido")

Walrus com Listas e Compreensões Aninhadas

# Extrair apenas valores que atendem a um critério e processá-los
dados = [3, 7, 2, 9, 4, 8, 1, 6]
resultado = [
    (metade, dobro)
    for x in dados
    if (metade := x / 2) > 2 and (dobro := x * 2) < 20
]
print(resultado)  # [(3.5, 6), (4.0, 8)]

Depuração com Walrus

Um truque interessante é usar o walrus operator para depurar expressões sem refatorar o código:

# Depurar o valor intermediário de uma expressão
resultado = [
    (debug := x ** 2 + 1)
    for x in range(5)
]
print(debug)  # Último valor calculado: 17

Performance: Walrus Operator Vale a Pena?

O principal ganho de performance com o walrus operator não está na execução em si, mas na eliminação de chamadas redundantes. Considere este exemplo:

import time

def calcular_pesado(n):
"""Simula um cálculo caro"""
time.sleep(0.001)
return n ** 2


numeros = list(range(100))


Sem walrus: calcular_pesado roda 2x por item quando True


start = time.time()
resultado_antigo = [calcular_pesado(n) for n in numeros if calcular_pesado(n) > 50]
print(f"Sem walrus: {time.time() - start:.3f}s")


Com walrus: calcular_pesado roda 1x por item


start = time.time()
resultado_novo = [v for n in numeros if (v := calcular_pesado(n)) > 50]
print(f"Com walrus: {time.time() - start:.3f}s")

A diferença de tempo é dramaticamente menor com o walrus, especialmente para cálculos caros. Para uma análise detalhada de performance em Python, consulte as dicas oficiais de performance do Python.

Quando NÃO Usar o Operador Walrus

O walrus operator pode tornar o código menos legível se usado em excesso ou em contextos inadequados. Veja quando evitá-lo:

❌ Expressões Muito Complexas

# ❌ Evite: difícil de ler e entender
if (a := complexa_funcao(b := outra_funcao(c := 10))) > 5:
    print(a, b, c)

✅ Prefira: claro e explícito


c = 10
b = outra_funcao(c)
a = complexa_funcao(b)
if a > 5:
print(a, b, c)

❌ Substituir Atribuições Simples

# ❌ Desnecessário
if (x := 10) > 5:
    print(x)

✅ Melhor


x = 10
if x > 5:
print(x)

❌ Dentro de F-Strings (Cuidado!)

# ⚠️ Funciona, mas é confuso
print(f"{(x := 5)} ao quadrado é {x ** 2}")

✅ Mais claro


x = 5
print(f"{x} ao quadrado é {x ** 2}")

O Debate da Comunidade

O operador walrus gerou uma das maiores controvérsias na história do Python. O criador da linguagem, Guido van Rossum, se aposentou como BDFL (Benevolent Dictator for Life) em parte devido às discordâncias em torno da PEP 572. Mesmo assim, a proposta foi aceita e implementada no Python 3.8.

Os principais argumentos a favor incluem:

  • Redução de código duplicado
  • Código mais conciso em padrões comuns (while + read, if + assign)
  • Eliminação de erros de esquecer a atribuição extra em loops

Os argumentos contra incluem:

  • Curva de aprendizado para iniciantes
  • Possibilidade de abuso e código ilegível
  • Semelhança visual com o operador de atribuição (=) pode confundir

Se você quiser entender a fundo as motivações técnicas, leia a PEP 572 na íntegra.

Boas Práticas

  1. Sempre use parênteses em volta da expressão walrus para evitar ambiguidades
  2. Use apenas onde realmente simplifica o código (while + read, if + regex, comprehensions)
  3. Nunca aninhe múltiplos walrus na mesma expressão
  4. Prefira legibilidade sobre concisão — código claro é mais importante que código curto
  5. Combine com type hints para tornar o código ainda mais expressivo
# ✅ Exemplo bem escrito
import re
from pathlib import Path

def processar_log(caminho: str) -> list[str]:
erros: list[str] = []
padrao = re.compile(r'ERROR: (.+)')


with Path(caminho).open() as f:
    while (linha := f.readline()):
        if (match := padrao.search(linha)):
            erros.append(match.group(1))

return erros</code></pre>


Walrus Operator com Dicionários e JSON


O operador walrus também é extremamente útil no processamento de dados JSON e dicionários, especialmente quando você precisa verificar a existência de uma chave e processar seu valor simultaneamente:


import json

dados_json = '{"usuario": "ana", "email": "[email protected]", "idade": 28}'
dados = json.loads(dados_json)


Verificar e processar campos obrigatórios


if (nome := dados.get("usuario")) and (email := dados.get("email")):
print(f"Processando: {nome} <{email}>")


Processamento em lote com walrus


usuarios = [
{"nome": "Ana", "pontos": 150},
{"nome": "Bruno", "pontos": 80},
{"nome": "Carla", "pontos": 200},
{"nome": None, "pontos": 0}
]


Filtrar apenas usuários válidos com pontuação alta


validos = [
{"nome": u["nome"], "pontos": u["pontos"], "categoria": "ouro" if u["pontos"] >= 150 else "prata"}
for u in usuarios
if u["nome"] and (pontos := u["pontos"]) > 50
]
print(validos)


Esse padrão é muito comum em pipelines de ETL e processamento de dados. Para mais exemplos de processamento eficiente, veja o artigo completo no tutorial da Real Python e a referência no GeeksforGeeks.


Escopo de Variáveis com Walrus


Um detalhe importante sobre o operador walrus é o escopo da variável criada. Diferentemente do que muitos pensam, a variável atribuída com := fica disponível no escopo atual, não apenas dentro da expressão:


# A variável 'match' fica disponível após a expressão
if (match := re.search(r'\d+', "abc123def")):
    print(f"Número encontrado: {match.group()}")

'match' ainda existe aqui!


print(match.group())  # Funciona: imprime "123"


Em list comprehensions com Python < 3.12, a variável vaza para o escopo externo


(isso foi corrigido no Python 3.12+)


[quadrado for _ in range(1) if (quadrado := 5 ** 2)]
print(quadrado)  # Python < 3.12: 25; Python 3.12+: NameError


Esse comportamento de escopo foi uma das principais críticas ao operador walrus durante sua discussão. Se você quiser entender todos os detalhes técnicos do escopo em expressões de atribuição, consulte a seção de escopo da PEP 572 e a FAQ oficial do Python sobre walrus.


Exemplos Reais em Projetos


Processamento de Arquivos Grandes


Para arquivos muito grandes que não cabem na memória, o walrus operator com while é a abordagem ideal:


from pathlib import Path

def processar_grande(arquivo: str, chunk: int = 8192) -> int:
total = 0
with Path(arquivo).open("rb") as f:
while (dados := f.read(chunk)):
total += dados.count(b"\n")
return total


Uso


linhas = processar_grande("log_servidor.txt")
print(f"Total de entradas no log: {linhas}")


Cache de Resultados em Tempo Real


# Cache simples com walrus
def obter_dados_api(url: str) -> dict:
    if url not in cache and (resposta := requests.get(url)).ok:
        cache[url] = resposta.json()
    return cache.get(url)


Esses padrões são amplamente utilizados em aplicações do mundo real. Para mais exemplos, confira o artigo no Real Python sobre novidades do Python 3.9, que detalha melhorias nas comprehensions que beneficiam o uso do walrus.


Resumo


O operador walrus (:=) é uma adição poderosa ao Python que, quando usada com moderação e bom senso, pode tornar seu código mais limpo, eficiente e expressivo. Os principais pontos deste guia são:


    
  
  • ✅ Atribui valor a uma variável dentro de uma expressão
    • 
  
  • ✅ Elimina código duplicado em loops while e comprehensions
    • 
  
  • ✅ Melhora performance evitando chamadas redundantes em filtros
    • 
  
  • ✅ Disponível desde Python 3.8
    • 
  
  • ⚠️ Use com moderação — legibilidade sempre em primeiro lugar
    • 



Para continuar seus estudos, explore estes recursos oficiais:



Domine essa ferramenta e seu código Python será mais pythônico, eficiente e elegante!