python如何获取一个字典的值_python获取字典dict值的几种方法

裘德小鎮的故事

发布时间：2025-09-14 18:15:01

1238人浏览过

来源于php中文网

原创

直接访问键（dict[key]）在键存在时效率高但键不存在会抛出KeyError，而.get()方法更安全，键不存在时可返回默认值，避免程序崩溃。

python如何获取一个字典的值_python获取字典dict值的几种方法

Python中获取字典的值，最直接也最常用的方式就是通过键名直接访问，例如

my_dict['key']

，或者使用其内置的

.get()

方法。这两种方法各有优势，前者在确定键存在时效率高，但键不存在会抛出

KeyError

；后者则更“温柔”，可以在键不存在时返回一个默认值，避免程序崩溃。理解它们的适用场景，能让你的代码更健壮、更易读。

解决方案

在Python中，从字典（dict）中获取值主要有以下几种方式，每种都针对不同的使用场景和错误处理需求：

直接通过键访问 (
```
dict[key]
```
) 这是最直观、最常用的方法。当你确定字典中某个键一定存在时，直接使用方括号
```
[]
```
加键名就可以获取对应的值。
```
data = {'name': 'Alice', 'age': 30, 'city': 'New York'}
user_name = data['name']
print(f"用户名为: {user_name}") # 输出: 用户名为: Alice
```
注意： 如果你尝试访问一个不存在的键，Python会立即抛出
```
KeyError
```
异常，这可能会中断你的程序。
使用
```
.get()
```
方法 (
dict.get(key, default_value)
)
```
.get()
```
方法是获取字典值时更安全的选择，尤其是在你不确定键是否存在的情况下。它接受两个参数：第一个是要查找的键，第二个是可选的默认值。

立即学习“Python免费学习笔记（深入）”；
- 如果键存在，它会返回对应的值。
- 如果键不存在，并且你提供了
```
default_value
```
  ，它会返回这个默认值。
- 如果键不存在，且你没有提供
```
default_value
```
  ，它会默认返回
```
None
```
  。
```
data = {'name': 'Bob', 'age': 25}
user_city = data.get('city', 'Unknown')
print(f"用户城市: {user_city}") # 输出: 用户城市: Unknown
```
user_age = data.get('age') print(f"用户年龄: {user_age}") # 输出: 用户年龄: 25

user_email = data.get('email') print(f"用户邮箱: {user_email}") # 输出: 用户邮箱: None
```
我个人在处理外部数据源或者API响应时，非常偏爱`get()`方法。它能让代码在面对不确定性时更健壮，避免了不必要的`try-except`块，让代码看起来更“干净”，也减少了因键缺失而导致程序崩溃的风险。
```

Python字典中直接访问键和使用

.get()

方法有什么核心区别？

这两种方法的核心区别在于它们处理键不存在的情况。直接访问

dict[key]

在键不存在时会毫不留情地抛出

KeyError

。这就像你直接去一个抽屉里找东西，发现没有就大喊一声“没有！”然后把所有事情都停下来。这种行为在某些场景下是期望的，比如你确实认为某个键是必须存在的，如果它不存在，那就是一个程序错误，需要立即处理。

而

.get()

方法则温和得多。当键不存在时，它不会抛出异常，而是返回你指定的默认值（如果你没指定，就返回

None

）。这就像你去抽屉里找东西，如果没找到，你会说“没找到，那就用备用的吧”或者“没找到就算了”。这种行为在处理可选数据、配置项或者来自外部的、结构可能不完全一致的数据时特别有用。它允许你的程序继续执行，而不是直接崩溃。

从我个人的经验来看，选择哪种方法，很大程度上取决于你对“键不存在”这个情况的预期。如果键的缺失是异常情况，需要中断程序或进行错误日志记录，那么

dict[key]

配合

try-except KeyError

是一个清晰的选择。但如果键的缺失是常见且可以接受的情况，并且你可以提供一个合理的默认值或接受

None

，那么

.get()

无疑是更优雅、更简洁的解决方案。它能让你的代码少写很多

if key in dict:

这样的检查，减少冗余。

config = {'debug_mode': True}

# 使用[]访问，如果键不存在会报错
try:
    log_level = config['log_level']
except KeyError:
    print("错误：log_level 配置缺失！")
    log_level = 'INFO' # 提供一个默认值作为补救
print(f"当前日志级别 (通过[]访问): {log_level}")

# 使用.get()访问，更优雅地处理缺失
log_level_safe = config.get('log_level', 'INFO')
print(f"当前日志级别 (通过.get()访问): {log_level_safe}")

# 假设一个必须存在的键
user_data = {'id': 101, 'name': 'Alice'}
try:
    user_id = user_data['id']
    user_email = user_data['email'] # 这一行会抛出KeyError
except KeyError as e:
    print(f"关键数据缺失: {e}")

如何安全地从嵌套字典中获取值，避免多层

KeyError

？

从嵌套字典中获取值是一个非常常见的场景，但如果处理不当，很容易遇到一连串的

KeyError

。想象一下，你有一个像

data = {'user': {'profile': {'name': 'John'}}}

这样的字典，你想获取

name

。如果直接

data['user']['profile']['name']

，万一

user

不存在，或者

profile

不存在，你的程序就直接崩了。这简直是噩梦。

要安全地处理这种情况，

get()

方法是你的最佳伙伴。你可以链式调用

get()

方法，每一步都提供一个默认值（通常是另一个空字典，以便继续下一层查找，或者

None

如果那是最终层）。

complex_data = {
    'user': {
        'id': '123',
        'details': {
            'name': 'Jane Doe',
            'email': 'jane.doe@example.com'
        },
        'preferences': {}
    },
    'settings': {
        'theme': 'dark'
    }
}

# 示例1: 成功获取嵌套值
user_name = complex_data.get('user', {}).get('details', {}).get('name')
print(f"用户姓名: {user_name}") # 输出: 用户姓名: Jane Doe

# 示例2: 某一层键不存在
user_phone = complex_data.get('user', {}).get('details', {}).get('phone')
print(f"用户电话: {user_phone}") # 输出: 用户电话: None (因为phone不存在)

# 示例3: 顶层键不存在
admin_email = complex_data.get('admin', {}).get('contact', {}).get('email')
print(f"管理员邮箱: {admin_email}") # 输出: 管理员邮箱: None (因为admin不存在)

# 示例4: 指定默认值
user_language = complex_data.get('user', {}).get('preferences', {}).get('language', 'en-US')
print(f"用户语言: {user_language}") # 输出: 用户语言: en-US (因为language不存在，但提供了默认值)

这种链式调用

get()

的方式，虽然看起来有点冗长，但它极大地提高了代码的健壮性。每一步都像在问：“这个键存在吗？如果存在，给我它的值；如果不存在，就给我一个空字典（或者

None

），这样我就不会因为找不到而报错。”我个人在处理复杂的JSON数据或者API响应时，几乎都会用这种方式，它能让我少写很多

if

判断，代码也显得更整洁。

当然，如果你需要处理更深层次、更动态的嵌套结构，可以考虑编写一个辅助函数，或者使用一些库（比如

dotmap

或

box

）来通过点语法访问，但对于大多数常见的两三层嵌套，链式

get()

已经足够强大和实用了。

在处理大量数据时，获取字典值的方法对性能有影响吗？

这是一个很好的问题，因为在性能敏感的应用中，即使是微小的差异也可能累积成显著的瓶颈。对于Python字典来说，获取值的操作通常是非常快的，因为字典底层是基于哈希表实现的，理论上查找的时间复杂度是O(1)（常数时间）。

松果AI写作

专业全能的高效AI写作工具

下载

那么，

dict[key]

和

dict.get(key, default)

在性能上是否有显著差异呢？

一般而言，直接通过

dict[key]

访问会比
dict.get()
稍微快一点点。这种差异主要是因为

dict.get()

在内部需要处理额外的逻辑，比如检查默认值参数、处理键不存在的情况等。而

dict[key]

则更直接，它只管查找，找不到就直接抛异常。

然而，在绝大多数实际应用场景中，这种性能差异是微不足道的，几乎可以忽略不计。 除非你正在执行一个极其紧密的循环，迭代数百万甚至上亿次，并且每次迭代都需要获取字典值，否则你不太可能感知到这两者之间的性能差距。通常，程序的其他部分（如文件I/O、网络请求、复杂的计算逻辑）才是真正的性能瓶颈。

我个人在编写代码时，从来不会为了那微乎其微的性能优势而牺牲代码的健壮性和可读性。我更倾向于根据错误处理的需求来选择方法：

如果键的缺失是一个需要立即捕获并处理的错误，我会用
```
dict[key]
```
并配合
```
try-except
```
。
如果键的缺失是预期情况，并且可以优雅地提供一个默认值，或者接受
```
None
```
，那么
```
dict.get()
```
绝对是首选。

你可以通过Python的

timeit

模块来简单测试一下：

import timeit

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
key_exists = 'c'
key_missing = 'z'

# 测试直接访问存在的键
time_direct_exist = timeit.timeit("my_dict[key_exists]", globals=globals(), number=1_000_000)
print(f"直接访问存在的键耗时: {time_direct_exist:.6f} 秒")

# 测试.get()访问存在的键
time_get_exist = timeit.timeit("my_dict.get(key_exists)", globals=globals(), number=1_000_000)
print(f".get()访问存在的键耗时: {time_get_exist:.6f} 秒")

# 测试直接访问不存在的键 (会抛异常，所以要包在try-except里比较)
time_direct_missing = timeit.timeit("try: my_dict[key_missing] except KeyError: pass", globals=globals(), number=1_000_000)
print(f"直接访问不存在的键 (带try-except) 耗时: {time_direct_missing:.6f} 秒")

# 测试.get()访问不存在的键
time_get_missing = timeit.timeit("my_dict.get(key_missing)", globals=globals(), number=1_000_000)
print(f".get()访问不存在的键耗时: {time_get_missing:.6f} 秒")

# 测试.get()访问不存在的键并带默认值
time_get_missing_default = timeit.timeit("my_dict.get(key_missing, 0)", globals=globals(), number=1_000_000)
print(f".get()访问不存在的键 (带默认值) 耗时: {time_get_missing_default:.6f} 秒")

你会发现，这些数字都非常小，差异通常在微秒级别，对于一百万次操作来说，这点差异几乎可以忽略不计。所以，选择哪种方法，更多地应该从代码的逻辑清晰度、错误处理策略和可维护性出发，而不是过早地优化这点微小的性能差异。

除了获取单个值，Python还有哪些方法可以高效地处理字典中的所有值？

虽然标题聚焦于获取单个字典值，但在实际开发中，我们经常需要处理字典中的所有值，比如遍历它们、对它们进行计算或筛选。Python为我们提供了非常高效和简洁的方法来完成这些任务。

```
dict.values()
```
：获取所有值的视图
```
dict.values()
```
方法会返回一个“视图对象”，它展示了字典中所有值的一个动态集合。这个视图对象不是一个列表的拷贝，而是字典值的一个实时反映。这意味着如果字典内容发生变化，视图对象也会随之更新。你可以直接遍历它：
```
scores = {'math': 95, 'science': 88, 'history': 70}
for score in scores.values():
    print(f"分数: {score}")
# 输出:
# 分数: 95
# 分数: 88
# 分数: 70
```
如果你需要将所有值转换为一个列表，可以简单地
```
list(scores.values())
```
。

列表推导式（List Comprehensions）结合

dict.values()

这是Python中处理序列数据非常强大且简洁的工具。如果你需要对字典的所有值进行某种转换或筛选，并生成一个新的列表，列表推导式是理想的选择：

prices = {'apple': 1.2, 'banana': 0.8, 'orange': 1.5}
# 获取所有价格的两倍
doubled_prices = [price * 2 for price in prices.values()]
print(f"翻倍后的价格: {doubled_prices}") # 输出: 翻倍后的价格: [2.4, 1.6, 3.0]

# 筛选出价格高于1.0的水果
expensive_fruits = [price for price in prices.values() if price > 1.0]
print(f"较贵的水果价格: {expensive_fruits}") # 输出: 较贵的水果价格: [1.2, 1.5]

这种方式不仅代码量少，而且通常比传统的

for

循环加

append

更快，因为它在C语言级别进行了优化。

```
dict.items()
```
：同时获取键和值 虽然这不完全是“只获取值”，但在很多场景下，你可能需要根据键来处理对应的值。
```
dict.items()
```
返回一个由键值对元组组成的视图对象，你可以同时遍历键和值：
```
inventory = {'laptop': 5, 'mouse': 20, 'keyboard': 10}
for item, quantity in inventory.items():
    print(f"{item} 剩余 {quantity} 件")
# 输出:
# laptop 剩余 5 件
# mouse 剩余 20 件
# keyboard 剩余 10 件
```
同样，
```
dict.items()
```
也可以和列表推导式结合使用，实现更复杂的逻辑。