类型错误：无法在 Python 中解压不可迭代的“X”对象

作者

目录

TypeError: cannot unpack non-iterable int object in Python

  1. TypeError：无法在 Python 中解压不可迭代的 INT 对象
  2. TypeError：无法解压不可迭代的 FUNCTION 对象
  3. 类型错误：无法解压不可迭代的 FLOAT 对象
  4. 类型错误：无法解压不可迭代的 NoneType 对象

类型错误：无法在 Python 中解压不可迭代的 int 对象

当我们尝试解包一个整数值时，会出现 Python“TypeError: cannot unpack non-iterable int object”。

要解决该错误，请追踪变量在何处被分配了一个整数，并将分配更正为一个可迭代对象，例如一个列表或一个整数元组。

typeerror 无法解压不可迭代的 int 对象

下面是错误如何发生的示例。

主程序
# ⛔️ TypeError: cannot unpack non-iterable int object
a, b = 10

错误原因

我们正在尝试解压一个整数，但整数是不可迭代的。

解包元组或整数列表

您可以使用元组或整数列表。

主程序
a, b = (10, 20)

print(a)  # 👉️ 10
print(b)  # 👉️ 20

为了能够使用 unpacking，变量需要与 iterable 中的值一样多。

如果需要将多个变量初始化为0.

主程序
a, b, c = 0, 0, 0

print(a, b, c)  # 👉️ 0, 0, 0

可以使用相同的方法来解压缩列表。

主程序
a, b = [10, 20]

print(a)  # 👉️ 10
print(b)  # 👉️ 20

解包调用函数的结果

如果要解包调用函数的结果，请确保从函数返回元组或整数列表。

主程序
def get_list():
    return [10, 20]


a, b = get_list()

print(a)  # 👉️ 10
print(b)  # 👉️ 20

该get_list函数返回一个整数列表，因此我们可以将整数解包为变量。

将整数的个别数字分配给变量

如果您需要将整数的各个数字分配给变量，请将整数转换为字符串。

主程序
a, b, c = str(123)

print(a)  # 👉️ '1'
print(b)  # 👉️ '2'
print(c)  # 👉️ '3'

与整数不同，字符串是可迭代的。请注意，各个变量存储字符串，因此如果需要将它们转换回整数，则必须将它们传递给
int()类。

在解包之前检查变量是否不存储整数

if如果您需要在解包之前检查变量是否不存储整数，请使用语句。

主程序
example = 10

if not isinstance(example, int):
    a, b = example
    print(a, b)
else:
    # 👇️ this runs
    print('Variable stores an integer')

该变量存储一个整数，因此else块运行。

或者，如果变量存储整数，则可以将变量重新分配给可迭代对象。

主程序
example = 10

if isinstance(example, int):
    example = (0, 0)
    a, b = example

    print(a, b)  # 👉️ 0, 0

我们检查example变量是否存储了一个整数，如果是，我们将它重新分配给一个元组。

遍历具有索引访问权限的列表

错误的另一个常见原因是试图遍历具有索引访问权限的整数列表。

主程序
a_list = [10, 20, 30, 40]

# ⛔️ TypeError: cannot unpack non-iterable int object
for index, item in a_list:
    print(index, item)

代码示例导致错误，因为我们试图解包列表中的整数之一。

相反，使用该enumerate()函数遍历列表并访问当前迭代的索引。

主程序
a_list = [10, 20, 30, 40]

for index, item in enumerate(a_list):
    print(index, item) # 0 10, 1 20, 2 30, ...

enumerate函数接受一个可迭代对象并返回一个包含元组的枚举对象，其中第一个元素是索引，第二个元素是相应的项目。

主程序
my_list = ['bobby', 'hadz', 'com']

for index, item in enumerate(my_list):
    print(index, item)  # 👉️ 0 bobby, 1 hadz, 2 com

检查变量存储的类型

如果您不确定变量存储的对象类型，请使用类type()
。

主程序
my_int = 10

print(type(my_int))  # 👉️ <class 'int'>
print(isinstance(my_int, int))  # 👉️ True

my_list = [0, 0]

print(type(my_list))  # 👉️ <class 'list'>
print(isinstance(my_list, list))  # 👉️ True

类型
类
返回对象的类型。

如果传入的对象是传入类的实例或子类，则isinstance函数返回
。True

目录

  1. TypeError：无法解压不可迭代的 FUNCTION 对象
  2. 类型错误：无法解压不可迭代的 FLOAT 对象
  3. 类型错误：无法解压不可迭代的 NoneType 对象

TypeError: 无法解压不可迭代的函数对象

当我们尝试解包函数对象而不是可迭代对象时，会出现 Python“TypeError: cannot unpack non-iterable function object”。

要解决该错误，请确保使用括号调用该函数，例如
my_function()并从该函数返回一个可迭代对象。

typeerror 无法解压不可迭代的函数对象

下面是错误如何发生的示例。

主程序
def get_list():
    return ['one', 'two']


# ⛔️ TypeError: cannot unpack non-iterable function object
a, b = get_list  # 👈️ forgot to call function
我们忘记用括号调用函数，例如get_list()，所以我们的代码实际上试图解包函数对象而不是列表。

调用带括号的函数解决错误

要解决错误，请确保调用该函数。

主程序
def get_list():
    return ['one', 'two']


a, b = get_list()

print(a)  # 👉️ 'one'
print(b)  # 👉️ 'two'

我们使用括号来调用函数，所以现在我们迭代函数返回的列表。

请注意，分配左侧的值必须与列表中的项目一样多。

如果你的函数有任何参数，你必须在调用它时提供它们，例如my_func(10, 20)。
主程序
def get_list(x, y):
    return [x, y]


a, b = get_list(10, 20)

print(a)  # 👉️ 10
print(b)  # 👉️ 20

确保从函数返回一个可迭代对象，例如列表或元组。

主程序
a, b = (10, 20)

print(a)  # 👉️ 10
print(b)  # 👉️ 20

变量需要与可迭代对象中的值一样多。

主程序
a, b, c = (10, 20, 30)

print(a)  # 👉️ 10
print(b)  # 👉️ 20
print(c)  # 👉️ 30

如果左边的值多于或少于 iterable 中的值，则会引发错误。

检查变量存储的类型

如果您不确定变量存储的对象类型，请使用类type()
。

主程序
def get_list():
    return ['one', 'two']


print(type(get_list))  # 👉️ <class 'function'>
print(callable(get_list))  # 👉️ True


my_list = ['a', 'b', 'c']

print(type(my_list))  # 👉️ <class 'list'>
print(isinstance(my_list, list))  # 👉️ True

类型
类
返回对象的类型。

如果传入的对象是传入类的实例或子类，则isinstance函数返回
。True

可调用函数将一个对象作为参数，True如果该对象看起来可调用则返回，否则False返回。

如果callable()函数返回True，调用对象仍有可能失败，但是，如果返回False，调用对象将永远不会成功。

目录

  1. 类型错误：无法解压不可迭代的 FLOAT 对象
  2. 类型错误：无法解压不可迭代的 NoneType 对象

类型错误：无法解压不可迭代的浮点对象

当我们尝试解包浮点值时，会出现 Python“TypeError: cannot unpack non-iterable float object”。

要解决该错误，请跟踪变量在何处分配了浮点数并将分配更正为可迭代对象，例如浮点数列表或元组。

typeerror 无法解压不可迭代的浮点对象

下面是错误如何发生的示例。

主程序
my_float = 3.1

# ⛔️ TypeError: cannot unpack non-iterable float object
a, b = my_float

我们正在尝试解包一个浮点数，但浮点数是不可迭代的。

解包一个列表或一个浮点数元组

您可以使用元组或浮点数列表。

主程序
my_tuple = (3.1, 6.2)

a, b = my_tuple

print(a)  # 👉️ 3.1
print(b)  # 👉️ 6.2

变量需要与可迭代对象中的值一样多。

如果左侧的值多于或少于赋值右侧的值，则会引发错误。

如果需要将多个变量初始化为0.

主程序
a, b, c = 0, 0, 0

print(a, b, c)  # 👉️ 0, 0, 0

将调用函数的结果解包到变量中

如果要解包调用函数的结果，请确保从函数返回元组或浮点数列表。

主程序
def get_list():
    return [3.1, 6.2]


a, b = get_list()

print(a)  # 👉️ 3.1
print(b)  # 👉️ 6.2

该get_list函数返回一个浮点数列表，因此我们可以将浮点数解包为变量。

在解包之前检查变量是否不存储浮点数

if如果您需要在解包之前检查变量是否不存储浮点数，请使用语句。

主程序
example = 3.1

if not isinstance(example, float):
    a, b = example
else:
    # 👇️ this runs
    print('Variable stores a float')

或者，如果变量存储浮点数，则可以将变量重新分配给可迭代对象。

主程序
example = 3.1

if isinstance(example, float):
    example = (0, 0)
    a, b = example

    print(a, b)  # 👉️ 0, 0

我们
检查示例变量是否存储了一个浮点数。

如果是，我们将其重新分配给包含 2 个值的元组。

打印变量的类型

如果您不确定变量存储的对象类型，请使用类type()
。

主程序
my_float = 3.14

print(type(my_float))  # 👉️ <class 'float'>
print(isinstance(my_float, float))  # 👉️ True

my_list = [3.1, 6.2]
print(type(my_list))  # 👉️ <class 'list'>
print(isinstance(my_list, list))  # 👉️ True

类型
类
返回对象的类型。

如果传入的对象是传入类的实例或子类，则isinstance函数返回
。True

TypeError: 无法解压不可迭代的 NoneType 对象

当我们尝试解包一个None值时，会出现 Python“TypeError: cannot unpack non-iterable NoneType object”。

要解决该错误，请追踪变量在何处被分配了 None 值并将分配更正为可迭代对象，例如列表或元组。

类型错误无法解压不可迭代的非类型对象

下面是错误如何发生的示例。

主程序
# ⛔️ TypeError: cannot unpack non-iterable NoneType object
a, b = None

我们正在尝试解包一个None值，但None值是不可迭代的。

声明多个存储的变量None

如果您需要声明存储None在同一行的多个变量，请None用逗号分隔多个值。

主程序
a, b = None, None

print(a)  # 👉️ None
print(b)  # 👉️ None

分配的左侧和右侧的值数必须匹配。

如果左侧的值更多或更少，则会引发错误。

在解包之前检查变量是否不存储 None

if如果您需要

在解包之前检查变量是否未存储 None值，请使用语句。

主程序
example = None

if example is not None:
    a, b = example
else:
    # 👇️ this runs
    print('variable stores a None value')

该if块仅在变量未存储None值时运行，因此不会引发错误。

或者，如果变量存储
None.

主程序
example = None

if example is None:
    example = [10, 20, 30]

a, b, c = example

print(a)  # 👉️ 10
print(b)  # 👉️ 20
print(c)  # 👉️ 30

如果变量存储 None，我们将其设置为包含 3 个值的列表并解压缩这些值。

追踪变量设置为 None 的位置

要解决该错误，您必须找到为变量赋值的位置
None并更正赋值。

最常见的None价值来源是：

  1. 有一个不返回任何东西的函数（None隐式返回）。
  2. 将变量显式设置为None.
  3. 将变量分配给调用不返回任何内容的内置函数的结果。
  4. 具有仅在满足特定条件时才返回值的函数。

不返回值的函数None在 Python 中返回

不显式返回值的函数 return None。

主程序
# 👇️ this function returns None
def get_list():
    print(['one', 'two'])


# ⛔️ TypeError: cannot unpack non-iterable NoneType object
a, b = get_list()

您可以使用return 语句从函数返回值。

主程序
def get_list():
    return ['one', 'two']

a, b = get_list()

print(a)  # 👉️ 'one'
print(b)  # 👉️ 'two'

该函数现在返回一个包含 2 个元素的列表。

许多内置方法返回 None

请注意，有许多内置函数（例如sort()）可以就地改变原始对象并返回None。

确保您没有将调用一个的结果存储在变量中。

主程序
my_list = ['c', 'b', 'a']


# ⛔️ TypeError: cannot unpack non-iterable NoneType object
x, y, z = my_list.sort()

这些sort函数和许多其他内置
函数返回None，因为它们改变了原始对象。

相反，调用sort()列表并在之后解压缩值。

主程序
my_list = ['c', 'b', 'a']

my_list.sort()

x, y, z = my_list

print(x)  # 👉️ a
print(y)  # 👉️ b
print(z)  # 👉️ c

有一个只有在满足条件时才返回值的函数

错误的另一个常见原因是具有仅在满足条件时才返回值的函数。

主程序
def get_list(l):
    if len(l) > 3:
        return l


my_list = get_list(['one', 'two', 'three'])
print(my_list)  # 👉️ None

# ⛔️ TypeError: cannot unpack non-iterable NoneType object
a, b, c = my_list

if函数中的语句仅get_list在传入参数的长度大于 时运行3。

在所有其他情况下，该函数不返回任何内容并最终隐式返回None。

要解决错误，您要么必须检查函数是否没有返回
None，要么在不满足条件时返回默认值。

主程序
def get_list(l):
    if len(l) > 3:
        return l

    return ['', '', ''] # 👈️ return default value if condition not met


my_list = get_list(['one', 'two', 'three'])
print(my_list)  # 👉️ ['', '', '']

a, b, c = my_list

print(a, b, c)  # 👉️ "", "", ""

现在，无论条件是否满足，函数都保证返回一个值。