类型错误：列表索引必须是整数或切片，而不是 str

作者

目录

TypeError: list indices must be integers or slices, not str

  1. 类型错误：LIST 索引必须是整数或切片，而不是 str
  2. TypeError：TUPLE 索引必须是整数或切片，而不是 str
  3. TypeError：SLICE 索引必须是整数或无或具有_ _索引_ _方法

类型错误：列表索引必须是整数或切片，而不是 str

当我们使用字符串而不是整数来访问特定索引处的列表时，会出现 Python“TypeError: list indices must be integers or slice, not str”。

要解决该错误，请使用该类int()将字符串转换为整数，例如my_list[int(my_str)].

类型错误列表索引必须是整数或切片而不是 str

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

主程序
my_str = '1'

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

# ⛔️ TypeError: list indices must be integers or slices, not str
result = my_list[my_str]

错误是因为我们使用字符串作为列表索引。

主程序
a_list = ['a', 'b', 'c', 'd', 'e']

# ✅ indices must be integers
print(a_list[0]) # 👉️ 'a'
print(a_list[1]) # 👉️ 'b'

使用整数或切片作为列表索引

要解决该错误，请使用整数或切片作为列表索引。

主程序
my_str = '1'

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

# ✅ convert str to int
result = my_list[int(my_str)]

print(result)  # 👉️ 'b'

我们使用int()类将字符串转换为整数，以便能够访问索引处的列表。

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

如果需要获取列表的一部分，还需要将索引转换为整数。

主程序
start_index = '0'
stop_index = '2'

a_list = ['a', 'b', 'c', 'd', 'e']

new_list = a_list[int(start_index):int(stop_index)]

print(new_list)  # 👉️ ['a', 'b']

请注意，我们使用该类int()将两个值都转换为整数。

列表切片的语法是
a_list[start:stop:step].

主程序
a_list = ['a', 'b', 'c', 'd', 'e']

print(a_list[0:2]) # 👉️ ['a', 'b']

print(a_list[1:3]) # 👉️ ['b', 'c']

索引start是包含的，stop索引是排他的（最多，但不包括）。

如果您需要遍历一个列表并访问当前迭代的索引，请使用enumerate().

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

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

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

您还可以使用该类range()来访问索引。

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

for index in range(len(my_list)):
    # 0 bobby
    # 1 hadz
    # 2 com
    print(index, my_list[index])

检查一个项目是否在列表中

如果您需要检查某个值是否在列表中，请使用in运算符。

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

if 'a' in a_list:
    # 👇️ this runs
    print('The value is in the list')
else:
    print('The value is not in the list')

print('a' in a_list)  # 👉️ True
print('Z' in a_list)  # 👉️ False

如果值在列表中，则运算符返回，否则in返回
。Truefalse

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

请注意，input()即使用户输入整数，该函数也总是返回一个字符串。

主程序
a_list = ['a', 'b', 'c', 'd']

index = input('Enter an index: ')

print(index) # 👉️ '1'
print(type(index)) # 👉️ string

# ⛔️ TypeError: list indices must be integers or slices, not str
print(a_list[index])

输入总是返回字符串

该input()函数将提供的值转换为字符串并返回它。

要解决该错误，请int()在访问列表之前使用该类将值转换为整数。

主程序
a_list = ['a', 'b', 'c', 'd']

# ✅ convert to integer
index = int(input('Enter an index: '))

print(index)  # 👉️ 1
print(type(index))  # 👉️ <class 'int'>

print(a_list[index])  # 👉️ b

将输入转换为整数

使用字典列表或字典列表

如果您打算声明字典，请确保使用花括号（而不是方括号）。

主程序
my_dict = {}

my_dict['name'] = 'Bobby Hadz'
my_dict['age'] = 30

print(my_dict)  # 👉️ {'name': 'Bobby Hadz', 'age': 30}

如果您正在迭代字典列表，请确保在每次迭代时访问字典的键值对。

主程序
my_list = [
    {'id': 1, 'name': 'Alice'},
    {'id': 2, 'name': 'Bob'},
    {'id': 3, 'name': 'Carl'},
]

for entry in my_list:
    print(f'Employee id: {entry["id"]}')
    print(f'Employee name: {entry["name"]}')

我们使用for循环遍历字典列表。

该entry变量在每次迭代时存储一个字典，因此您可以通过特定键访问它以获取相应的值。

如果需要访问当前迭代的索引，请使用该enumerate()
函数。

主程序
my_list = [
    {'id': 1, 'name': 'Alice'},
    {'id': 2, 'name': 'Bob'},
    {'id': 3, 'name': 'Carl'},
]

for index, dictionary in enumerate(my_list):
    print(index, dictionary)
    print(dictionary['id'], dictionary['name'])

您可以使用索引访问列表中的特定字典，然后访问字典中的键。

主程序
my_list = [
    {'id': 1, 'name': 'Alice'},
    {'id': 2, 'name': 'Bob'},
    {'id': 3, 'name': 'Carl'},
]

result = my_list[0]['name']
print(result)  # 👉️ 'Alice'

我们访问索引处的列表项0，然后访问name字典的键。

获取列表值的索引

list.index()如果您需要获取列表中某个值的索引，请使用该方法。

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

print(a_list.index('a')) # 👉️ 0
print(a_list.index('b')) # 👉️ 1

该list.index()方法返回其值等于提供的参数的第一个项目的索引。

使用带有列表值的字典

如果您有一个包含列表值的字典，请在访问索引之前访问特定的键。

主程序
my_dict = {
    'fruits': ['apple', 'banana', 'kiwi']
}

result = my_dict['fruits'][0]
print(result)  # 👉️ 'apple'

如果您需要遍历字典，请使用该dict.items()方法。

主程序
my_dict = {'name': 'Alice', 'age': 30}

for key, value in my_dict.items():
    print(key, value)  # 👉️ name Alice, age 30

dict.items
方法返回字典项（（键，值）对）的新视图。

在访问它们之前将 JSON 字符串解析为原生 Python 对象

如果在使用 JSON 字符串时出现错误，请确保在访问特定项目之前将 JSON 解析为本机 Python 对象。

主程序
import json

my_json = json.dumps(
    [
        {'id': 1, 'name': 'Alice'},
        {'id': 2, 'name': 'Bob'},
        {'id': 3, 'name': 'Carl'},
    ]
)

print(type(my_json))  # 👉️ <class 'str'>

# ✅ convert to native Python object
my_list = json.loads(my_json)

print(my_list[0]['name'])  # 👉️ 'Alice'
print(my_list[1]['name'])  # 👉️ 'Bob'

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

json.loads方法将JSON 字符串解析为本机 Python 对象。

相反，json.dumps方法将 Python 对象转换为 JSON 格式的字符串。

然后，您可以使用整数作为列表索引或字符串来访问字典中的键。

检查变量存储的对象类型

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

主程序
my_dict = {'name': 'Alice', 'age': 30}

print(type(my_dict))  # 👉️ <class 'dict'>
print(isinstance(my_dict, dict))  # 👉️ True

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

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

类型
类
返回对象的类型。

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

目录

  1. TypeError：TUPLE 索引必须是整数或切片，而不是 str
  2. TypeError：SLICE 索引必须是整数或无或具有_ _索引_ _方法

类型错误：元组索引必须是整数或切片，而不是 str

Python“TypeError: tuple indices must be integers or slices, not str”发生在我们使用字符串而不是整数来访问特定索引处的元组时。

要解决该错误，请使用该类int()将字符串转换为整数。

typeerror 元组索引必须是整数或切片而不是 str

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

主程序
my_tuple = ('a', 'b', 'c')

my_str = '1'

# ⛔️ TypeError: tuple indices must be integers or slices, not str
result = my_tuple[my_str]

错误是因为我们使用字符串作为元组索引引起的。

主程序
my_tuple = ('a', 'b', 'c', 'd')

# ✅ indices must be integers
print(my_tuple[0]) # 👉️ a
print(my_tuple[1]) # 👉️ b

print(my_tuple[1:3]) # 👉️ ('b', 'c')

访问元组时使用整数或切片

要解决该错误，请使用类将字符串转换为整数int()。

主程序
my_tuple = ('a', 'b', 'c')

my_str = '1'

# ✅ convert str to int
result = my_tuple[int(my_str)]

print(result)  # 👉️ 'b'

代码示例使用该类int()在访问元组时将字符串索引转换为整数。

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

如果您需要获取元组的一部分，则两个索引都必须是整数。

主程序
my_tuple = ('a', 'b', 'c', 'd')

start_index = '1'
stop_index = '3'

new_tuple = my_tuple[int(start_index):int(stop_index)]

print(new_tuple) # 👉️ ('b', 'c')

元组切片的语法

是my_tuple[start:stop:step].

主程序
my_tuple = ('a', 'b', 'c', 'd')

print(my_tuple[0:2])  # 👉️ ('a', 'b')
print(my_tuple[1:3])  # 👉️ ('b', 'c')

索引start是包含的，stop索引是排他的（最多，但不包括）。

如果start省略索引，则认为是0，如果stop省略索引，则切片转到元组的末尾。

遍历元组

您可以使用简单的for 循环来迭代元组。

主程序
my_tuple = ('a', 'b', 'c', 'd')

for item in my_tuple:
    print(item)  # 👉️ a, b, c, d

如果您需要访问当前迭代的索引，请使用该
enumerate()函数。

主程序
my_tuple = ('a', 'b', 'c')

for index, item in enumerate(my_tuple):
    # 0 a
    # 1 b
    # 2 c
    print(index, item)

检查一个项目是否在一个元组中

如果您需要检查某个项目是否在元组中，请使用in运算符。

主程序
my_tuple = ('a', 'b', 'c')

print('a' in my_tuple)  # 👉️ True

print('hello' in my_tuple)  # 👉️ False

如果该项目在元组中，则in运算符返回，
否则返回。TrueFalse

使用字典和元组

如果您打算声明字典，请确保使用花括号（而不是圆括号）。

主程序
my_dict = {}

my_dict['name'] = 'Alice'
my_dict['age'] = 30

print(my_dict)  # 👉️ {'name': 'Alice', 'age': 30}

如果您正在迭代字典元组，请确保在每次迭代时访问字典的键值对。

主程序
my_tuple = (
    {'id': 1, 'name': 'Alice'},
    {'id': 2, 'name': 'Bob'},
    {'id': 3, 'name': 'Carl'},
)

for entry in my_tuple:
    print(entry['id'])
    print(entry['name'])

我们使用一个for循环来遍历一个字典元组。

该entry变量在每次迭代时存储一个字典，因此您可以通过特定键访问它以获取相应的值。

您可以使用索引访问元组中的特定字典，然后访问字典中的键。

主程序
my_tuple = (
    {'id': 1, 'name': 'Alice'},
    {'id': 2, 'name': 'Bob'},
    {'id': 3, 'name': 'Carl'},
)

result = my_tuple[0]['name']
print(result)  # 👉️ 'Alice'

我们访问索引处的元组项0，然后访问name字典的键。

如果您有一个包含元组值的字典，请在访问索引之前访问特定的键。

主程序
my_dict = {
    'fruits': ('apple', 'banana', 'kiwi')
}

result = my_dict['fruits'][0]

print(result)  # 👉️ 'apple'

如果您需要遍历字典，请使用该dict.items()方法。

主程序
my_dict = {'name': 'Alice', 'age': 30}

for key, value in my_dict.items():
    print(key, value)  # 👉️ name Alice, age 30

dict.items
方法返回字典项（（键，值）对）的新视图。

元组在 Python 中是如何构造的

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

  • 使用一对括号()创建一个空元组
  • 使用尾随逗号 –a,或(a,)
  • 用逗号分隔项目 –a, b或(a, b)
  • 使用tuple()构造函数
元组与列表非常相似，但实现的内置方法较少并且是不可变的（无法更改）。

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

主程序
my_tuple = ('a', 'b', 'c')

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

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

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

类型
类
返回对象的类型。

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

TypeError: slice indices must be integers or None or have an _ _ index _ _方法

Python“TypeError: slice indices must be integers or None or have an
_ _ index _ _ method”发生在我们使用非整数值进行切片时（例如 a
float）。

要解决该错误，请确保在对列表、字符串或任何其他序列进行切片时使用整数。

typeerror slice indices must be integers or none or have index 方法

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

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

start = 0.5
stop = 2.5

# ⛔️ TypeError: slice indices must be integers or None or have an __index__ method
result = my_list[start:stop]

切片列表时，我们使用浮点数作为起始值和终止值。

在对序列进行切片时，我们需要对 和 值使用start整数。 stopstep

列表切片的语法是my_list[start:stop:step].

切片时将值转换为整数

要解决错误，请将浮点值转换为整数。

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

start = 0.5
stop = 2.5

result = my_list[int(start):int(stop)]

print(result)  # 👉️ ['a', 'b']

我们将浮点数传递给类int()以将它们转换为整数。

请注意，对于的值start是包含性的，而对于的值是排除性的。 stop
主程序
my_list = ['a', 'b', 'c', 'd']

print(my_list[0:2])  # 👉️ ['a', 'b']

print(my_list[1:3])  # 👉️ ['b', 'c']

如果start省略索引，则认为是0，如果stop省略索引，则切片转到列表的末尾。

除法运算符总是返回一个浮点数

当我们使用除法运算符/时经常会出现错误
，因为除法运算符/总是产生一个浮点值

主程序
print(10/2)  # 👉️ 5.0

整数除法/产生一个浮点数，而
整数除法 //产生一个整数。

主程序
print(10//2)  # 👉️ 5
使用 floor 除法运算符的结果是对floor()结果应用函数的数学除法。

一旦使用整数对序列进行切片，错误就会得到解决。

检查变量存储的类型

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

主程序
my_int = 10

print(type(my_int))
print(isinstance(my_int, int))

my_float = 3.14

print(type(my_float))
print(isinstance(my_float, float))

类型
类
返回对象的类型。

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