迹忆客 专注技术分享

Python "KeyError: 0" 异常是在我们尝试访问不包含0 这个键的时候去访问该键而引起的。

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

下面是一个产生上述错误的示例

my_dict = {1: ['c', 'd'], 2: ['e', 'f']}

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

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

使用 dict.get() 方法

避免“KeyError: 0”异常的一种方法是使用 dict.get() 方法。

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 个参数：

• key 要为其返回值的键
• default 如果字典中不存在提供的键，则返回默认值（可选）

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

我们可以使用适合我们的用例的任何默认值，例如 无、0 或空字符串。

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, ''))  # 👉️ ""

在访问之前为键设置一个值

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

my_dict = {1: ['c', 'd'], 2: ['e', 'f']}

my_dict[0] = [] # 👈️ 将键初始化为空列表

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

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

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

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

在设置之前检查密钥是否不存在

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

my_dict = {1: ['c', 'd'], 2: ['e', 'f']}


# ✅ 如果 key 不存在则初始化 key
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 语句来处理错误。

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] = []  # 👈️ 必要时可以初始化 key

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

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

使用 dict.items() 方法遍历字典

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

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() 类。

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 循环使用范围类来获取从 0 到 9 的迭代器。

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

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

使用 defaultdict 类解决错误

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

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 参数，它调用该参数为给定键提供默认值。

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

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

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

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

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

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

employee = {
    'name': 'Jiyik'
}

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

我们试图在字典中分配一个嵌套键，但是地址键不存在，所以我们得到一个 KeyError 异常。

首先为键赋值

解决错误的一种方法是先为地址键分配一个值。

employee = {
    'name': 'Jiyik'
}

employee['address'] = {} # 👈️ 将键分配给空字典

employee['address']['country'] = 'China'

# 👇️ {'name': 'Jiyik', 'address': {'country': 'China'}}
print(employee)

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

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

在赋值之前检查键是否存在

如果字典中不存在键，则只能分配键。

employee = {
    'name': 'Jiyik'
}

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

employee['address']['country'] = 'China'

# 👇️ {'name': 'Jiyik', 'address': {'country': 'China'}}
print(employee)

if 语句仅在地址键不在字典中时运行。

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

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

from collections import defaultdict

employee = defaultdict(dict)

employee['address']['country'] = 'China'

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

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

defaultdict 类采用 default_factory 参数，它调用该参数为给定键提供默认值。

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

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

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

from collections import defaultdict

my_dict = defaultdict(int)

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

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

设置密钥时使用 try/except 语句

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

employee = {
    'name': 'Jiyik'
}

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

# 👇️ {'name': 'Jiyik', 'address': {'country': 'China'}}
print(employee)

KeyError 异常由我们分配地址键并为嵌套国家键设置值的 except 子句处理。

(JSON) Python 中的 KeyError 异常

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

import json

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

# 👇️ 将 JSON 字符串解析为 Python 字典
my_dict = json.loads(my_json)
print(my_dict)  # 👉️ {'name': 'Jiyik', 'age': 30}


# 👇️ 检查字典中是否存在键
if 'country' in my_dict:
    print(my_dict['country'])

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

我们使用 in 运算符在访问字典之前检查字典中是否存在国家/地区键。

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

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

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

import json

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

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

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

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

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

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

import json

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

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


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

如果我们尝试访问任何其他键，将得到 KeyError 异常。

忽略 KeyError 异常

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

import json

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

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


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

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

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

• key 要为其返回值的键
• default 如果字典中不存在提供的键，则返回默认值（可选）

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

确保正确访问 key

确保我们没有尝试错误地访问key。

import json

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

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


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

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

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

import json

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

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


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

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

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