# Python Basics - dict 메서드
**dict 메서드**는 딕셔너리의 키-값 쌍을 동적으로 검색, 수정, 순회하는 방법들입니다.
---
## 조회 및 접근
### `get(key, default=None)` — 안전한 키 조회
```python
d = {"name": "Alice", "age": 30}
# 키 존재
value = d.get("name") # "Alice"
# 키 없을 때
value = d.get("job") # None (KeyError 아님)
value = d.get("job", "N/A") # "N/A" (기본값)
# d["job"]과의 차이
try:
value = d["job"] # KeyError 발생
except KeyError:
print("키 없음")
```
**특징:**
- 시간복잡도: **O(1)** 평균
- 키 없을 때 안전하게 None 또는 기본값 반환
- d[key]는 KeyError 발생, get()은 안전
---
### `keys()` — 모든 키 조회
```python
d = {"a": 1, "b": 2, "c": 3}
keys = d.keys() # dict_keys(['a', 'b', 'c'])
list(d.keys()) # ['a', 'b', 'c']
# 순회
for key in d.keys():
print(key) # a, b, c
# 멤버십 검증 (O(1))
"a" in d.keys() # True
```
**특징:**
- 반환: view 객체 (동적, 딕셔너리 변경 시 반영)
- 순회: O(1) per 항목
- 검증: O(1) 평균
---
### `values()` — 모든 값 조회
```python
d = {"name": "Alice", "age": 30}
values = d.values() # dict_values(['Alice', 30])
list(d.values()) # ['Alice', 30]
# 순회
for value in d.values():
print(value) # Alice, 30
```
**특징:**
- 반환: view 객체
- 중복 가능 (같은 값 여러 개)
- 멤버십 검증: O(n) (값을 찾아야 함)
---
### `items()` — 키-값 쌍 조회
```python
d = {"name": "Alice", "age": 30}
# 튜플 쌍 반환
items = d.items() # dict_items([('name', 'Alice'), ('age', 30)])
# 순회 (권장)
for key, value in d.items():
print(f"{key}: {value}") # name: Alice, age: 30
# 일반적 패턴과 비교
for key in d:
print(f"{key}: {d[key]}") # 비효율적 (조회 한 번 더)
```
**특징:**
- 가장 효율적인 순회 방법
- 언팩킹으로 간결한 코드
---
## 수정 및 삭제
### `update(other)` — 여러 키-값 한 번에 추가/수정
```python
d = {"a": 1, "b": 2}
# 다른 딕셔너리로 업데이트
d.update({"c": 3, "a": 99}) # {"a": 99, "b": 2, "c": 3}
# 키워드 인자로 업데이트
d.update(x=10, y=20) # {"a": 99, "b": 2, "c": 3, "x": 10, "y": 20}
# iterable of pairs로 업데이트
d.update([("p", 100), ("q", 200)])
```
**특징:**
- 시간복잡도: **O(n)** (n = 추가할 항목)
- 기존 키는 덮어쓰기
- 반환값: None (제자리 수정)
---
### `pop(key, default=None)` — 키 제거 및 값 반환
```python
d = {"a": 1, "b": 2, "c": 3}
value = d.pop("b") # 2, d = {"a": 1, "c": 3}
value = d.pop("x") # KeyError 발생
# 기본값
value = d.pop("x", -1) # -1 (안전)
```
**특징:**
- 시간복잡도: **O(1)** 평균
- 키 없으면 KeyError (기본값 있으면 기본값 반환)
- 값을 반환 (del d[key]는 None 반환)
---
### `popitem()` — 임의의 키-값 쌍 제거 및 반환
```python
d = {"a": 1, "b": 2, "c": 3}
key, value = d.popitem() # ("c", 3) [Python 3.7+: 마지막 항목]
print(d) # {"a": 1, "b": 2}
# 빈 딕셔너리에서
d = {}
d.popitem() # KeyError: dictionary is empty
```
**특징:**
- 시간복잡도: **O(1)** 평균
- Python 3.7+: LIFO 순서 (마지막 항목)
- 공백 파이썬 3.7 이전: 임의 순서
---
### `clear()` — 모든 항목 제거
```python
d = {"a": 1, "b": 2}
d.clear() # {}
# 동치 방법
d = {} # 새 객체 생성
```
**특징:**
- 시간복잡도: **O(n)**
- 딕셔너리 객체는 유지
---
### `setdefault(key, default=None)` — 키 없으면 추가, 값 반환
```python
d = {"a": 1}
# 키 존재: 값 반환 (수정 없음)
value = d.setdefault("a", 99) # 1
# 키 없음: 추가 후 값 반환
value = d.setdefault("b", 2) # 2, d = {"a": 1, "b": 2}
# 기본값 생략
value = d.setdefault("c") # None, d = {..., "c": None}
# 일반적 패턴
if "d" not in d:
d["d"] = 100
# 위 코드를 다음과 같이 축약
d.setdefault("d", 100)
```
**특징:**
- 시간복잡도: **O(1)** 평균
- get() 유사 (읽기만) vs setdefault() (없으면 쓰기)
---
## 생성
### `fromkeys(iterable, value=None)` — 키 리스트에서 딕셔너리 생성
```python
# 키 iterable에서 생성
keys = ["a", "b", "c"]
d1 = dict.fromkeys(keys) # {"a": None, "b": None, "c": None}
d2 = dict.fromkeys(keys, 0) # {"a": 0, "b": 0, "c": 0}
# 문자열도 가능 (각 문자가 키)
d3 = dict.fromkeys("abc", False) # {"a": False, "b": False, "c": False}
# 주의: 가변 객체는 공유됨
d4 = dict.fromkeys(["x", "y"], [])
d4["x"].append(1)
print(d4) # {"x": [1], "y": [1]} (공유됨!)
```
**특징:**
- 시간복잡도: **O(n)**
- value가 가변이면 모든 키가 같은 객체 공유
- list, dict 등은 deepcopy 필요
---
## 복사
### `copy()` — 얕은 복사 (Shallow Copy)
```python
original = {"a": 1, "nested": [2, 3]}
shallow = original.copy()
# 최상위 값은 복사
shallow["a"] = 99
print(original) # {"a": 1, ...} (영향 없음)
# 중첩 객체는 공유
shallow["nested"].append(4)
print(original) # {"a": 1, "nested": [2, 3, 4]} (영향!)
# 깊은 복사
import copy
deep = copy.deepcopy(original)
deep["nested"].append(5)
print(original) # 영향 없음
```
**특징:**
- 시간복잡도: **O(n)** (최상위만)
- 얕은 복사: 중첩 객체는 공유
---
## 참고: 순회 방식 비교
| 방식 | 코드 | 효율성 |
|------|------|--------|
| **keys 명시** | `for k in d.keys()` | 일반적 |
| **키만** | `for k in d` | 권장 (간결) |
| **값만** | `for v in d.values()` | O(n) |
| **쌍** | `for k, v in d.items()` | 권장 (효율) |
---
## 관련 개념
- [[./python-basics-collections|Python Basics - Collections]] — dict 기본
- [[./python-mutable-immutable|Mutable vs Immutable]] — 가변성 원리
---
**마지막 업데이트**: 2026-05-10 | **상태**: Part of Basic Types Series