目录
TypeError: list indices must be integers or slices, not str
- 类型错误:LIST 索引必须是整数或切片,而不是 str
- TypeError:TUPLE 索引必须是整数或切片,而不是 str
- TypeError:SLICE 索引必须是整数或无或具有_ _索引_ _方法
类型错误:列表索引必须是整数或切片,而不是 str
当我们使用字符串而不是整数来访问特定索引处的列表时,会出现 Python“TypeError: list indices must be integers or slice, not str”。
要解决该错误,请使用该类int()
将字符串转换为整数,例如my_list[int(my_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()类将字符串转换为整数,以便能够访问索引处的列表。
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
返回
。True
false
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
目录
类型错误:元组索引必须是整数或切片,而不是 str
Python“TypeError: tuple indices must be integers or slices, not str”发生在我们使用字符串而不是整数来访问特定索引处的元组时。
要解决该错误,请使用该类int()
将字符串转换为整数。
下面是错误如何发生的示例。
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()
在访问元组时将字符串索引转换为整数。
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
运算符返回,
否则返回。True
False
使用字典和元组
如果您打算声明字典,请确保使用花括号(而不是圆括号)。
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
)。
要解决该错误,请确保在对列表、字符串或任何其他序列进行切片时使用整数。
下面是错误如何发生的示例。
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
整数。 stop
step
列表切片的语法是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()
结果应用函数的数学除法。一旦使用整数对序列进行切片,错误就会得到解决。
检查变量存储的类型
如果不确定变量存储的对象类型,请使用内置类
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