TypeError: < str 和 int 实例之间不支持

str当我们在 type和的
值之间使用比较运算符时，会出现 Python“TypeError: ‘<‘ not supported between instances of ‘str’ and ‘int’” int。

要解决该错误，请在比较值之前将字符串转换为整数。

str 和 int 实例之间不支持类型错误

在字符串和整数之间使用比较运算符

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

主程序


my_str = '10'

my_int = 5

# ⛔️ TypeError: '<' not supported between instances of 'str' and 'int'
print(my_str < my_int)

我们在导致错误的不兼容类型（str 和 int）的值之间使用了比较运算符。

将字符串转为整数解决错误

要解决该错误，请确保您比较的值是兼容的类型。

主程序


my_str = '10'

my_int = 5

# ✅ convert str to int
print(int(my_str) < my_int)  # 👉️ False


if int(my_str) < my_int:
    print('my_str < my_int')
else:
    # 👇️ this runs
    print('my_str >= my_int')

我们使用int()类将字符串转换为整数。

如果需要将字符串转换为浮点数，也可以使用float()类。

主程序


my_str = '5.5'

my_int = 5

print(float(my_str) < my_int)  # 👉️ False

我们使用该类float()将字符串转换为浮点数，以便能够将其与整数进行比较。

浮点数和整数是兼容的类型，所以一切都按预期工作。

str()如果您打算比较 2 个字符串而不是 2 个数字，也可以使用该类。

该`input()`函数总是返回一个字符串

如果您使用input()内置函数，则用户输入的所有值都会转换为字符串（甚至是数值）。

主程序


from_input = input('Enter your fav number: ')
print(from_input)  # 👉️ 3
print(type(from_input))  # 👉️ <class 'str'>

my_int = 5

# ⛔️ TypeError: '<=' not supported between instances of 'str' and 'int'
print(from_input <= my_int)

输入总是返回字符串

输入函数将数据转换为字符串并返回。

即使用户输入一个数字，它也会在从返回之前转换为字符串input()。

要解决错误，请将字符串传递给int()(or float()) 类。

主程序


from_input = input('Enter your fav number: ')
print(from_input)  # 👉️ 3
print(type(from_input))  # 👉️ <class 'str'>

my_int = 5

print(int(from_input) <= my_int)  # 👉️ True

if int(from_input) <= my_int:
    print('success')

将字符串转换为整数

我们将字符串从input函数转换回整数并比较这两个数字。

如果您需要在用户输入无效整数时处理错误，则可以使用
try/except 语句。

主程序


try:
    from_input = input('Enter your fav number: ')
    print(from_input)  # 👉️ "abc"
    print(type(from_input))  # 👉️ <class 'str'>

    my_int = 5

    print(int(from_input) <= my_int)
except ValueError:
    print('Invalid integer supplied')

使用 try except 语句

比较运算符左右两侧的值必须是兼容类型。

使用 int 和字符串调用`min()`and函数`max()`

当您使用整数和字符串调用min()和
max()函数时，也会发生该错误。

主程序


num_1 = 15
num_2 = '20'  # 👈️ stores a string

# ⛔️ TypeError: '<' not supported between instances of 'str' and 'int'
print(min([num_1, num_2]))

# ⛔️ TypeError: '>' not supported between instances of 'int' and 'str'
print(max([num_2, num_1]))

该num_2变量存储一个字符串，因此不能与整数进行比较。

我们可以将该值转换为整数来解决错误。

主程序


num_1 = 15
num_2 = '20'  # 👈️ stores a string

print(min([num_1, int(num_2)])) # 👉️ 15

print(max([int(num_2), num_1])) # 👉️ 20

如果您需要将列表中的所有值转换为整数，请使用列表理解。

主程序


a_list = ['15', '20', 25, '30']

new_list = [int(x) for x in a_list]
print(new_list) # 👉️ [15, 20, 25, 30]

print(min(new_list)) # 👉️ 15
print(max(new_list)) # 👉️ 30

列表推导用于对每个元素执行某些操作或选择满足条件的元素子集。

在每次迭代中，我们将当前项目转换为整数并返回结果。

检查变量存储的类型

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

主程序


my_str = '13'

print(type(my_str))  # 👉️ <class 'str'>
print(isinstance(my_str, str))  # 👉️ True

my_int = 5

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

类型
类
返回对象的类型。

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

浮点数和整数等值是兼容的，可以进行比较。但是，您不能将字符串与整数进行比较。

int()在比较之前，必须使用类将字符串转换为整数。

TypeError: < list 和 int 实例之间不支持

list
当我们在 type和的值之间使用比较运算符时，会出现 Python“TypeError: ‘<‘ not supported between instances of ‘list’ and ‘int’” int。

要解决该错误，请访问特定索引处的列表或将列表的长度与整数进行比较。

list 和 int 实例之间不支持类型错误

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

主程序


my_list = [3, 5, 8]

my_int = 10

# ⛔️ TypeError: '<' not supported between instances of 'list' and 'int'
print(my_list < my_int)

我们在导致错误的不兼容类型（list 和 int）的值之间使用了比较运算符。

要解决该错误，请确保您正在比较的值属于兼容类型。

访问特定索引处的列表并比较值

解决错误的一种方法是访问列表中的特定项目。

主程序


my_list = [3, 5, 8]

my_int = 10

print(my_list[0] < my_int)  # 👉️ True

if my_list[0] < my_int:
    # 👇️ this runs
    print('success')

我们访问了索引处的列表项0（第一项）并将其与整数进行比较。

Python 索引是从零开始的，因此列表中的第一项的索引为0，最后一项的索引为-1或len(a_list) - 1。

主程序


my_list = [3, 5, 8]

print(my_list[0])  # 👉️ 3
print(my_list[1])  # 👉️ 5
print(my_list[2])  # 👉️ 8

确保你比较的值是兼容的类型

您要比较的值必须是兼容类型。int()如果列表包含包裹在字符串中的数字，请使用或类将字符串转换为数字
float()。

主程序


my_list = ['3', '5', '8']

my_int = 10

print(int(my_list[0]) < my_int)  # 👉️ True

列表存储的是字符串，因此我们不得不int()在比较之前使用该类将字符串转换为整数。

根据比较过滤列表中的整数

如果您打算根据比较过滤掉列表中的整数，请使用列表理解。

主程序


my_list = [3, 5, 8, 10, 15]

new_list = [x for x in my_list if x > 7]

print(new_list)  # 👉️ [8, 10, 15]

该示例返回一个新列表，其中仅包含大于的值7。

比较列表的长度和整数

如果您打算将列表的长度与整数进行比较，请使用该len()
函数。

主程序


my_list = [3, 5, 8]

my_int = 10

print(len(my_list) > my_int)  # 👉️ False

print(len(my_list))  # 👉️ 3

if len(my_list) < my_int:
    # 👇️ this runs
    print("The list's length is less than 10")

len ()函数返回对象的长度（项目数）。

该函数采用的参数可以是序列（字符串、元组、列表、范围或字节）或集合（字典、集合或冻结集合）。

将列表中项目的总和与整数进行比较

如果您打算将列表中项目的总和与整数进行比较，请使用
sum()函数。

主程序


my_list = [3, 5, 8]

my_int = 10

print(sum(my_list) > my_int)  # 👉️ True

print(sum(my_list))  # 👉️ 16

if sum(my_list) > my_int:
    # 👇️ this runs
    print('The sum is greater than 10')

sum函数接受一个可迭代对象，从左到右对其项目求和并返回总数。

比较运算符左右两侧的值必须是兼容类型。

检查变量存储的类型

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

主程序


my_list = [3, 5, 8]

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

my_int = 10

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

类型
类
返回对象的类型。

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

TypeError > 在 float 和 str 实例之间不支持

float
当我们在 type和的值之间使用比较运算符时，会出现 Python“TypeError: ‘>’ not supported between instances of ‘float’ and ‘str’” str。

要解决该错误，请在比较值之前将字符串转换为浮点数。

float 和 str 实例之间不支持类型错误

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

主程序


my_float = 1.1

my_str = '2.2'

# ⛔️ TypeError: '>' not supported between instances of 'float' and 'str'
print(my_float > my_str)

我们在导致错误的不兼容类型（float 和 str）的值之间使用了比较运算符。

将字符串转为浮点数解决错误

要解决该错误，请确保您正在比较的值属于兼容类型。

主程序


my_float = 1.1

my_str = '2.2'

# ✅ convert str to float
print(my_float > float(my_str))  # 👉️ False

if my_float > float(my_str):
    print('true')
else:
    # 👇️ this runs
    print('false')

我们使用该类float()将字符串转换为浮点数。int()如果需要将字符串转换为整数，也可以使用该类。

str()如果您打算比较 2 个字符串而不是 2 个数字，也可以使用该类。

解决使用时的错误`pandas`

如果使用pandas，请确保将列中的项目转换为浮动。

主程序


import pandas as pd

d = {'col1': ['1.1', '2.2'], 'col2': ['3.3', '4.4']}
df = pd.DataFrame(data=d)

# ✅ cast items to float
df['col1'] = df['col1'].astype(float)

print(3.14 > df['col1'][0]) # 👉️ True

如果你打算比较 2 个字符串，你也可以使用str()类而不是。float

该`input()`函数总是返回一个字符串值

请注意，input()即使用户提供了浮点数，内置函数也会返回一个字符串。

主程序


my_float = 1.1

from_input = input('Enter your fav number: ')
print(from_input)  # 👉️ 2.2
print(type(from_input))  # 👉️ <class 'str'>


# ⛔️ TypeError: '<' not supported between instances of 'float' and 'str'
print(my_float < from_input)

带浮点数的输入函数

输入函数将数据转换为字符串并返回。

即使用户输入一个数字，它也会在从返回之前转换为字符串input()。

要解决错误，请将字符串传递给float()(or int()) 类。

主程序


my_float = 1.1

from_input = input('Enter your fav number: ')
print(from_input)  # 👉️ 2.2
print(type(from_input))  # 👉️ <class 'str'>


print(my_float < float(from_input))  # 👉️ True

将输入值转换为浮点数

我们将字符串从input函数转换回 afloat并比较这两个数字。

try/except如果您需要在用户输入无效浮点数时处理错误，则可以使用语句。

主程序


my_float = 1.1

try:
    from_input = input('Enter your fav number: ')
    print(from_input)  # 👉️ abc
    print(type(from_input))  # 👉️ <class 'str'>

    print(my_float < float(from_input))

except ValueError:
    # 👇️ this runs
    print('Invalid float supplied')

提供的浮点数无效

比较运算符左右两侧的值必须是兼容类型。

使用浮点数和字符串调用`min()`and函数`max()`

当您使用浮点数和字符串调用min()and函数时，也会发生该错误。max()

主程序


num_1 = 1.1
num_2 = '2.2'  # 👈️ stores a string

# ⛔️ TypeError: '<' not supported between instances of 'str' and 'float'
print(min([num_1, num_2]))

# ⛔️ TypeError: '>' not supported between instances of 'float' and 'str'
print(max([num_2, num_1]))

该num_2变量存储的是一个字符串，因此不能与浮点数进行比较。

我们可以将值转换为浮点数来解决错误。

主程序


num_1 = 1.1
num_2 = '2.2'  # 👈️ stores a string

print(min([num_1, float(num_2)]))  # 👉️ 1.1

print(max([float(num_2), num_1]))  # 👉️ 2.2

如果您需要将列表中的所有值转换为浮点数，请使用列表理解。

主程序


a_list = ['1.1', '2.2', 3.3, '4.4']

new_list = [float(x) for x in a_list]
print(new_list)  # 👉️ [1.1, 2.2, 3.3, 4.4]

print(min(new_list))  # 👉️ 1.1
print(max(new_list))  # 👉️ 4.4

列表推导用于对每个元素执行某些操作或选择满足条件的元素子集。

在每次迭代中，我们将当前项转换为浮点数并返回结果。

检查变量存储的类型

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

主程序


my_float = 1.1

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

my_str = '3.14'

print(type(my_str))  # 👉️ <class 'str'>
print(isinstance(my_str, str))  # 👉️ True

类型
类
返回对象的类型。

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

TypeError > tuple 和 int 实例之间不支持

tuple
当我们在 type和的值之间使用比较运算符时，会出现 Python“TypeError: ‘>’ not supported between instances of ‘tuple’ and ‘int’” int。

要解决该错误，请访问特定索引处的元组或将元组的长度与整数进行比较。

tuple 和 int 实例之间不支持类型错误

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

主程序


my_tuple = 2, 4, 6

my_int = 5

# ⛔️ TypeError: '>' not supported between instances of 'tuple' and 'int'
print(my_tuple > my_int)

我们在导致错误的不兼容类型（元组和整数）的值之间使用了比较运算符。

要解决该错误，请确保您正在比较的值在比较之前是兼容的类型。

访问特定索引处的元组

解决错误的一种方法是访问元组中的特定项。

主程序


my_tuple = 2, 4, 6

my_int = 5

print(my_tuple[0] > my_int)  # 👉️ False

if my_tuple[0] > my_int:
    print('yes')
else:
    # 👇️ this runs
    print('no')

我们访问了索引处的元组项0（第一项）并将其与整数进行比较。

Python 索引是从零开始的，因此元组中的第一项的索引为0，最后一项的索引为-1or len(my_tuple) - 1。

如果元组中的值是字符串类型，请int()在比较之前使用该类将它们转换为整数。

主程序


my_tuple = ('2', '4', '6')

my_int = 5

print(int(my_tuple[0]) > my_int)  # 👉️ False

if int(my_tuple[0]) > my_int:
    print('yes')
else:
    # 👇️ this runs
    print('no')

您要比较的值必须是兼容类型。如果元组包含包裹在字符串中的数字，则使用或类将字符串转换为数字。 int()float()

根据比较过滤元组

如果您打算根据比较过滤掉元组中的整数，请使用列表理解。

主程序


my_tuple = 2, 4, 6, 8

my_int = 5

new_tuple = tuple([x for x in my_tuple if x > my_int])

print(new_tuple)  # 👉️ (6, 8)

该示例返回一个仅包含大于 5 的元素的元组。

比较一个元组的长度和一个整数

如果您打算将元组的长度与整数进行比较，请使用该len()
函数。

主程序


my_tuple = 2, 4, 6, 8

my_int = 5

print(len(my_tuple) > my_int)  # 👉️ False

print(len(my_tuple))  # 👉️ 4

len ()函数返回对象的长度（项目数）。

该函数采用的参数可以是序列（字符串、元组、列表、范围或字节）或集合（字典、集合或冻结集合）。

元组在 Python 中是如何构造的

万一你错误地声明了一个元组，元组有多种构造方式：

使用一对括号()创建一个空元组
使用尾随逗号 –a,或(a,)
用逗号分隔项目 –a, b或(a, b)
使用tuple()构造函数

将元组的总和与整数进行比较

如果您打算将元组中项目的总和与整数进行比较，请使用该
sum()函数。

主程序


my_tuple = 2, 4, 6, 8

my_int = 5

print(sum(my_tuple) > my_int)  # 👉️ True

print(sum(my_tuple))  # 👉️ 20

该sum函数接受一个可迭代对象，从左到右对其项求和并返回总数。

比较运算符左右两侧的值必须是兼容类型。

打印变量的类型

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

主程序


my_tuple = 2, 4, 6, 8

print(type(my_tuple))  # 👉️ <class 'tuple'>
print(isinstance(my_tuple, tuple))  # 👉️ True

my_int = 5

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

类型
类
返回对象的类型。

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

‘>’ 在 ‘method’ 和 ‘int’ 的实例之间不被支持

当我们在方法和整数之间使用比较运算符时，会出现 Python“TypeError: ‘>’ not supported between instances of ‘method’ and ‘int’”。

要解决该错误，请确保调用带有括号的方法，例如
my_method().

方法和 int 实例之间不支持类型错误

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

主程序


class Employee():
    def get_salary(self):
        return 100


emp1 = Employee()

my_int = 10

# ⛔️ TypeError: '>' not supported between instances of 'method' and 'int'
print(emp1.get_salary > my_int) # 👈️ forgot to call method

我们忘记用括号调用方法，例如，所以我们的代码实际上试图比较一个方法和一个整数。 emp.get_salary()

调用解决错误的方法

要解决错误，请确保调用该方法。

主程序


class Employee():
    def get_salary(self):
        return 100


emp1 = Employee()

my_int = 10

print(emp1.get_salary() > my_int)  # 👉️ True

我们使用括号来调用该方法，所以现在我们将方法的返回值与一个整数进行比较。

如果您的方法接受参数，请确保在调用它时传递它们，例如. emp1.get_salary(10, 20)

主程序


class Employee():
    def get_salary(self, num):
        return 100 * num


emp1 = Employee()

my_int = 10

print(emp1.get_salary(2) > my_int)  # 👉️ True

print(emp1.get_salary(2))  # 👉️ 200

我们在方法调用中传递了一个参数

您可能还会收到错误“TypeError：‘>’在‘function’和‘int’的实例之间不受支持”。

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

主程序


def get_num():
    return 50


my_int = 10

# ⛔️ TypeError: '>' not supported between instances of 'function' and 'int'
print(get_num > my_int) # 👈️ forgot to call method

函数实例和 int 之间不支持类型错误

get_num我们忘记用括号调用函数。

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

主程序


def get_num(num):
    return 50 * num


my_int = 10

print(get_num(5) > my_int)  # 👉️ True

print(get_num(5))  # 👉️ 250

我们使用括号来调用函数，所以现在我们将函数的返回值与一个整数进行比较。

如果您的函数接受参数，请确保提供它们。

TypeError: < str 和 int 实例之间不支持

目录

TypeError: < not supported between instances of str and int