El parámetro strict de la función map() convierte una suposición implícita en una regla comprobable: todos los iterables usados en una transformación deben aportar la misma cantidad de elementos. El comportamiento tradicional de map() termina cuando se agota el iterable más corto. Esto puede ser útil en algunos algoritmos, pero también puede descartar registros de forma silenciosa cuando listas, columnas, identificadores o mediciones quedan desalineados.
Con strict=True, Python lanza ValueError cuando un iterable termina antes que otro. La excepción aparece durante el consumo porque map() es perezoso. En esta guía aprenderás a usar el modo estricto, probarlo, aplicarlo en casos reales y mantener compatibilidad con versiones anteriores.
Cómo map puede ocultar datos faltantes
nombres = ["Ana", "Bruno", "Carla"]
notas = [9.5, 8.0]
resultado = list(map(lambda nombre, nota: (nombre, nota), nombres, notas))
print(resultado)
# [('Ana', 9.5), ('Bruno', 8.0)]
Carla desaparece sin aviso. En una aplicación real, la diferencia puede venir de un archivo incompleto, una consulta, una API o un filtro aplicado solamente a una colección. Como la salida sigue pareciendo válida, el error puede avanzar hasta producción.
Uso de strict=True
nombres = ["Ana", "Bruno", "Carla"]
notas = [9.5, 8.0]
pares = map(lambda nombre, nota: (nombre, nota), nombres, notas, strict=True)
try:
print(list(pares))
except ValueError as error:
print(f"Datos desalineados: {error}")
La llamada crea un iterador. La validación ocurre al usar list(), un bucle, next() u otro consumidor. Por eso el bloque que maneja el error debe envolver el consumo completo.
Ejemplo con precios
precios = [100.0, 80.0, 50.0]
descuentos = [0.10, 0.20, 0.05]
finales = list(
map(
lambda precio, descuento: round(precio * (1 - descuento), 2),
precios,
descuentos,
strict=True,
)
)
Si falta un descuento, la operación falla antes de guardar una actualización incompleta. La igualdad de longitudes pasa a formar parte del contrato del código.
Cuándo conviene activar el modo estricto
Úsalo cuando cada posición de los iterables representa una misma entidad: IDs y valores, nombres y correos, fechas y mediciones, coordenadas, productos y precios, tareas y configuraciones o columnas extraídas de una tabla.
También resulta útil dentro de bibliotecas y servicios de datos. Una excepción cercana al origen suele ser más segura que una colección parcial que provoca fallos mucho después.
No lo actives cuando truncar sea intencional. Algunos sistemas de streaming combinan elementos solamente mientras todas las fuentes tienen datos. En ese caso, el comportamiento tradicional es correcto, pero debe quedar documentado.
map estricto frente a zip estricto
izquierda = [1, 2, 3]
derecha = [10, 20, 30]
con_map = list(map(lambda a, b: a + b, izquierda, derecha, strict=True))
con_zip = [a + b for a, b in zip(izquierda, derecha, strict=True)]
assert con_map == con_zip
zip(strict=True) valida y produce tuplas. map(strict=True) valida y aplica directamente una función. Una comprensión suele ser más legible para lógica compleja; map es compacto cuando ya existe una función reutilizable.
Funciones con nombre para reglas importantes
def calcular_total(cantidad: int, precio: float) -> float:
if cantidad < 0:
raise ValueError("la cantidad no puede ser negativa")
return round(cantidad * precio, 2)
cantidades = [2, 1, 4]
precios = [12.5, 30.0, 8.0]
totales = list(map(calcular_total, cantidades, precios, strict=True))
La validación de longitud y la validación de dominio son responsabilidades distintas. El modo estricto garantiza alineación; la función valida cada dato y realiza la transformación.
Pruebas correctas
import pytest
def sumar(a, b):
return a + b
def test_datos_alineados():
assert list(map(sumar, [1, 2], [10, 20], strict=True)) == [11, 22]
def test_segundo_mas_corto():
with pytest.raises(ValueError):
list(map(sumar, [1, 2, 3], [10, 20], strict=True))
def test_primero_mas_corto():
with pytest.raises(ValueError):
list(map(sumar, [1], [10, 20], strict=True))
Consumir el iterador es obligatorio. Una prueba que solo crea el objeto map puede terminar sin comprobar el desajuste.
Compatibilidad con versiones anteriores
Antes de usar el parámetro en una biblioteca, define la versión mínima de Python. Para secuencias con tamaño conocido, se pueden comparar longitudes antes de mapear.
def map_estricto_secuencias(funcion, *secuencias):
longitudes = {len(secuencia) for secuencia in secuencias}
if len(longitudes) > 1:
raise ValueError("los argumentos tienen longitudes diferentes")
return map(funcion, *secuencias)
Esta versión necesita len(). Para iteradores arbitrarios puede construirse una alternativa sobre zip(strict=True).
def map_estricto(funcion, *iterables):
for grupo in zip(*iterables, strict=True):
yield funcion(*grupo)
Evaluación perezosa y memoria
El modo estricto conserva la evaluación perezosa. No convierte todos los datos en listas ni inspecciona el contenido por adelantado. Esto permite trabajar con archivos, generadores, cursores y flujos de forma incremental.
El coste de la comprobación es pequeño frente al coste de corregir datos parciales. En la mayoría de aplicaciones, la función aplicada y la fuente de datos dominan el tiempo total.
Iteradores infinitos
Si todos los iteradores son infinitos, nunca aparece un final desigual. Si uno es infinito y otro finito, se lanza el error cuando termina el finito. Usa un límite explícito con itertools.islice() cuando el procesamiento deba detenerse tras una cantidad concreta.
from itertools import count, islice
indices = islice(count(), 3)
valores = ["a", "b", "c"]
resultado = list(map(lambda indice, valor: (indice, valor), indices, valores, strict=True))
Manejo de errores en pipelines
Captura ValueError donde puedas agregar contexto útil o recuperarte. Un importador puede indicar el archivo y las columnas afectadas. Evita ignorar la excepción y continuar con una salida parcial.
def combinar_columnas(ids, importes, origen):
try:
return list(map(lambda item_id, importe: {"id": item_id, "importe": importe}, ids, importes, strict=True))
except ValueError as error:
raise ValueError(f"columnas desalineadas en {origen}") from error
Buenas prácticas
Activa el modo estricto cuando la igualdad de tamaños sea una precondición. Consume el iterador dentro del bloque de manejo de errores. Usa funciones con nombre para reglas complejas. Prueba ambos sentidos del desajuste. Documenta de forma explícita los casos donde el truncamiento sea intencional.
Continúa aprendiendo con los artículos de Academify sobre heapq y colas de prioridad, queue y comunicación entre hilos, graphlib y ordenación topológica y UUIDs ordenables. Consulta también la documentación oficial de map y las novedades de Python 3.14.
Conclusión
map(strict=True) es una mejora pequeña con un beneficio importante para la confiabilidad. Detecta entradas desalineadas, evita descartar registros silenciosamente, conserva el procesamiento perezoso y se integra bien con pruebas automatizadas. Cuando varios iterables representan campos de los mismos registros, el modo estricto hace visible y verificable esa relación.
