Python 给字典加值，核心就三种情况：**新增一个键值对、修改已有键的值、批量合并一组新值**。最常用的写法是 `字典[键] = 值`，它既能新增，也能覆盖；如果你想一次加多个值，可以用 `update()`；如果是“键不存在才加”，更适合用 `setdefault()`。真正容易出错的，不是语法本身，而是你没有分清“新增”“覆盖”“累加”“嵌套赋值”这几类场景。

很多人问“python怎么给字典加值”，其实问的是两个问题：**怎么写**，以及**什么时候该用哪种方式**。如果只是普通新增，直接赋值就够了；如果你担心把原值覆盖掉，就要先判断键是否存在；如果字典里套字典或列表，写法又会不一样。把这几类情况分开，基本就不会乱。

## 一、最常见的字典加值方式：直接赋值

Python 字典最直接的加值方法，就是用方括号给某个键赋值：

```python
person = {}
person["name"] = "张三"
person["age"] = 18

print(person)
```

输出结果：

```python
{'name': '张三', 'age': 18}
```

这种写法的特点很明确：**如果键原本不存在，就是新增；如果键已经存在，就是修改原值**。

比如：

```python
person = {"name": "张三", "age": 18}
person["age"] = 20

print(person)
```

输出：

```python
{'name': '张三', 'age': 20}
```

所以，很多初学者以为“给字典加值”和“修改字典值”是两件事，其实在 Python 里，这两个动作经常用的是同一个语法。

下面这个表可以快速区分几种常见方式：

| 场景 | 写法 | 是否会覆盖原值 | 适用情况 |
|---|---|---:|---|
| 新增或修改单个键 | `d[key] = value` | 会 | 最常见、最直接 |
| 批量添加多个键值对 | `d.update({...})` | 会 | 一次加多个值 |
| 键不存在才设置默认值 | `d.setdefault(key, value)` | 不会 | 防止误覆盖 |
| 在原值基础上累加 | `d[key] += value` | 可能报错 | 适合数值、列表等已存在值 |

如果你只是想回答“python怎么给字典加值”，优先记住这一句就够了：

```python
d["新键"] = "新值"
```

但只会这一种，在实际写代码时还不够，因为很多问题出在边界情况上。

## 二、批量给字典加值，用 update() 更合适

当你不是加一个值，而是一次想加入多个键值对，`update()` 会比连续写多行赋值更清晰。

例如：

```python
student = {"name": "李四"}
student.update({"age": 20, "gender": "男"})

print(student)
```

输出：

```python
{'name': '李四', 'age': 20, 'gender': '男'}
```

`update()` 的作用是把另一个字典中的内容合并进来。它也有一个重要特点：**如果遇到相同的键，会直接覆盖原来的值**。

看这个例子：

```python
student = {"name": "李四", "age": 18}
student.update({"age": 20, "city": "北京"})

print(student)
```

输出：

```python
{'name': '李四', 'age': 20, 'city': '北京'}
```

这里的 `age` 从 18 被改成了 20，同时新增了 `city`。

除了传字典，`update()` 还可以传键值对序列：

```python
student = {}
student.update([("name", "王五"), ("age", 22)])

print(student)
```

输出：

```python
{'name': '王五', 'age': 22}
```

如果你的场景是接口返回一批字段、表单提交一组数据、配置项一次性合并，那么 `update()` 比单条赋值更适合。它表达的是“整体补充或整体更新”，语义更完整。

不过这里有个常见误区：有人把 `update()` 理解成“只新增不修改”。这不对。**`update()` 本质上是合并，也包含覆盖。**

## 三、键不存在时再加值，别直接覆盖

很多代码不是不会“给字典加值”，而是加值时把旧数据不小心改掉了。比如你想给字典设置一个默认值，只在没有这个键时才添加，这时就不该直接写 `d[key] = value`，而应该考虑 `setdefault()`。

例如：

```python
config = {"theme": "dark"}
config.setdefault("theme", "light")
config.setdefault("font_size", 14)

print(config)
```

输出：

```python
{'theme': 'dark', 'font_size': 14}
```

可以看到：

- `theme` 已经存在，所以没有被改成 `light`
- `font_size` 原本不存在，所以被成功添加

这就是 `setdefault()` 的核心作用：**有这个键就保留原值，没有才补上默认值**。

它还会返回对应键的值，例如：

```python
data = {}
value = data.setdefault("count", 0)

print(data)
print(value)
```

输出：

```python
{'count': 0}
0
```

这种写法特别适合下面几类场景：

1. 初始化统计字段
2. 给配置项补默认值
3. 处理嵌套字典时先确保父键存在

比如统计单词出现次数时，很多人会先这么写：

```python
word_count = {}
word = "python"

if word not in word_count:
    word_count[word] = 0
word_count[word] += 1
```

这没问题，但可以更紧凑：

```python
word_count = {}
word = "python"

word_count.setdefault(word, 0)
word_count[word] += 1
```

如果你问“python怎么给字典加值才不覆盖原来的值”，那 `setdefault()` 就是更稳妥的答案之一。

## 四、给字典里的值继续加内容，要分清值是什么类型

“给字典加值”还有一种非常常见的真实需求：不是给字典新增键，而是给某个键对应的值继续追加内容。这里最容易混淆，因为不同值类型，写法完全不同。

### 1. 值是数字：做累加

```python
score = {"math": 90}
score["math"] += 5

print(score)
```

输出：

```python
{'math': 95}
```

但这里有个前提：`math` 这个键必须已经存在，否则会报错：

```python
score = {}
score["math"] += 5
```

会报 `KeyError`。

稳妥写法一般是先初始化：

```python
score = {}
score["math"] = score.get("math", 0) + 5

print(score)
```

输出：

```python
{'math': 5}
```

`get()` 的意思是：如果键存在，就取它的值；如果不存在，就用默认值 0。

### 2. 值是列表：做追加

如果字典的某个键对应的是列表，想“继续加值”通常是 `append()`：

```python
data = {"tags": ["python"]}
data["tags"].append("字典")

print(data)
```

输出：

```python
{'tags': ['python', '字典']}
```

如果这个键一开始不存在，可以这样写：

```python
data = {}
data.setdefault("tags", []).append("python")

print(data)
```

输出：

```python
{'tags': ['python']}
```

这种写法在分组、归类、收集数据时很常见。

### 3. 值是字典：做嵌套赋值

比如一个用户信息字典里还有地址信息：

```python
user = {"name": "小王"}
user["address"] = {}
user["address"]["city"] = "上海"

print(user)
```

输出：

```python
{'name': '小王', 'address': {'city': '上海'}}
```

如果你直接写：

```python
user = {"name": "小王"}
user["address"]["city"] = "上海"
```

就会报错，因为 `address` 这个键还不存在。

更安全的写法是：

```python
user = {"name": "小王"}
user.setdefault("address", {})["city"] = "上海"

print(user)
```

输出：

```python
{'name': '小王', 'address': {'city': '上海'}}
```

所以，很多“字典加值失败”的问题，不是字典不会加，而是**你没有先把中间层初始化好**。

## 五、实际开发里最容易踩的 4 个误区

“python怎么给字典加值”看起来简单，但真正写代码时，常见错误很集中，基本都出在下面几类。

### 1. 以为赋值只能新增，没意识到会覆盖

很多人写：

```python
d["name"] = "新名字"
```

心里想的是“添加一个字段”，结果原来的 `name` 被改掉了。只要键相同，直接赋值就是覆盖，不会报提醒，也不会保留旧值。

如果你的业务要求“不允许覆盖”，就要先判断：

```python
if "name" not in d:
    d["name"] = "新名字"
```

或者用：

```python
d.setdefault("name", "新名字")
```

### 2. 对不存在的键直接累加

下面这种写法很常见：

```python
d["count"] += 1
```

如果 `count` 还不存在，就一定报错。更稳妥的是：

```python
d["count"] = d.get("count", 0) + 1
```

这类问题常出现在计数、统计、汇总逻辑里。

### 3. 嵌套字典没初始化就直接赋值

像这样：

```python
d["user"]["age"] = 18
```

如果 `user` 不存在，会直接报错。必须先确保 `user` 是个字典：

```python
d.setdefault("user", {})["age"] = 18
```

### 4. 把列表追加和字典新增混为一谈

有人会把下面两件事混淆：

```python
d["a"] = 1
```

和

```python
d["a"].append(1)
```

前者是在给字典设置某个键的值，后者是在操作这个键对应的列表对象。只有当 `d["a"]` 本身已经是列表时，`append()` 才成立。

可以简单理解为：

- `d[key] = value`：改的是字典结构
- `d[key].append(value)`：改的是值内部的内容

这个区分非常重要，尤其在处理复杂数据时。

## 六、怎么选最合适的写法，关键看你的目标

如果你只是日常写脚本，知道几种语法就够了；但如果你想真正把“给字典加值”这件事写得稳定，不容易出 bug，就要根据目的选方法，而不是看到什么就写什么。

可以按这个思路判断：

| 你的目标 | 推荐写法 | 原因 |
|---|---|---|
| 加一个新字段 | `d[key] = value` | 最直接 |
| 一次加多个字段 | `d.update({...})` | 更简洁 |
| 键不存在才添加 | `d.setdefault(key, value)` | 防止覆盖 |
| 给数值做累加 | `d[key] = d.get(key, 0) + n` | 避免 KeyError |
| 给列表追加元素 | `d.setdefault(key, []).append(x)` | 兼顾初始化和追加 |
| 给嵌套字典赋值 | `d.setdefault(parent, {})[child] = value` | 先创建中间层 |

真正实用的不是死记语法，而是先问自己一句：**我现在是要新增、覆盖、累加，还是追加内部内容？**

一旦这个问题想清楚，写法自然就明确了。

## 七、总结

Python 给字典加值，最基础的方式是 `d[key] = value`，它既能新增，也能修改。想批量加值，用 `update()`；想在键不存在时再设置默认值，用 `setdefault()`；想做计数、列表追加、嵌套赋值，就要根据值的类型换写法。

如果你只记一个原则，记这个就够：**先分清你的操作目标，再选对应方法**。很多字典加值出错，不是因为语法难，而是把“新增”“覆盖”“累加”“嵌套赋值”混在了一起。把这几类场景拆开处理，字典操作就会清楚很多。

可以直接通过键名赋值来更新，例如：d['key'] = 新值。若想基于原值进行修改，也可以先读取旧值再计算后赋回去。

更新字典键的值

如果字典中某个键已经存在，我想把它的值改掉，应该用什么方式更合适？

Python 字典里已经有同名键时，怎么正确更新它的值？

直接使用 d['新键'] = 值 就能新增一项。如果键原本不存在，Python 会自动创建这个键值对。

向字典添加键值对

在字典里加入一个新的键值对，应该怎么操作才不会出错？

我想给 Python 字典新增一项，键不存在时该怎么写？

可以使用 update 方法批量添加多个键值对，例如 d.update({'a': 1, 'b': 2})。也可以循环遍历数据源，逐个写入到字典中。

批量写入字典数据

我有一组键和值，想一起放进字典里，有哪些常用写法？

如何一次性给 Python 字典批量添加多个值？

PingCodeDocs

Python 给字典加值最常用的是 d[key] = value，这种写法既能新增键值对，也会在键已存在时覆盖原值。一次添加多个值可以用 update()，如果只想在键不存在时添加默认值，更适合用 setdefault()。如果是给数字累加、给列表追加、给嵌套字典赋值，就不能只看“加值”两个字，而要先判断这个键对应的值是什么类型。实际使用中最容易出错的是误覆盖旧值、对不存在的键直接累加、嵌套层级没初始化。只要先分清自己是要新增、修改、累加还是追加内容，再选对应写法，Python 字典加值就不容易写错。