ValueError: No hay suficientes valores para desempaquetar en Python

Python lanza ValueError: not enough values to unpack siempre que una asignación o la cabecera de un bucle pide más variables de las que el iterable de la derecha puede proporcionar. Lo encontrarás en asignaciones directas, en entradas que se dividen en muy pocos campos y en bucles sobre diccionarios que desempaquetan cada par en un número incorrecto de nombres. Esta guía muestra cómo interpretar el mensaje y cómo corregir cada situación.

Por qué Python lanza ValueError: not enough values to unpack

Desempaquetar asigna los elementos de un iterable —una tupla, una lista, una cadena u objeto de vista— a una lista de nombres correspondiente. En a, b, c = 3, 5, Python cuenta ambos lados antes de asignar nada: tres nombres a la izquierda, dos valores a la derecha. Como llegaron menos valores que los objetivos escritos, el intérprete lanza un ValueError cuyo mensaje informa ambos recuentos, expected 3, got 2. Esos dos números son el diagnóstico: el primero indica cuántos objetivos escribiste y el segundo, cuántos valores produjo realmente el iterable.

Ejecuta este ejemplo para ver el mensaje que informa Python:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

try:
    a, b, c = 3, 5
except ValueError as error:
    print("ValueError:", error)

ValueError: not enough values to unpack (expected 3, got 2)

Sin el try/except, el programa se detiene en la línea de la asignación. El mismo desajuste aparece con cualquier iterable más corto que la lista de objetivos: a, b, d, e = [1, 2, 3] pide cuatro nombres a una lista de tres elementos, y a, b, c = 2 pide tres nombres a un solo entero, que Python no puede desempaquetar en absoluto.

Corregir errores de desempaquetado en asignaciones y entradas

La corrección más sencilla es hacer que ambos lados coincidan: el número de nombres a la izquierda debe igualar el número de valores que el lado derecho puede proporcionar. Cuando los valores provienen de input(), recuerda que input() siempre devuelve una cadena, por lo que split() decide cuántos campos recibe realmente la asignación. El programa siguiente pide tres números separados por comas y obtiene tres, así que el desempaquetado funciona y la multiplicación se ejecuta. Ejecuta este ejemplo:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

import sys
from io import StringIO

# Simulate typing "2,2,2" at the prompt.
sys.stdin = StringIO("2,2,2\n")

x, y, z = input("Enter three numbers to multiply: ").split(",")
product = int(x) * int(y) * int(z)
print("The product of x, y, and z is:", product)

Enter three numbers to multiply: The product of x, y, and z is: 8

La línea de sys.stdin sustituye a un usuario que escribe 2,2,2; en un programa real llamas a input() con normalidad y la persona ante el teclado decide cuántos campos llegan. Cuando alguien escribe menos campos de los que necesitan los objetivos, la lista resultante de la división es demasiado corta y aparece el mismo ValueError:

import sys
from io import StringIO

# Simulate typing "1,2" at the prompt.
sys.stdin = StringIO("1,2\n")

try:
    x, y, z = input("Enter values for x, y and z: ").split(",")
except ValueError as error:
    print("ValueError:", error)

Enter values for x, y and z: ValueError: not enough values to unpack (expected 3, got 2)

Si el lado derecho puede variar de longitud legítimamente, un objetivo con asterisco absorbe el excedente: first, *rest = [1, 2, 3] vincula first a 1 y rest a [2, 3]. El asterisco solo ayuda cuando el problema son los elementos de sobra; cuando llegan muy pocos valores, iguala los recuentos o valida primero la entrada.

Corregir el desempaquetado de diccionarios con .items()

Un diccionario almacena pares clave-valor. Iterar el propio diccionario solo produce sus claves, mientras que .items() devuelve una vista de pares (key, value) en la que cada par contiene exactamente dos valores. Puedes ver las tres vistas estándar:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

student = {"name": "Zeeshan Afridi", "degree": "BSSE", "section": "A"}

print("Keys:", student.keys())
print("Values:", student.values())
print("Items:", student.items())

Keys: dict_keys(['name', 'degree', 'section'])
Values: dict_values(['Zeeshan Afridi', 'BSSE', 'A'])
Items: dict_items([('name', 'Zeeshan Afridi'), ('degree', 'BSSE'), ('section', 'A')])

Como cada elemento de .items() es un par de dos valores, una cabecera de bucle con tres objetivos falla en la primera iteración: es el par el que proporciona los valores, no el método, quien fija el recuento:

student = {"name": "Zeeshan Afridi", "degree": "BSSE", "section": "A"}

try:
    for k, v, l in student.items():
        print(k, v, l)
except ValueError as error:
    print("ValueError:", error)

ValueError: not enough values to unpack (expected 3, got 2)

La corrección consiste en desempaquetar cada par en dos nombres, uno para la clave y otro para el valor:

student = {"name": "Zeeshan Afridi", "degree": "BSSE", "section": "A"}

for key, value in student.items():
    print("Key:", key)
    print("Value:", value)

Key: name
Value: Zeeshan Afridi
Key: degree
Value: BSSE
Key: section
Value: A

Cuando solo necesitas las claves, itera el diccionario directamente con for key in student:; usa .values() cuando solo necesites los valores. Ten cuidado de no desempaquetar un bucle simple sobre las claves: for k, v in student: intenta desempaquetar cada cadena de clave en sí misma, por lo que las claves de varios caracteres fallan con too many values to unpack.

Validar la entrada y gestionar los errores de desempaquetado

Dos hábitos mantienen este error alejado de los usuarios. Primero, cuenta los campos antes de desempaquetar: split() te entrega una lista y len() te dice si coincide con el número de nombres que piensas asignar, de modo que puedas volver a pedir los datos con un mensaje claro:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

import sys
from io import StringIO

# Simulate typing "1,2" at the prompt.
sys.stdin = StringIO("1,2\n")

parts = input("Enter three numbers to multiply: ").split(",")

if len(parts) != 3:
    print("Please enter exactly three numbers separated by commas.")
else:
    x, y, z = (int(part) for part in parts)
    print("The product of x, y, and z is:", x * y * z)

Enter three numbers to multiply: Please enter exactly three numbers separated by commas.

Segundo, envuelve el bloque de desempaquetado y conversión en try/except: las palabras clave de Python son try y except, no la grafía try-catch usada en algunos otros lenguajes. Como int() también lanza ValueError para campos no numéricos, una sola cláusula except cubre tanto una lista de campos corta como los valores que no se pueden convertir:

import sys
from io import StringIO

# Simulate typing "2,two,4" at the prompt.
sys.stdin = StringIO("2,two,4\n")

try:
    x, y, z = input("Enter three numbers to multiply: ").split(",")
    product = int(x) * int(y) * int(z)
    print("The product of x, y, and z is:", product)
except ValueError as error:
    print("Could not use that input:", error)

Enter three numbers to multiply: Could not use that input: invalid literal for int() with base 10: 'two'

Capturar la excepción permite que el programa se recupere, pero no corrige los datos. Prefiere la comprobación de longitud —además de cualquier comprobación numérica o de formato que necesite tu entrada— para poder indicar al usuario exactamente qué escribir, y mantén try/except como red de seguridad alrededor del propio desempaquetado.