Python dict.get()返回None时怎么处理？

Python 中调用 dict.get() 得到 None，通常有两种可能：字典中没有这个键，或者这个键虽然存在，但它本身保存的值就是 None。如果只是希望键不存在时给一个默认值，可以直接使用 get(key, default)；如果业务上必须区分“键不存在”和“值是 None”，则应该结合 in 判断，而不能只检查 get() 的返回结果。

dict.get()为什么会返回None

dict.get() 是 Python 字典中很常用的取值方法。它与通过方括号 dict[key] 读取数据的一个重要区别是：键不存在时，get() 不会抛出 KeyError，而是返回默认值。

如果没有指定默认值，这个默认值就是 None。

user = {
    "name": "Tom",
    "age": 20
}

print(user.get("name"))
print(user.get("email"))

示例输出：

Tom
None

这里的 email 不存在，所以：

user.get("email")

实际上相当于：

user.get("email", None)

方法一：键不存在时直接设置默认值

如果你的需求只是“取不到值时使用一个备用值”，最简单的写法就是给 get() 传入第二个参数。

user = {
    "name": "Tom"
}

email = user.get("email", "未填写")
print(email)

示例输出：

未填写

get() 的基本形式是：

字典.get(键, 默认值)

键存在时返回实际值；键不存在时返回第二个参数。

默认值不一定是字符串，也可以按照后续代码需要设置为数字、列表或其他对象：

data = {
    "username": "alice"
}

age = data.get("age", 0)
tags = data.get("tags", [])
settings = data.get("settings", {})

print(age)
print(tags)
print(settings)

示例输出：

0
[]
{}

方法二：返回None后单独判断

有些时候不能在调用 get() 时直接确定默认值，需要根据是否得到数据执行不同逻辑，这时可以先保存返回结果，再判断是否为 None。

config = {
    "timeout": None
}

timeout = config.get("timeout")

if timeout is None:
    print("没有可用的 timeout")
else:
    print("timeout =", timeout)

判断 None 时，推荐写：

if value is None:
    ...

而不是：

if value == None:
    ...

None 是一个单例对象，使用 is None 可以直接表达“这个对象是不是 None”，含义也更加明确。

不要直接用if value判断是否返回None

下面这种代码看起来很简洁，但经常会引入错误：

count = data.get("count")

if not count:
    print("没有 count")

问题是 Python 中除了 None 之外，下面这些值也会被视为假值：

• 0
• 0.0
• "" 空字符串
• [] 空列表
• {} 空字典
• False

例如：

data = {
    "count": 0
}

count = data.get("count")

if not count:
    print("没有数据")

示例输出：

没有数据

但实际上 count 这个键存在，而且它的合法值就是 0。

如果你真正要检查的是 None，应该写成：

if count is None:
    print("count 没有值")
else:
    print("count =", count)

示例输出：

count = 0

关键问题：怎么区分“键不存在”和“值本身是None”

这是处理 dict.get() 返回 None 时最容易混淆的地方。

看下面这个字典：

user = {
    "name": "Tom",
    "email": None
}

执行：

print(user.get("email"))
print(user.get("phone"))

示例输出：

None
None

两个结果完全相同，但含义不同：

• email 这个键存在，只是它保存的值是 None；
• phone 这个键根本不存在。

因此，只看下面的代码无法区分两种情况：

if user.get("email") is None:
    ...

如果程序确实需要区分，就应该先判断键是否存在：

if "email" not in user:
    print("email 字段不存在")
elif user["email"] is None:
    print("email 字段存在，但值为 None")
else:
    print("email =", user["email"])

示例输出：

email 字段存在，但值为 None

设置默认值也不能覆盖“键存在但值为None”

另一个常见误解是认为给 get() 设置默认值后，只要原值是 None，默认值就会生效。

实际上不会。

user = {
    "email": None
}

email = user.get("email", "未填写")
print(email)

示例输出：

None

原因是默认值只在键不存在时使用。这里 email 已经存在，所以 get() 会返回该键实际保存的 None。

如果你的业务规则是“键不存在或者值为 None，都使用默认值”，可以明确判断：

user = {
    "email": None
}

email = user.get("email")

if email is None:
    email = "未填写"

print(email)

示例输出：

未填写

也可以写成条件表达式：

email = user.get("email")
email = "未填写" if email is None else email

能不能用or快速提供默认值

有时会看到这样的写法：

name = user.get("name") or "匿名用户"

这种写法的含义并不是“如果返回 None 就使用匿名用户”，而是“如果左侧是任何假值，就使用右侧”。

例如：

user = {
    "name": ""
}

name = user.get("name") or "匿名用户"
print(name)

示例输出：

匿名用户

虽然 name 存在，而且它的值是合法的空字符串，但 or 仍然使用了备用值。

因此，两种写法适合的规则不同。

不要为了缩短一两行代码而改变数据含义。如果 0、空字符串或 False 在业务中是有效数据，就不应该使用 or 代替 None 判断。

实际场景：读取接口或JSON转换后的字典

处理接口数据、配置文件或 JSON 数据时，经常会遇到字段缺失或者字段值为 null 的情况。JSON 中的 null 被 Python 解析后通常对应 None。

例如得到下面的数据：

user = {
    "id": 1001,
    "nickname": None,
    "score": 0
}

如果希望昵称缺失或为 None 时显示“未设置”，但分数为 0 时仍保留 0，可以分别处理：

nickname = user.get("nickname")
if nickname is None:
    nickname = "未设置"

score = user.get("score", 0)

print("昵称：", nickname)
print("积分：", score)

示例输出：

昵称： 未设置
积分： 0

这里不能写：

score = user.get("score") or 100

因为字典中的 score 明明是合法的 0，最终却会被改成 100。

实际场景：None出现时应该报错，而不是给默认值

并不是所有 None 都应该自动替换。

假设程序读取数据库连接配置：

config = {
    "host": "127.0.0.1",
    "port": 3306
}

password = config.get("password")

如果 password 是程序运行必须提供的配置，那么静默使用空字符串可能会掩盖配置错误：

password = config.get("password", "")

更合适的处理方式可能是直接检查并报告问题：

password = config.get("password")

if password is None:
    raise ValueError("配置中缺少有效的 password")

# 后续连接数据库
print("配置检查通过")

也就是说，dict.get() 返回 None 后怎么处理，关键不在于找到一种统一写法，而在于确定 None 在当前数据中的含义。

什么时候应该直接使用方括号取值

如果一个键按照程序设计必须存在，那么有时直接写：

username = user["username"]

反而比：

username = user.get("username")

更合适。

假设后面的代码要求 username 必须是字符串，而这个键缺失实际上属于数据错误。如果使用 get()，错误可能暂时被变成 None，直到更后面的代码才暴露出来。

使用方括号时，如果键不存在，会立即触发 KeyError：

user = {
    "id": 1001
}

username = user["username"]

这有助于尽早发现“不应该缺失的数据真的缺失了”。

如果默认值的创建过程比较复杂

还要注意，get() 的第二个参数会在函数调用之前先被求值。也就是说，即使键已经存在，默认值表达式仍然会执行。

例如：

def create_default():
    print("正在创建默认值")
    return "default"

data = {
    "name": "Tom"
}

name = data.get("name", create_default())
print(name)

示例输出：

正在创建默认值
Tom

虽然最终没有使用 create_default() 的结果，但这个函数仍然执行了。

如果默认值的计算比较耗时，或者调用本身会产生副作用，可以改成显式判断：

data = {
    "name": "Tom"
}

if "name" in data:
    name = data["name"]
else:
    name = create_default()

print(name)

对于普通的字符串、数字、空列表等简单默认值，一般不需要为此增加额外代码。

一个完整的处理思路

遇到 dict.get() 返回 None 时，可以按下面的顺序判断：

1. 这个键本来是否允许不存在；
2. 键存在时，None 是否属于合法值；
3. 如果缺少数据，是否有明确的默认值；
4. 0、空字符串、False 等是否应该保留；
5. 如果字段必须存在，是否应该直接报错。

几种常用写法放在一起看

1. 键不存在就使用默认字符串

name = data.get("name", "未知")

适合键可能不存在，而且不存在时与默认值没有必要进一步区分的情况。

2. 只针对None进行处理

name = data.get("name")

if name is None:
    name = "未知"

这种写法能够保留 ""、0 和 False 等合法假值。

3. 区分键不存在和值为None

if "name" not in data:
    print("name 键不存在")
elif data["name"] is None:
    print("name 存在，但值为 None")
else:
    print(data["name"])

适合接口校验、数据清洗和配置检查等需要准确区分数据状态的场景。

4. 所有假值都使用默认值

name = data.get("name") or "未知"

只有当 None、空字符串、0、False 等都可以统一视为“没有有效值”时才适合这样写。

5. 字段必须存在

name = data["name"]

如果键缺失本身就是程序错误，不必刻意使用 get() 把错误转换成 None。

容易写错的几个地方

不要把返回 None 直接理解成“键不存在”。键存在但值就是 None 时结果完全一样，需要区分时使用 in。

不要用 if not value 代替 if value is None。前者还会把 0、空字符串、空列表和 False 一并判断为假。

不要认为 get(key, default) 会替换已经存在的 None。默认值只在键不存在时生效。

不要为了避免异常而对所有字段都使用 get()。如果字段必须存在，让程序及时暴露 KeyError 有时比悄悄得到 None 更容易定位数据问题。

总结

dict.get() 返回 None 本身不是错误，它只是表示当前调用没有得到其他值。处理时最重要的是先弄清楚数据规则。

如果键不存在时有明确备用值，可以直接写：

value = data.get("key", default)

如果只想处理 None，同时保留 0、空字符串和 False：

value = data.get("key")

if value is None:
    value = default

如果需要区分“键不存在”和“键存在但值为 None”，则应该检查键：

if "key" not in data:
    print("键不存在")
elif data["key"] is None:
    print("键存在，但值为 None")

而当这个字段按程序设计必须存在时，可以直接使用 data["key"]，让缺失字段尽早暴露。把这几种情况区分清楚后，dict.get() 返回 None 就不需要靠猜测处理了。