O parâmetro strict da função map() torna explícita uma suposição que muitos programas já fazem silenciosamente: todos os iteráveis usados na transformação devem ter o mesmo tamanho. Sem essa verificação, map() encerra quando o iterável mais curto termina. Isso pode ocultar dados faltantes, desalinhamentos entre colunas e erros em pipelines. Com strict=True, o Python levanta ValueError quando os comprimentos não combinam, permitindo detectar o problema no ponto exato em que ele surge.
Neste guia, você verá como usar map(strict=True), quando a validação faz sentido, como testar o comportamento e quais alternativas usar em versões anteriores do Python. O recurso é especialmente útil em importação de dados, processamento de lotes, cálculos vetoriais simples e qualquer rotina que combine elementos de duas ou mais sequências.
Por que o map tradicional pode esconder erros
A função map() aplica uma função a cada grupo de itens retirados dos iteráveis recebidos. Quando você fornece apenas um iterável, o comportamento é direto. Com dois ou mais iteráveis, porém, a execução para no menor deles.
nomes = ["Ana", "Bruno", "Carla"]
notas = [9.5, 8.0]
resultado = list(map(lambda nome, nota: (nome, nota), nomes, notas))
print(resultado)
# [('Ana', 9.5), ('Bruno', 8.0)]
Carla desapareceu do resultado sem aviso. Em uma demonstração simples isso é fácil de perceber, mas em uma aplicação real o erro pode passar despercebido. Um CSV pode ter uma coluna incompleta, uma API pode retornar listas com quantidades diferentes ou um cálculo pode perder registros silenciosamente.
Esse comportamento histórico é semelhante ao de zip() sem validação. Ele é conveniente quando o truncamento é intencional, mas perigoso quando o programa pressupõe alinhamento completo.
Como usar strict=True
Ao ativar o modo estrito, map() continua produzindo resultados normalmente enquanto os iteráveis estão alinhados. Se um terminar antes dos demais, a iteração levanta ValueError.
nomes = ["Ana", "Bruno", "Carla"]
notas = [9.5, 8.0]
pares = map(lambda nome, nota: (nome, nota), nomes, notas, strict=True)
try:
print(list(pares))
except ValueError as erro:
print(f"Dados desalinhados: {erro}")
Essa validação acontece durante o consumo do iterador, e não necessariamente no momento em que map() é chamado. Isso ocorre porque map é preguiçoso: ele calcula cada item apenas quando solicitado. Por isso, testes devem consumir o objeto com list(), um laço for ou outra operação equivalente.
Exemplo com cálculo de preços
Imagine um sistema que recebe preços e descontos em listas paralelas. Se faltar um desconto, truncar o resultado pode fazer um produto desaparecer da atualização.
precos = [100.0, 80.0, 50.0]
descontos = [0.10, 0.20, 0.05]
finais = list(
map(
lambda preco, desconto: round(preco * (1 - desconto), 2),
precos,
descontos,
strict=True,
)
)
print(finais) # [90.0, 64.0, 47.5]
O modo estrito transforma a igualdade de comprimentos em um contrato executável. Se os dados estiverem incorretos, o processamento falha cedo, antes de persistir resultados incompletos.
Quando o modo estrito é recomendado
Use strict=True quando cada posição dos iteráveis representa uma única entidade lógica. É o caso de colunas de uma tabela, coordenadas x e y, IDs e valores, nomes e e-mails, datas e medições ou tarefas e configurações.
Também é uma boa escolha em código interno de bibliotecas. Uma exceção clara costuma ser melhor do que retornar uma coleção parcial que provoca falhas longe da origem do problema. A validação ajuda a manter invariantes e simplifica a depuração.
Por outro lado, não use o modo estrito quando o truncamento fizer parte da regra de negócio. Um algoritmo pode, por exemplo, combinar itens somente enquanto duas fontes têm dados disponíveis. Nesse cenário, o comportamento tradicional continua apropriado, mas vale documentar a intenção.
Diferença entre map estrito e zip estrito
zip(strict=True) valida os comprimentos e retorna tuplas. map(strict=True) valida os comprimentos e aplica uma função diretamente. As duas abordagens podem produzir o mesmo resultado.
valores_a = [1, 2, 3]
valores_b = [10, 20, 30]
com_map = list(map(lambda a, b: a + b, valores_a, valores_b, strict=True))
com_zip = [a + b for a, b in zip(valores_a, valores_b, strict=True)]
assert com_map == com_zip
A compreensão de lista com zip costuma ser mais legível quando a transformação é complexa ou exige condições. map é compacto quando você já tem uma função nomeada reutilizável.
Use funções nomeadas em regras importantes
Embora lambdas funcionem bem em exemplos curtos, funções nomeadas tornam validação, testes e mensagens de erro mais claros.
def calcular_total(quantidade: int, preco: float) -> float:
if quantidade < 0:
raise ValueError("quantidade não pode ser negativa")
return round(quantidade * preco, 2)
quantidades = [2, 1, 4]
precos = [12.5, 30.0, 8.0]
totais = list(map(calcular_total, quantidades, precos, strict=True))
A validação de comprimento e a validação de domínio são responsabilidades diferentes. strict=True garante alinhamento; a função aplicada garante que cada valor seja aceitável.
Como testar corretamente
Teste tanto o caso válido quanto os dois tipos de desalinhamento: o primeiro iterável mais curto e um iterável posterior mais curto.
import pytest
def somar(a, b):
return a + b
def test_map_strict_alinhado():
resultado = list(map(somar, [1, 2], [10, 20], strict=True))
assert resultado == [11, 22]
def test_map_strict_detecta_segundo_menor():
with pytest.raises(ValueError):
list(map(somar, [1, 2, 3], [10, 20], strict=True))
def test_map_strict_detecta_primeiro_menor():
with pytest.raises(ValueError):
list(map(somar, [1], [10, 20], strict=True))
O consumo com list() é indispensável. Sem ele, o teste apenas cria o iterador e pode terminar sem executar a validação.
Compatibilidade com versões anteriores
Antes de usar o parâmetro em uma biblioteca, defina a versão mínima do Python. Para projetos que ainda precisam funcionar em versões sem esse recurso, use zip(strict=True) quando disponível ou valide sequências de tamanho conhecido antes do map.
def map_estrito(funcao, *sequencias):
tamanhos = {len(seq) for seq in sequencias}
if len(tamanhos) > 1:
raise ValueError("os argumentos têm tamanhos diferentes")
return map(funcao, *sequencias)
Essa alternativa exige objetos com len() e não serve para geradores infinitos ou iteradores de uso único. Uma implementação genérica pode usar zip(strict=True) e aplicar a função aos grupos.
def map_estrito_generico(funcao, *iteraveis):
for grupo in zip(*iteraveis, strict=True):
yield funcao(*grupo)
Desempenho e consumo de memória
O modo estrito preserva a avaliação preguiçosa. Ele não precisa converter todos os dados em listas nem comparar comprimentos antecipadamente. Isso permite trabalhar com arquivos, streams e geradores sem carregar tudo na memória.
A verificação tem custo pequeno e normalmente irrelevante diante do benefício de detectar inconsistências. Em pipelines críticos, falhar cedo costuma ser muito mais barato do que corrigir dados incompletos depois.
Cuidados com iteradores infinitos
Se todos os iteradores forem infinitos, o desalinhamento nunca ocorre e o processamento continua enquanto houver consumo. Se um for infinito e outro finito, o modo estrito levanta erro quando o finito acabar. Portanto, combine o recurso com limites explícitos quando necessário, usando itertools.islice().
from itertools import count, islice
indices = islice(count(), 3)
valores = ["a", "b", "c"]
resultado = list(map(lambda i, v: (i, v), indices, valores, strict=True))
Boas práticas
Ative o modo estrito quando comprimentos iguais forem uma pré-condição. Consuma o iterador dentro do bloco que trata a exceção. Prefira funções nomeadas para regras complexas. Adicione testes para ambos os sentidos do desalinhamento. Documente quando o truncamento for intencional.
Para aprofundar o tema, veja também os guias da Academify sobre heapq e filas de prioridade, queue e comunicação entre threads, graphlib e dependências e UUIDs no Python. Consulte ainda a documentação oficial de map e o guia de novidades do Python 3.14.
Conclusão
map(strict=True) é uma mudança pequena com grande impacto na confiabilidade. Ele evita que listas paralelas sejam truncadas silenciosamente, aproxima o código de um contrato explícito e localiza erros de dados no ponto em que acontecem. Sempre que seus iteráveis representarem campos alinhados da mesma entidade, o modo estrito oferece uma proteção simples, eficiente e fácil de testar.
