KeyError: Python 中的 0 异常 [已解决]

作者

目录

KeyError: 0 exception in Python

  1. Python 中的 KeyError: 0 异常
  2. 在Python中分配新Key时出现KeyError异常
  3. (JSON) Python 中的 KeyError 异常

Python 中的 KeyError: 0 异常

当我们尝试访问0字典中不包含该键的键时，会引发 Python“KeyError: 0”异常。

要解决该错误，请在尝试访问字典之前设置该键，或者dict.get()在该键不存在时使用它来获取默认值。

按键错误 0

以下是错误发生方式的示例。

主要.py
my_dict = {1: ['c', 'd'], 2: ['e', 'f']}

# ⛔️ KeyError: 0
print(my_dict[0])

我们尝试访问0字典中不包含该键的键。

使用 dict.get() 方法

避免异常的一种方法是使用该dict.get()方法。

主要.py
my_dict = {1: ['c', 'd'], 2: ['e', 'f']}

print(my_dict.get(0))  # 👉️ None

print(my_dict.get(0, 'default value'))  # 👉️ default value

如果键在字典中，则 dict.get 方法返回给定键的值，否则返回默认值。

该方法采用以下 2 个参数：

姓名 描述
钥匙 返回值的键
默认 如果提供的键不存在于字典中则返回默认值（可选）

default如果未提供参数值，则默认为None，因此该get()方法永远不会引发KeyError。

您可以使用适合您的用例的任何默认值，例如None或0空字符串。

主要.py
my_dict = {1: ['c', 'd'], 2: ['e', 'f']}

print(my_dict.get(0, None))  # 👉️ None

print(my_dict.get(0, 0))  # 👉️ 0

print(my_dict.get(0, ''))  # 👉️ ""

在访问键之前设置它的值

解决该错误的另一种方法是在尝试访问特定键之前为其设置一个值。

主要.py
my_dict = {1: ['c', 'd'], 2: ['e', 'f']}

my_dict[0] = [] # 👈️ initialize key to empty list

my_dict[0].append('a')
my_dict[0].append('b')

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

0在示例中，我们将键初始化为空列表。

现在我们可以安全地访问密钥而不会出现KeyError异常。

设置之前检查key是否不存在

您还可以在设置之前检查该键是否在字典中不存在。

主要.py
my_dict = {1: ['c', 'd'], 2: ['e', 'f']}


# ✅ initialize key if it doesn't exist
if 0 not in my_dict:
    my_dict[0] = []

my_dict[0].append('a')
my_dict[0].append('b')

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

我们检查0字典中是否不存在该键并将其值初始化为空列表。

使用try/except语句来处理错误

您还可以使用
try/ except 语句来处理错误。

主要.py
my_dict = {1: ['c', 'd'], 2: ['e', 'f']}

try:
    print(my_dict[0])
except KeyError:
    # 👇️ this runs
    print('key does not exist in dict')
    my_dict[0] = []  # 👈️ can initialize key if necessary

尝试访问0字典中的键会导致KeyError异常，然后该异常会传递到except块。

异常KeyError由子句处理except，您可以0在必要时在其中初始化密钥。

使用该dict.items()方法迭代字典

dict.items()如果需要迭代字典，请使用该方法。

主要.py
my_dict = {0: ['a', 'b'], 1: ['c', 'd'], 2: ['e', 'f']}


for key, value in my_dict.items():
    print(key, value)  # 0 ['a', 'b'], 1 ['c', 'd'], 2 ['e', 'f']

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

range()您还可以在迭代字典时使用该类。

主要.py
my_dict = {1: ['b'], 3: ['c'], 5: ['d']}

for index in range(0, 10):
    if index in my_dict:
        # ['b']
        # ['c']
        # ['d']
        print(my_dict[index])

for循环使用该类从torange获取迭代器。09

主要.py
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(0, 10)))

在每次迭代中，我们在访问索引之前检查字典中是否存在索引。

使用defaultdict类来解决错误

您还可以使用该类defaultdict来避免错误。

主要.py
from collections import defaultdict

my_dict = defaultdict(list)

my_dict[0].append('a')
my_dict[0].append('b')

print(my_dict)  # 👉️ defaultdict(<class 'list'>, {0: ['a', 'b']})

请注意，您必须defaultdict在使用该类之前导入该类。

defaultdict

类接受一个参数，default_factory调用该参数为给定键提供默认值。

键的值被插入到字典中并返回。

我们将list类传递给构造函数，因此每次尝试访问不存在的键时，list都会在不带任何参数的情况下调用该类，并为该键设置一个列表对象。

在Python中分配新Key时出现KeyError异常

尝试分配嵌套键时在字典中分配新键时会引发 KeyError 异常。

要解决该错误，请有条件地设置键或使用类defaultdict为字典中不存在的键设置默认值。

以下是错误发生方式的示例。

主要.py
employee = {
    'name': 'Bobby Hadz'
}

# ⛔️ KeyError: 'address'
employee['address']['country'] = 'Austria'

我们尝试在字典中分配一个嵌套键，但该address键不存在，因此出现KeyError异常。

首先给key赋值

解决该错误的一种方法是address首先为键分配一个值。

主要.py
employee = {
    'name': 'Alice'
}

employee['address'] = {} # 👈️ assign key to empty dict

employee['address']['country'] = 'Austria'

# 👇️ {'name': 'Alice', 'address': {'country': 'Austria'}}
print(employee)

我们将address键设置为空字典，因此我们能够分配嵌套country键。

address但是，如果该键已在字典中设置，则这将覆盖该键。

赋值前检查key是否存在

仅当字典中尚不存在该键时，您才能分配该键。

主要.py
employee = {
    'name': 'Alice'
}

if 'address' not in employee:
    employee['address'] = {}

employee['address']['country'] = 'Austria'

# 👇️ {'name': 'Alice', 'address': {'country': 'Austria'}}
print(employee)

仅当键不在字典中if时才运行该语句。address

使用defaultdict类为不存在的键设置默认值

您还可以使用该类defaultdict为字典中尚不存在的键设置默认值。

主要.py
from collections import defaultdict

employee = defaultdict(dict)

employee['address']['country'] = 'Austria'

# 👇️ defaultdict(<class 'dict'>, {'address': {'country': 'Austria'}})
print(employee)

print(employee['address'])  # 👉️ {'country': 'Austria'}

defaultdict

类接受一个参数，default_factory调用该参数为给定键提供默认值。

键的值被插入到字典中并返回。

我们将dict类传递给构造函数，因此每次尝试访问不存在的键时，dict都会在不带任何参数的情况下调用该类，并为该键设置一个 dict 对象。

这是defaultdict对象如何工作的一个简单示例。

主要.py
from collections import defaultdict

my_dict = defaultdict(int)

print(my_dict['a'])  # 👉️ 0

该a键不存在于 中dict，因此
int()类在没有任何参数的情况下被调用，并且0为我们尝试访问的键设置了一个值。

try/except设置key时使用语句

您还可以在向字典添加新键时使用try/except语句来处理异常。KeyError

主要.py
employee = {
    'name': 'Alice'
}

try:
    employee['address']['country'] = 'Austria'
except KeyError:
    employee['address'] = {}
    employee['address']['country'] = 'Austria'

# 👇️ {'name': 'Alice', 'address': {'country': 'Austria'}}
print(employee)

异常由我们分配
键并为嵌套键设置值的子句KeyError处理。exceptaddresscountry

(JSON) Python 中的 KeyError 异常

要解决 Python 中的 (JSON) KeyError 异常，请使用该json.loads()
方法将 JSON 字符串解析为本机 Python 对象，并在访问该键之前有条件地检查该键是否存在于字典中。

主要.py
import json

my_json = r'{"name": "Alice", "age": 30}'

# 👇️ parse JSON string to Python dict
my_dict = json.loads(my_json)
print(my_dict)  # 👉️ {'name': 'Alice', 'age': 30}


# 👇️ check if key is present in dictionary
if 'country' in my_dict:
    print(my_dict['country'])

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

在访问字典之前，我们使用in运算符检查该country键是否存在于字典中。

当与字典一起使用时，运算符检查对象中是否存在指定的键dict。

如果密钥不存在，则将其设置为默认值

或者，您可以检查该键是否不在字典中并将其设置为默认值，例如空字符串或空列表。

主要.py
import json

my_json = r'{"name": "Alice", "age": 30}'

my_dict = json.loads(my_json)
print(my_dict)  # 👉️ {'name': 'Alice', 'age': 30}

if 'country' not in my_dict:
    my_dict['country'] = ''

print(my_dict['country'])  # 👉️ ''

country如果字典中尚不存在该键，我们仅将其设置为空字符串。

调试时，使用该dict.keys()方法打印字典的键。

主要.py
import json

my_json = r'{"name": "Alice", "age": 30}'

my_dict = json.loads(my_json)
print(my_dict)  # 👉️ {'name': 'Alice', 'age': 30}


# 👇️ ['name', 'age']
print(list(my_dict.keys()))

如果您尝试访问任何其他密钥，则会遇到异常KeyError。

忽略KeyError异常

如果您只需要访问特定的键并且需要忽略异常KeyError
，请使用该dict.get()方法。

主要.py
import json

my_json = r'{"name": "Alice", "age": 30}'

my_dict = json.loads(my_json)
print(my_dict)  # 👉️ {'name': 'Alice', 'age': 30}


print(my_dict.get('country'))  # 👉️ None
print(my_dict.get('country', 'default value'))  # 👉️ 'default value'

如果键在字典中，则 dict.get 方法返回给定键的值，否则返回默认值。

该方法采用以下 2 个参数：

姓名 描述
钥匙 返回值的键
默认 如果提供的键不存在于字典中则返回默认值（可选）

default如果未提供参数值，则默认为None，因此该get()方法永远不会引发KeyError。

确保正确访问密钥

确保您没有尝试错误地访问密钥。

主要.py
import json

my_json = r'{"address": {"country": "Austria"}}'

my_dict = json.loads(my_json)
print(my_dict)  # 👉️ {'address': {'country': 'Austria'}}


print(my_dict['address']['country'])  # 👉️ 'Austria'

address请注意，在访问嵌套键之前，我们首先必须访问该键country。

如果您有一个数组，请确保在尝试访问键之前在特定索引处访问它。

主要.py
import json

my_json = r'[{"address": {"country": "Austria"}}]'

my_list = json.loads(my_json)
print(my_list)  # 👉️ [{'address': {'country': 'Austria'}}]


print(my_list[0]['address']['country'])  # 👉️ 'Austria'

我们将 JSON 字符串解析为一个列表。请注意，我们首先必须访问索引处的列表0以获取 dict 对象。

一旦我们有了一个 dict 对象，我们就可以访问它的特定键。

额外资源

您可以通过查看以下教程了解有关相关主题的更多信息：