This Python error is caused by trying to unpack an iterable into too many variables. This can commonly happen when trying to loop over key/value errors of a dict or when unpacking a function’s return value. Fix this by using the .items() method for dicts or by using the correct number of variables for a function’s return value.
In Python, you can unpack a list, tuple, or some other iterable into variables using a one-liner: a, b = [1, 2]. But, this only works if you have the correct number of variables to hold the values in the iterable. Too many variables, and you’ll get “ValueError: not enough values to unpack”.
This can happen in a number of common scenarios. Read on to see what they are and how to fix them.
❌ Problem: you are unpacking a list of iterables into the wrong number of variables
This isn’t the most common case but it’s the most basic. If you have a list of things, and those things are expected to be tuples of a particular size, it’s common to unpack them into variables with meaningful names while you loop through them to make your code easier to read.
But, if one or more of those tuples (or other iterable, it doesn’t matter) has a different length, you’ll get this error.
Here’s an example:
my_list = [(1, 2), (1, 2, 3)]
for a, b, c in my_list:
print(a, b, c)
What we’re trying to do above is loop through my_list and unpack each item, which is a tuple, into three variables: a, b, and c. This isn’t going to work, as you can imagine, because the very first tuple only has two things in it, i.e., not enough to fill up our 3 variables. Python isn’t going to try to “do the right thing” for you here, it’s just going to barf out this error:
Traceback (most recent call last):
File "/home/user/main.py", line 3, in <module>
for a, b, c in my_list:
ValueError: not enough values to unpack (expected 3, got 2)
The error is pretty straightforward. Thankfully. Read it, understand it, then move on to our fixes below…
✅ Fix 1: use just one variable
The simplest way to fix this is to just use one variable. This might be preferred for your particular situation. It works because, after all, the things in the list are just tuples, and can be held in one variable:
my_list = [(1, 2), (1, 2, 3)]
for a in my_list:
print(a)
# -> (1, 2)
# (1, 2, 3)
From here, you can unpack a however you see fit.
✅ Fix 2: use a nested for loop
You might want to get at each individual item in my_list‘s tuples. If that’s the case, you’ll want a nested for loop like this:
my_list = [(1, 2), (1, 2, 3)]
for a in my_list:
for b in a:
print(b)
# -> 1
# 2
# 1
# 2
# 3
Now you have access to each individual item. It’s not as pretty as unpacking can be, but it’s effective.
❌ Problem: you are trying to get a key/value pair from a dict
Now this is a very common scenario. Unpacking key/value pairs from a dict in a for loop is a very regular task in Python. But, it’s not as simple as this example, even though it looks correct:
my_dict = { 'a': 1, 'b': 2, 'c': 3 }
for k,v in my_dict:
print(k,v)
What’s actually happening here is we’re looping over the keys of the dict, not the key/value pairs. When we run it, we get the following error:
Traceback (most recent call last):
File "/home/user/main.py", line 3, in <module>
for k,v in my_dict:
ValueError: not enough values to unpack (expected 2, got 1)
To fix this, we’ll have to find a way to get the key/value pairs instead of just the keys.
✅ Fix: use the .items() method to get key/value pairs
Getting the key/value pairs from a dict is simple: we just use the built-in .items() method of dicts:
my_dict = { 'a': 1, 'b': 2, 'c': 3 }
for k,v in my_dict.items():
print(k,v)
# -> a 1
# b 2
# c 3
What .items() does is it produces a list of tuples, just like we had in our first example. Except for one major difference: it’s guaranteed to always have tuples with just two (2) items in them. That means its safe for us to unpack them into two variables!
❌ Problem: you are trying to unpack a function’s return value
This is another very common situation in Python. Lots of functions, like some of the ones in the sockets package, return multiple values. If you supply too many variables for the number of values returned, you’ll get the “ValueError: not enough values to unpack” error.
Here’s an example of a function that returns not-enough variables for the number we’re expecting:
def get_a_thing():
return 1, 2
a, b, c = get_a_thing()
print(a, b, c)
Here, the function get_a_thing() returns a tuple of two (2) items: 1 and 2. Kind of a useless function, isn’t it? Whatever, it’s just an example. The point is, we’re unpacking its return value of two things into three things, variables a, b, and c. Unlike other languages, Python won’t just leave c undefined, it’ll throw this error:
Traceback (most recent call last):
File "/home/user/main.py", line 4, in <module>
a, b, c = get_a_thing()
ValueError: not enough values to unpack (expected 3, got 2)
Which means exactly what it says. On to the solutions!
✅ Fix 1: use the correct number of variables
The most obvious thing to do here, if possible, is to just use the correct number of variables to receive the return value:
def get_a_thing():
return 1, 2
a, b = get_a_thing()
print(a, b)
# -> 1 2
This will require (ugh) reading the documentation for the function and/or finding where it’s defined to take a look at what it’s returning. I know, I know. That’s a lot of work. Especially if it’s inherited code written by some guy that left the company years ago. If you can’t call him up, don’t worry, we have a foolproof solution…
Look at the error message. It tells you how many variables to expect 😉
✅ Fix 2: use just one variable
That’s right, we can just use one variable to receive whatever the function is returning. This is because functions that return multiple values with the syntax return "foo", "bar" are really just returning a tuple, ("foo", "bar"), which you can always just put into a single variable like so:
def get_a_thing():
return 1, 2
a = get_a_thing()
print(a)
# -> (1, 2)
This is in fact the only solution if the function can return variable length tuples. Of course, that’s a poorly written function, and you should probably go yell at whoever wrote it.
Conclusion
In this article, we covered what causes the Python error “ValueError: not enough values to unpack” and the various ways to fix it. Some causes are pretty common, such as trying to get key/value pairs out of a dict object. Fix this by using .items(). Other causes, like functions with multi-value return values of varying lengths, are both frustrating and stupid. Functions shouldn’t do that, or should at least warn you extensively in the documentation. I’ve only ever come across this once, and never in a popular package.
The bottom line is, always use the correct number of variables to unpack something, or just don’t do it at all. Or just use one, if it’s a function. Then you’ll have a tuple with everything in it.
That’s all for now, hope it helped!
1. First should understand the error meaning
Error not enough values to unpack (expected 3, got 2) means:
a 2 part tuple, but assign to 3 values
and I have written demo code to show for you:
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Function: Showing how to understand ValueError 'not enough values to unpack (expected 3, got 2)'
# Author: Crifan Li
# Update: 20191212
def notEnoughUnpack():
"""Showing how to understand python error `not enough values to unpack (expected 3, got 2)`"""
# a dict, which single key's value is two part tuple
valueIsTwoPartTupleDict = {
"name1": ("lastname1", "email1"),
"name2": ("lastname2", "email2"),
}
# Test case 1: got value from key
gotLastname, gotEmail = valueIsTwoPartTupleDict["name1"] # OK
print("gotLastname=%s, gotEmail=%s" % (gotLastname, gotEmail))
# gotLastname, gotEmail, gotOtherSomeValue = valueIsTwoPartTupleDict["name1"] # -> ValueError not enough values to unpack (expected 3, got 2)
# Test case 2: got from dict.items()
for eachKey, eachValues in valueIsTwoPartTupleDict.items():
print("eachKey=%s, eachValues=%s" % (eachKey, eachValues))
# same as following:
# Background knowledge: each of dict.items() return (key, values)
# here above eachValues is a tuple of two parts
for eachKey, (eachValuePart1, eachValuePart2) in valueIsTwoPartTupleDict.items():
print("eachKey=%s, eachValuePart1=%s, eachValuePart2=%s" % (eachKey, eachValuePart1, eachValuePart2))
# but following:
for eachKey, (eachValuePart1, eachValuePart2, eachValuePart3) in valueIsTwoPartTupleDict.items(): # will -> ValueError not enough values to unpack (expected 3, got 2)
pass
if __name__ == "__main__":
notEnoughUnpack()
using VSCode debug effect:
2. For your code
for name, email, lastname in unpaidMembers.items():
but error
ValueError: not enough values to unpack (expected 3, got 2)
means each item(a tuple value) in unpaidMembers, only have 1 parts:email, which corresponding above code
unpaidMembers[name] = email
so should change code to:
for name, email in unpaidMembers.items():
to avoid error.
But obviously you expect extra lastname, so should change your above code to
unpaidMembers[name] = (email, lastname)
and better change to better syntax:
for name, (email, lastname) in unpaidMembers.items():
then everything is OK and clear.
import cv2
import numpy as np
import math
def distance(x1, y1, x2, y2):
«»»
Calculate distance between two points
«»»
dist = math.sqrt(math.fabs(x2-x1)**2 + math.fabs(y2-y1)**2)
return dist
def find_color1(frame):
«»»
Filter «frame» for HSV bounds for color1 (inplace, modifies frame) & return coordinates of the object with that color
«»»
hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
hsv_lowerbound = np.array([102, 152, 0]) #replace THIS LINE w/ your hsv lowerb
hsv_upperbound = np.array([118, 255, 255])#replace THIS LINE w/ your hsv upperb
mask = cv2.inRange(hsv_frame, hsv_lowerbound, hsv_upperbound)
res = cv2.bitwise_and(frame, frame, mask=mask) #filter inplace
, cnts, = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
if len(cnts) > 0:
maxcontour = max(cnts, key=cv2.contourArea)
#Find center of the contour
M = cv2.moments(maxcontour)
if M['m00'] > 0 and cv2.contourArea(maxcontour) > 1000:
cx = int(M['m10']/M['m00'])
cy = int(M['m01']/M['m00'])
return (cx, cy), True
else:
return (700, 700), False #faraway point
else:
return (700, 700), False #faraway point
def find_color2(frame):
«»»
Filter «frame» for HSV bounds for color1 (inplace, modifies frame) & return coordinates of the object with that color
«»»
hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
hsv_lowerbound = np.array([40, 83, 0])#replace THIS LINE w/ your hsv lowerb
hsv_upperbound = np.array([101, 255, 255])#replace THIS LINE w/ your hsv upperb
mask = cv2.inRange(hsv_frame, hsv_lowerbound, hsv_upperbound)
res = cv2.bitwise_and(frame, frame, mask=mask)
,cnts, = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
if len(cnts) > 0:
maxcontour = max(cnts, key=cv2.contourArea)
#Find center of the contour
M = cv2.moments(maxcontour)
if M['m00'] > 0 and cv2.contourArea(maxcontour) > 2000:
cx = int(M['m10']/M['m00'])
cy = int(M['m01']/M['m00'])
return (cx, cy), True #True
else:
return (700, 700), True #faraway point
else:
return (700, 700), True #faraway point
cap = cv2.VideoCapture(0)
while(1):
_, orig_frame = cap.read()
if orig_frame is None:
break
#we'll be inplace modifying frames, so save a copy
copy_frame = orig_frame.copy()
(color1_x, color1_y), found_color1 = find_color1(copy_frame)
(color2_x, color2_y), found_color2 = find_color2(copy_frame)
#draw circles around these objects
cv2.circle(copy_frame, (color1_x, color1_y), 20, (255, 0, 0), -1)
cv2.circle(copy_frame, (color2_x, color2_y), 20, (0, 128, 255), -1)
if found_color1 and found_color2:
#trig stuff to get the line
hypotenuse = distance(color1_x, color1_x, color2_x, color2_y)
horizontal = distance(color1_x, color1_y, color2_x, color1_y)
vertical = distance(color2_x, color2_y, color2_x, color1_y)
angle = np.arcsin(vertical/hypotenuse)*180.0/math.pi
#draw all 3 lines
cv2.line(copy_frame, (color1_x, color1_y), (color2_x, color2_y), (0, 0, 255), 2)
cv2.line(copy_frame, (color1_x, color1_y), (color2_x, color1_y), (0, 0, 255), 2)
cv2.line(copy_frame, (color2_x, color2_y), (color2_x, color1_y), (0, 0, 255), 2)
#put angle text (allow for calculations upto 180 degrees)
angle_text = ""
if color2_y < color1_y and color2_x > color1_x:
angle_text = str(int(angle))
elif color2_y < color1_y and color2_x < color1_x:
angle_text = str(int(180 - angle))
elif color2_y > color1_y and color2_x < color1_x:
angle_text = str(int(180 + angle))
elif color2_y > color1_y and color2_x > color1_x:
angle_text = str(int(360 - angle))
#CHANGE FONT HERE
cv2.putText(copy_frame, angle_text, (color1_x-30, color1_y), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 128, 229), 2)
cv2.imshow('AngleCalc', copy_frame)
cv2.waitKey(5)
cap.release()
cv2.destroyAllWindows()
error
Traceback (most recent call last):
File «C:/Users/Besitzer/Real-Time-and-Static-Angles-Calculation-main/Real-Time-and-Static-Angles-Calculation-main/Angle_Findings Taha/color_based.py», line 72, in
(color1_x, color1_y), found_color1 = find_color1(copy_frame)
File «C:/Users/Besitzer/Real-Time-and-Static-Angles-Calculation-main/Real-Time-and-Static-Angles-Calculation-main/Angle_Findings Taha/color_based.py», line 21, in find_color1
, cnts, = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
ValueError: not enough values to unpack (expected 3, got 2)
[ WARN:1@4.056] global D:aopencv-pythonopencv-pythonopencvmodulesvideoiosrccap_msmf.cpp (539) `anonymous-namespace’::SourceReaderCB::~SourceReaderCB terminating async callback
Process finished with exit code 1
На чтение 5 мин Просмотров 12.7к. Опубликовано 22.11.2021
В этой статье мы рассмотрим из-за чего возникает ошибка ValueError: too many values to unpack и как ее исправить в Python.
Содержание
- Введение
- Что такое распаковка в Python?
- Распаковка списка в Python
- Распаковка списка с использованием подчеркивания
- Распаковка списка с помощью звездочки
- Что значит ValueError: too many values to unpack?
- Сценарий 1: Распаковка элементов списка
- Решение
- Сценарий 2: Распаковка словаря
- Решение
- Заключение
Введение
Если вы получаете ValueError: too many values to unpack (expected 2), это означает, что вы пытаетесь получить доступ к слишком большому количеству значений из итератора.
Ошибка Value Error — это стандартное исключение, которое может возникнуть, если метод получает аргумент с правильным типом данных, но недопустимым значением, или если значение, предоставленное методу, выходит за пределы допустимого диапазона.
В этой статье мы рассмотрим, что означает эта ошибка, в каких случаях она возникает и как ее устранить на примерах.
Что такое распаковка в Python?
В Python функция может возвращать несколько значений, и они могут быть сохранены в переменной. Это одна из уникальных особенностей Python по сравнению с другими языками, такими как C++, Java, C# и др.
Распаковка в Python — это операция, при которой значения итерабильного объекта будут присвоена кортежу или списку переменных.
Распаковка списка в Python
В этом примере мы распаковываем список элементов, где каждый элемент, который мы возвращаем из списка, должен присваиваться переменной в левой части для хранения этих элементов.
one, two, three = [1, 2, 3] print(one) print(two) print(three)
Вывод программы
Распаковка списка с использованием подчеркивания
Подчеркивание чаще всего используется для игнорирования значений; когда _ используется в качестве переменной, когда мы не хотим использовать эту переменную в дальнейшем.
one, two, _ = [1, 2, 3] print(one) print(two) print(_)
Вывод программы
Распаковка списка с помощью звездочки
Недостаток подчеркивания в том, что оно может хранить только одно итерируемое значение, но что если у вас слишком много значений, которые приходят динамически?
Здесь на помощь приходит звездочка. Мы можем использовать переменную со звездочкой впереди для распаковки всех значений, которые не назначены, и она может хранить все эти элементы.
one, two, *z = [1, 2, 3, 4, 5, 6, 7, 8] print(one) print(two) print(z)
Вывод программы
После того, как мы разобрались с распаковкой можно перейти к нашей ошибке.
Что значит ValueError: too many values to unpack?
ValueError: too many values to unpack возникает при несоответствии между возвращаемыми значениями и количеством переменных, объявленных для хранения этих значений. Если у вас больше объектов для присвоения и меньше переменных для хранения, вы получаете ошибку значения.
Ошибка возникает в основном в двух сценариях
Сценарий 1: Распаковка элементов списка
Давайте рассмотрим простой пример, который возвращает итерабильный объект из четырех элементов вместо трех, и у нас есть три переменные для хранения этих элементов в левой части.
В приведенном ниже примере у нас есть 3 переменные one, two, three но мы возвращаем 4 итерабельных элемента из списка.
one, two, three = [1, 2, 3, 4]
Вывод программы
Traceback (most recent call last):
File "/Users/krnlnx/Projects/Test/test.py", line 1, in <module>
one, two, three = [1, 2, 3, 4]
ValueError: too many values to unpack (expected 3)
Решение
При распаковке списка в переменные количество переменных, которые вы хотите распаковать, должно быть равно количеству элементов в списке.
Если вы уже знаете количество элементов в списке, то убедитесь, что у вас есть равное количество переменных в левой части для хранения этих элементов для решения.
Если вы не знаете количество элементов в списке или если ваш список динамический, то вы можете распаковать список с помощью оператора звездочки. Это обеспечит хранение всех нераспакованных элементов в одной переменной с оператором звездочка.
Сценарий 2: Распаковка словаря
В Python словарь — это набор неупорядоченных элементов, содержащих пары ключ-значение. Рассмотрим простой пример, который состоит из трех ключей, и каждый из них содержит значение, как показано ниже.
Если нам нужно извлечь и вывести каждую из пар ключ-значение в словаре, мы можем использовать итерацию элементов словаря с помощью цикла for.
Давайте запустим наш код и посмотрим, что произойдет
city = {"name": "Saint Petersburg", "population": 5000000, "country": "Russia"}
for k, v in city:
print(k, v)
Вывод программы
Traceback (most recent call last):
File "/Users/krnlnx/Projects/Test/test.py", line 3, in <module>
for k, v in city:
ValueError: too many values to unpack (expected 2)
В приведенном выше коде мы получаем ошибку, потому что каждый элемент в словаре «city» является значением.
В Python мы не должны рассматривать ключи и значения в словаре как две отдельные сущности.
Решение
Мы можем устранить ошибку с помощью метода items(). Функция items() возвращает объект представления, который содержит обе пары ключ-значение, сохраненные в виде кортежей.
Подробнее про итерацию словаря читайте по ссылке.
city = {"name": "Saint Petersburg", "population": 5000000, "country": "Russia"}
for k, v in city.items():
print(k, v)
Вывод программы
name Saint Petersburg population 5000000 country Russia
Примечание: Если вы используете Python 2.x, вам нужно использовать функцию iteritems() вместо функции items().
Заключение
В этой статье мы рассмотрели, почему в Python возникает ошибка «ValueError: too many values to unpack », разобрались в причинах и механизме ее возникновения. Мы также увидели, что этой ошибки можно избежать.
Posted by Marta on May 22, 2021 Viewed 48964 times
In this article, I will explain the main reason why you will encounter the Valueerror too many values to unpack error in python and a few different ways to fix it. I think it is essential to understand why this error occurs, just because if you have a good understanding of what caused it, you will avoid this error in the future and write better code.
This tutorial contains some code examples and possible ways to fix the error.
Too many values to unpack
Unpacking is quite a powerful feature in python. Unpacking will assign the values on the right-hand side to the variables on the left-hand side. Each of the values is assigned to one of the variables. Unpacking works when the number of variables and the numbers of values is the same. Every value has a corresponding variable.
See below a simple code snippet that will return the error Valueerror too many values to unpack
name1,name2 = ['Marta','Tristan','Gordon']
Check out the line above. There are three values on the right and only two variables on the left. The name Gordon will be left unassigned. The number of values on the right and the number of variables on the left don’t match. You can fix the code just by removing one of the values. See the code below:
name1,name2 = ['Marta','Tristan'] print(name1) print(name2)
Output:
For loop example: Too many values to unpack
Another case where the ‘Too many values to unpack’ error may occur when you are looping through dictionary’s entries. See the code snippet below that returns the error:
dict_example = {
'name': 'John',
'age':35
}
for key,value in dict_example:
print(key + " : " + str(value))
Output:
Traceback (most recent call last):
File line 5, in <module>
for key,value in dict_example:
ValueError: too many values to unpack (expected 2)
Why is the code above returning an error? At line 5, the issue is a dictionary used in a loop, by default, will return a list of keys. Unpacking one of the keys, which is one value, into two variables results in an unpacking error.
Solution #1
At the point of unpacking the dictionary entries, the number of values and the number of variables is not matching. One way to solve this is by using the dictionary .items() method. This method returns a list of tuples (key, value), two values for two variables. Problem solved! See the code below:
dict_example = {
'name': 'John',
'age':35
}
for key,value in dict_example.items():
print(key + " : " + str(value))
Output:
Solution #2
I think it is a good idea to see several ways to fix the error, to validate your understanding. Since the problem was having two variables and only one value to assign, another possible solution is to avoid unpacking. How can you do that? Just removing the value variable from the loop. See the code example below:
dict_example = {
'name': 'John',
'age':35
}
for key in dict_example: # Removed the value variable
print(key + " : " + str(dict_example.get(key)))
Output:
This code does the same as solution #1. It is just a different way to solve the same problem. The first solution is slightly more efficient; just you don’t have to search inside the loop.
Split example: Too many values to unpack
The unpacking error could arise when using the .split() method. The code below is the simplest case where using split returns a valueerror.
split1,split2='word1.word2.word3'.split('.')
Why is this code returning an error? The number of values on the right-hand side of the equal sign and the number of variables on the other side are not matching. The result of executing 'word1.word2.word3'.split('.') is a list containing three values: ['word1', 'word2', 'word3'].
Solution #1
The best way to avoid the unpacking error, in this case, is avoiding unpacking. The reason is that if you are not sure what the input of the split will be, you can’t be sure the outcome of splitting will always be two items. Therefore the safest option is avoiding unpacking.
How do you avoid unpacking? Just assigning the result to one variable. See the example below:
list='word1.word2.word3'.split('.')
This code will not raise any error.
Another example
Let’s see another example where you could encounter this unpacking issue. This issue can also arise when using the input() method. See the code example below:
a, b = input("Enter two numbers:")
print(a)
print(b)
The input() method will receive whatever the user type and save it as a string value. Therefore in the code example above, we are trying to assign one value to two variables. That means unpacking error. How can you solve it?
Solution #1
The safest and most straightforward solution is avoiding unpacking by just using one variable.
user_input = input("Enter two numbers:")
split_input=user_input.split()
a = split_input[0]
b = split_input[1]
print(a)
print(b)
Assuming the user enters two numbers separated by white space, this code won’t raise any error.
Solution #2
There is another way to fix the code below; however, this solution is not as safe and predictable as the previous one. Therefore I will encourage you to use the last approach when possible.
Another possible way to fix the code below is calling the .split() method right after receiving the input. That will split the string into a list. However, this approach is not error free. If the user entered more than two numbers, you would end up having the unpacking problem again.
a,b = input("Enter two numbers:")
Solution
a,b = input("Enter two numbers:").split()
print(a)
print(b)
Not enough values to unpack
We have seen the unpacking issue where you have more values than variables. It’s also possible having more variables than values. In that case, you will get a Not enough values to unpack error. The issue is the same, but the other way around, from left to right. See a code example below:
name1,name2,name3,name4 = ['Marta','Tristan','Gordon']
Output:
Traceback (most recent call last):
File line 4, in <module>
name1,name2,name3,name4 = ['Marta','Tristan','Gordon']
ValueError: not enough values to unpack (expected 4, got 3)
To prevent this problem, make sure the number of values on one side and the numbers of variables on the other side pair up. In this case, I can avoid the error just by removing the variable name4. See the code below:
name1,name2,name3 = ['Marta','Tristan','Gordon']
Knowledge Quiz Time!
Here is a chance to check how much you learned. See below a few quiz questions that will help you to confirm and reinforce your understanding. Find the solutions at the bottom of this article:
- What would this program output?
var1 = 'pear apple'.split(' ')
fruit1, fruit2, fruit3 = ['orange',var1]
print(fruit1)
A) ValueError: not enough values to unpack
B) orange
C) pear
2. What would this program output?
dict = {
'value1': 1,
'value2': 2,
'value3': 3
}
for key, value in dict.items():
print(value)
A) ValueError: too many values to unpack
B) 1 2 3
C) value1 value2 value3
Conclusion
To summarise, we have seen a few cases where the Valueerror: too many values to unpack error could occur and how you can fix it. You could make sure the values and the variables are pairing up. Another way to avoid this issue is by avoiding unpacking. I hope you enjoy this article, and understand this issue better to avoid it when you are programming.
Thank you so much for reading and supporting this blog!
Happy coding!
Solution
1.A, 2.B
Recommended articles
Unpacking syntax lets you separate the values from iterable objects. If you try to unpack more values than the total that exist in an iterable object, you’ll encounter the “ValueError: not enough values to unpack” error.
This guide discusses what this error means and why you may see it in your code. We’ll walk through an example of this error in action so you can see how it works.
Find Your Bootcamp Match
- Career Karma matches you with top tech bootcamps
- Access exclusive scholarships and prep courses
Select your interest
First name
Last name
Phone number
By continuing you agree to our Terms of Service and Privacy Policy, and you consent to receive offers and opportunities from Career Karma by telephone, text message, and email.
ValueError: not enough values to unpack
Iterable objects like lists can be “unpacked”. This lets you assign the values from an iterable object into multiple variables.
Unpacking is common when you want to retrieve multiple values from the response of a function call, when you want to split a list into two or more variables depending on the position of the items in the list, or when you want to iterate over a dictionary using the items() method.
Consider the following example:
name, address = ["John Doe", "123 Main Street"]
This code unpacks the values from our list into two variables: name and address. The variable “name” will be given the value “John Doe” and the variable address will be assigned the value “123 Main Street”.
You have to unpack every item in an iterable if you use unpacking. You cannot unpack fewer or more values than exist in an iterable. This is because Python would not know which values should be assigned to which variables.
An Example Scenario
We’re going to write a program that calculates the total sales of a product at a cheese store on a given day. To start, we’re going to ask the user to insert two pieces of information: the name of a cheese and a list of all the sales that have been made.
We can do this using an input() statement:
name = input("Enter the name of a cheese: ")
sales = input("Enter a comma-separated list of all purchases made of this cheese: ")
Our “sales” variable expects the user to insert a list of sales. Each value should be separated using a comma.
Next, define a function that calculates the total of all the sales made for a particular cheese. This function will also designate a cheese as a “top seller” if more than $50 has been sold in the last day.
def calculate_total_sales(sales):
split_sales = [float(x) for x in sales.split(",")]
total_sales = sum(split_sales)
if total_sales > 50.00:
top_seller = True
else:
top_seller = False
return [total_sales]
The split() method turns the values the user gives us into a list. We use a list comprehension to turn each value from our string into a float and put that number in a list.
We use the sum() method to calculate the total value of all the purchases for a given cheese based on the list that the split() method returns. We then use an if statement to determine whether a cheese is a top seller.
Our method returns an iterable with one item: the total sales made. We return an iterable so we can unpack it later in our program. Next, call our function:
total_sales, top_seller = calculate_total_sales(sales)
Our function accepts one parameter: the list of purchases. We unpack the result of our function into two parts: total_sales and top_seller.
Finally, print out the values that our function calculates:
print("Total Sales: $" + str(round(total_sales, 2))
print("Top Seller: " + str(top_seller))
We convert our variables to strings so we can concatenate them to our labels. We round the value of “total_sales” to two decimal places using the round() method. Let’s run our program and see if it works:
Enter the name of a cheese: Edam Enter a comma-separated list of all purchases made of this cheese: 2.20, 2.90, 3.30 Traceback (most recent call last): File "main.py", line 15, in <module> total_sales, top_seller = calculate_total_sales(sales) ValueError: not enough values to unpack (expected 2, got 1)
Our program fails to execute.
The Solution
The calculate_total_sales() function only returns one value: the total value of all the sales made of a particular cheese. However, we are trying to unpack two values from that function.
This causes an error because Python is expecting a second value to unpack. To solve this error, we have to return the “top_seller” value into our main program:
def calculate_total_sales(sales):
split_sales = [float(x) for x in sales.split(",")]
total_sales = sum(split_sales)
if total_sales > 50.00:
top_seller = True
else:
top_seller = False
return [total_sales, top_seller]
Our function now returns a list with two values: total_sales and top_seller. These two values can be unpacked by our program because they appear in a list. Let’s run our program and see if it works:
Enter the name of a cheese: Edam Enter a comma-separated list of all purchases made of this cheese: 2.20, 2.90, 3.30 Total Sales: $8.4 Top Seller: False
Our program now successfully displays the total sales of a cheese and whether that cheese is a top seller to the console.
Conclusion
The “ValueError: not enough values to unpack” error is raised when you try to unpack more values from an iterable object than those that exist. To fix this error, make sure the number of values you unpack from an iterable is equal to the number of values in that iterable.
Now you have the knowledge you need to fix this common Python error like an expert!
During a multiple value assignment, the ValueError: need more than 2 values to unpack occurs when either you have fewer objects to assign than variables, or you have more variables than objects.
Python has a very rich assignment feature. Python can store multiple values for variables in the assignment operator. Python functions can return a number of values to the calling function. The ValueError: need more than 2 values to unpack caused by the mismatch between the number of values returned and the number of variables in the assignment statement.
If the python function returns less objects than the available variables, the python interpreter can not assign the value to the excess variable. We ‘re going to see this value error and how to fix it in this article.
The older version of the python will throw different error “ValueError: not enough values to unpack (expected 3, got 2)“
Exceptions
Recent Python version
Traceback (most recent call last):
File "/Users/python/Desktop/test.py", line 1, in <module>
a, b, c, d = "Lion", "Tiger", "Monkey"
ValueError: need more than 3 values to unpack
[Finished in 0.0s with exit code 1]
Older Python version
Traceback (most recent call last):
File "./test.py", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 3)Root Cause
Python has an unique feature of returning multiple values in functions as well as assignment operators. The value error is due to either less values being returned than the variables available or not having enough objects for the variables. This error is caused by the mismatch between the number of variables and the number of values.
The total number of values returned must be the same as the number of variables returned. This is going to resolve this value error.
Solution 1
Find the total number of variables and the total number of values for the assignment operator. Add additional values to the assignment operator. The additional value is assigned to the variable. Passing the additional value to the variable will resolve this value error.
Program
a, b, c, d = "Lion", "Tiger", "Monkey"
print(a)
print(b)
print(c)
print(d)Output
Traceback (most recent call last):
File "/Users/python/Desktop/test.py", line 1, in <module>
a, b, c, d = "Lion", "Tiger", "Monkey"
ValueError: need more than 3 values to unpack
[Finished in 0.1s with exit code 1]Solution
a, b, c, d = "Lion", "Tiger", "Monkey", "Giraffe"
print(a)
print(b)
print(c)
print(d)Output
Lion
Tiger
Monkey
Giraffe
[Finished in 0.1s]Solution 2
Verify the assignment variables. If the number of assignment variables is greater than the total number of variables, delete the excess variable from the assignment operator. The number of objects returned, as well as the number of variables available are the same. This will resolve the value error.
Program
a, b, c, d = "Lion", "Tiger", "Monkey"
print(a)
print(b)
print(c)
print(d)Output
Traceback (most recent call last):
File "/Users/python/Desktop/test.py", line 1, in <module>
a, b, c, d = "Lion", "Tiger", "Monkey"
ValueError: need more than 3 values to unpack
[Finished in 0.1s with exit code 1]Solution
a, b, c = "Lion", "Tiger", "Monkey"
print(a)
print(b)
print(c)Output
Lion
Tiger
Monkey
[Finished in 0.0s]