Python Basic: dict

1. 딕셔너리 생성

딕셔너리 = {키: 값}

키와 값을 한 쌍으로 저장

# 성공: 딕셔너리 생성
user = {"name": "kim", "age": 20}

print(user)  # {'name': 'kim', 'age': 20}

# 성공: 여러 타입 저장 가능
data = {
    "name": "lee",
    "scores": [90, 80],
    "is_admin": False
}

print(data)
# {'name': 'lee', 'scores': [90, 80], 'is_admin': False}

# 주의: 키는 중복될 수 없음
user = {"name": "kim", "name": "lee"}

print(user)  # {'name': 'lee'}

# 주의: 리스트는 키로 사용할 수 없음
data = {[1, 2]: "hello"}  # TypeError

2. 딕셔너리 값 가져오기

딕셔너리[키]

키를 이용해 값 가져오기

# 성공: 키로 값 가져오기
user = {"name": "kim", "age": 20}

print(user["name"])  # kim
print(user["age"])   # 20

# 주의: 없는 키를 사용하면 에러 발생
user = {"name": "kim"}

print(user["age"])  # KeyError

3. get()

딕셔너리.get(키)
딕셔너리.get(키, 기본값)

키에 해당하는 값 가져오기

# 성공: 값 가져오기
user = {"name": "kim", "age": 20}

print(user.get("name"))  # kim

# 성공: 없는 키는 None 반환
print(user.get("email"))  # None

# 성공: 기본값 지정 가능
print(user.get("email", "없음"))  # 없음

# 주의: []와 다르게 에러가 나지 않음
user = {"name": "kim"}

print(user.get("age"))  # None

4. 딕셔너리 값 추가

딕셔너리[새키] = 값

새로운 키와 값 추가

# 성공: 값 추가
user = {"name": "kim"}

user["age"] = 20

print(user)
# {'name': 'kim', 'age': 20}

# 주의: 이미 있는 키면 값이 덮어쓰기됨
user = {"name": "kim"}

user["name"] = "lee"

print(user)
# {'name': 'lee'}

5. 딕셔너리 값 변경

딕셔너리[키] = 새값

기존 값 수정

# 성공: 값 변경
user = {"name": "kim", "age": 20}

user["age"] = 21

print(user)
# {'name': 'kim', 'age': 21}

# 주의: 없는 키면 새로 추가됨
user = {"name": "kim"}

user["age"] = 20

print(user)
# {'name': 'kim', 'age': 20}

6. del

del 딕셔너리[키]

특정 키와 값 삭제

# 성공: 키 삭제
user = {"name": "kim", "age": 20}

del user["age"]

print(user)
# {'name': 'kim'}

# 주의: 없는 키 삭제 시 에러 발생
user = {"name": "kim"}

del user["age"]  # KeyError

7. pop()

딕셔너리.pop(키)

키 삭제 후 값 반환

# 성공: 값 반환 후 삭제
user = {"name": "kim", "age": 20}

result = user.pop("age")

print(result)  # 20
print(user)    # {'name': 'kim'}

# 주의: 없는 키는 에러 발생
user = {"name": "kim"}

user.pop("age")  # KeyError

8. clear()

딕셔너리.clear()

딕셔너리 전체 비우기

# 성공: 전체 삭제
user = {"name": "kim", "age": 20}

user.clear()

print(user)  # {}

# 주의: 원본 딕셔너리가 직접 변경됨
user = {"name": "kim"}

result = user.clear()

print(result)  # None

9. keys()

딕셔너리.keys()

모든 키 가져오기

# 성공: 키 목록 가져오기
user = {"name": "kim", "age": 20}

print(user.keys())
# dict_keys(['name', 'age'])

# 성공: 리스트로 변환 가능
print(list(user.keys()))
# ['name', 'age']

# 주의: 결과는 리스트가 아니라 dict_keys 객체
user = {"name": "kim"}

result = user.keys()

print(result)
# dict_keys(['name'])

10. values()

딕셔너리.values()

모든 값 가져오기

# 성공: 값 가져오기
user = {"name": "kim", "age": 20}

print(user.values())
# dict_values(['kim', 20])

# 성공: 리스트 변환 가능
print(list(user.values()))
# ['kim', 20]

# 주의: 키는 포함되지 않음
user = {"name": "kim"}

print(user.values())
# dict_values(['kim'])

11. items()

딕셔너리.items()

키와 값을 함께 가져오기

# 성공: 키와 값 가져오기
user = {"name": "kim", "age": 20}

print(user.items())
# dict_items([('name', 'kim'), ('age', 20)])

# 성공: 반복문에서 자주 사용
for key, value in user.items():
    print(key, value)

# name kim
# age 20

# 주의: 튜플 형태로 저장됨
user = {"name": "kim"}

print(list(user.items()))
# [('name', 'kim')]

12. in

키 in 딕셔너리

딕셔너리에 키가 있는지 확인

# 성공: 키 존재 확인
user = {"name": "kim", "age": 20}

print("name" in user)   # True
print("email" in user)  # False

# 주의: 값 기준이 아니라 키 기준
user = {"name": "kim"}

print("kim" in user)   # False
print("name" in user)  # True

13. not in

키 not in 딕셔너리

딕셔너리에 키가 없는지 확인

# 성공: 키가 없으면 True
user = {"name": "kim"}

print("email" not in user)  # True

# 성공: 키가 있으면 False
print("name" not in user)  # False

# 주의: 값 기준이 아님
user = {"name": "kim"}

print("kim" not in user)  # True

14. for 반복문

for key in 딕셔너리:
    실행문

딕셔너리 키 반복

# 성공: 키 반복
user = {"name": "kim", "age": 20}

for key in user:
    print(key)

# name
# age

# 성공: 값 접근 가능
for key in user:
    print(key, user[key])

# name kim
# age 20

# 주의: 기본 반복은 키만 가져옴
user = {"name": "kim"}

for value in user:
    print(value)

# name

15. items() 반복문

for key, value in 딕셔너리.items():
    실행문

키와 값을 동시에 반복

# 성공: 키와 값 함께 출력
user = {"name": "kim", "age": 20}

for key, value in user.items():
    print(key, value)

# name kim
# age 20

# 주의: 변수 개수를 맞춰야 함
user = {"name": "kim"}

for item in user.items():
    print(item)

# ('name', 'kim')

16. update()

딕셔너리.update(딕셔너리)

여러 값 한 번에 추가 또는 수정

# 성공: 여러 값 추가
user = {"name": "kim"}

user.update({"age": 20, "city": "seoul"})

print(user)
# {'name': 'kim', 'age': 20, 'city': 'seoul'}

# 성공: 기존 값 수정 가능
user.update({"name": "lee"})

print(user)
# {'name': 'lee', 'age': 20, 'city': 'seoul'}

# 주의: 같은 키는 덮어쓰기됨
data = {"a": 1}

data.update({"a": 999})

print(data)
# {'a': 999}

17. copy()

딕셔너리.copy()

딕셔너리 복사

# 성공: 딕셔너리 복사
user = {"name": "kim", "age": 20}

copied = user.copy()

print(copied)
# {'name': 'kim', 'age': 20}

# 성공: 서로 다른 객체
copied["age"] = 30

print(user)
# {'name': 'kim', 'age': 20}

print(copied)
# {'name': 'kim', 'age': 30}

# 주의: 얕은 복사(shallow copy)
data = {
    "scores": [1, 2]
}

copied = data.copy()

copied["scores"][0] = 999

print(data)
# {'scores': [999, 2]}

18. len()

len(딕셔너리)

키 개수 구하기

# 성공: 키 개수 반환
user = {"name": "kim", "age": 20}

print(len(user))  # 2

# 성공: 빈 딕셔너리
data = {}

print(len(data))  # 0

# 주의: 값 개수가 아니라 키 개수 기준
data = {
    "a": [1, 2, 3]
}

print(len(data))  # 1

19. 중첩 딕셔너리

딕셔너리 = {
    키: {
        내부키: 값
    }
}

딕셔너리 안에 딕셔너리 저장

# 성공: 중첩 딕셔너리 생성
user = {
    "name": "kim",
    "contact": {
        "email": "test@test.com",
        "phone": "010-1111-2222"
    }
}

print(user["contact"]["email"])
# test@test.com

# 주의: 키를 단계별로 접근해야 함
user = {
    "contact": {
        "email": "test@test.com"
    }
}

print(user["contact"])
# {'email': 'test@test.com'}

20. 딕셔너리 컴프리헨션

{키표현식: 값표현식 for 변수 in 반복가능한값}

딕셔너리를 짧게 생성

# 성공: 숫자 제곱 저장
nums = [1, 2, 3]

result = {num: num * num for num in nums}

print(result)
# {1: 1, 2: 4, 3: 9}

# 성공: 문자열 길이 저장
fruits = ["apple", "banana"]

result = {fruit: len(fruit) for fruit in fruits}

print(result)
# {'apple': 5, 'banana': 6}

# 주의: 키가 중복되면 마지막 값만 유지
nums = [1, 1, 1]

result = {num: num * 10 for num in nums}

print(result)
# {1: 10}

21. setdefault()

딕셔너리.setdefault(키)
딕셔너리.setdefault(키, 기본값)

키가 없으면 기본값 추가 후 반환

# 성공: 없는 키면 추가됨
user = {"name": "kim"}

result = user.setdefault("age", 20)

print(result)  # 20
print(user)    # {'name': 'kim', 'age': 20}

# 성공: 이미 키가 있으면 기존 값 반환
result = user.setdefault("name", "lee")

print(result)  # kim
print(user)    # {'name': 'kim', 'age': 20}

# 주의: 기존 값은 변경되지 않음
user = {"name": "kim"}

user.setdefault("name", "lee")

print(user)
# {'name': 'kim'}

22. popitem()

딕셔너리.popitem()

마지막 키와 값 삭제 후 반환

# 성공: 마지막 데이터 제거
user = {
    "name": "kim",
    "age": 20
}

result = user.popitem()

print(result)  # ('age', 20)
print(user)    # {'name': 'kim'}

# 주의: 빈 딕셔너리에서는 에러 발생
data = {}

data.popitem()  # KeyError

23. fromkeys()

dict.fromkeys(반복가능한값)
dict.fromkeys(반복가능한값, 기본값)

여러 키를 한 번에 생성

# 성공: 기본값 None
keys = ["name", "age", "email"]

result = dict.fromkeys(keys)

print(result)
# {'name': None, 'age': None, 'email': None}

# 성공: 기본값 지정 가능
result = dict.fromkeys(keys, 0)

print(result)
# {'name': 0, 'age': 0, 'email': 0}

# 주의: 가변 객체 사용 시 공유됨
keys = ["a", "b"]

data = dict.fromkeys(keys, [])

data["a"].append(1)

print(data)
# {'a': [1], 'b': [1]}

24. sorted()

sorted(딕셔너리)

키를 기준으로 정렬

# 성공: 키 정렬
user = {
    "c": 3,
    "a": 1,
    "b": 2
}

result = sorted(user)

print(result)
# ['a', 'b', 'c']

# 성공: items()와 함께 사용 가능
result = sorted(user.items())

print(result)
# [('a', 1), ('b', 2), ('c', 3)]

# 주의: sorted() 결과는 리스트 반환
user = {"b": 2, "a": 1}

result = sorted(user)

print(type(result))
# <class 'list'>

25. 딕셔너리 합치기

딕셔너리 | 딕셔너리

딕셔너리 병합하기 (Python 3.9+)

# 성공: 딕셔너리 합치기
a = {"x": 1}
b = {"y": 2}

result = a | b

print(result)
# {'x': 1, 'y': 2}

# 성공: 같은 키는 뒤쪽 값 사용
a = {"x": 1}
b = {"x": 999}

print(a | b)
# {'x': 999}

# 주의: 원본은 변경되지 않음
a = {"x": 1}
b = {"y": 2}

result = a | b

print(a)
# {'x': 1}

26. update()로 합치기

딕셔너리.update(다른딕셔너리)

원본 딕셔너리에 병합

# 성공: 병합
a = {"x": 1}
b = {"y": 2}

a.update(b)

print(a)
# {'x': 1, 'y': 2}

# 주의: 원본 딕셔너리가 직접 변경됨
a = {"x": 1}
b = {"x": 999}

a.update(b)

print(a)
# {'x': 999}

27. 딕셔너리 컴프리헨션 조건문

{키: 값 for 변수 in 반복 if 조건}

조건에 맞는 값만 저장

# 성공: 짝수만 저장
nums = [1, 2, 3, 4]

result = {
    num: num * 10
    for num in nums
    if num % 2 == 0
}

print(result)
# {2: 20, 4: 40}

# 성공: 길이 5 이상 문자열만 저장
fruits = ["apple", "kiwi", "banana"]

result = {
    fruit: len(fruit)
    for fruit in fruits
    if len(fruit) >= 5
}

print(result)
# {'apple': 5, 'banana': 6}

# 주의: 조건에 맞는 값이 없으면 빈 딕셔너리
nums = [1, 3, 5]

result = {
    num: num
    for num in nums
    if num % 2 == 0
}

print(result)
# {}

28. 중첩 딕셔너리 반복

for key, value in 딕셔너리.items():

중첩 데이터 반복 처리

# 성공: 중첩 딕셔너리 반복
users = {
    "kim": {"age": 20},
    "lee": {"age": 30}
}

for name, info in users.items():
    print(name, info["age"])

# kim 20
# lee 30

# 주의: 내부 값도 딕셔너리일 수 있음
users = {
    "kim": {"age": 20}
}

print(users["kim"])
# {'age': 20}

29. zip()으로 딕셔너리 만들기

dict(zip(리스트1, 리스트2))

두 리스트를 묶어서 딕셔너리 생성

# 성공: 리스트 두 개 묶기
keys = ["name", "age"]
values = ["kim", 20]

result = dict(zip(keys, values))

print(result)
# {'name': 'kim', 'age': 20}

# 주의: 길이가 다르면 짧은 쪽 기준
keys = ["a", "b", "c"]
values = [1]

result = dict(zip(keys, values))

print(result)
# {'a': 1}

30. 딕셔너리 정렬

sorted(딕셔너리.items())

키 또는 값 기준 정렬

# 성공: 키 기준 정렬
data = {
    "b": 2,
    "a": 1,
    "c": 3
}

result = sorted(data.items())

print(result)
# [('a', 1), ('b', 2), ('c', 3)]

# 성공: 값 기준 정렬
result = sorted(
    data.items(),
    key=lambda item: item[1]
)

print(result)
# [('a', 1), ('b', 2), ('c', 3)]

# 주의: sorted 결과는 리스트
data = {"a": 1}

result = sorted(data.items())

print(type(result))
# <class 'list'>

31. 딕셔너리 길이 비교

len(딕셔너리)

딕셔너리 데이터 개수 확인

# 성공: 데이터 개수 확인
user = {
    "name": "kim",
    "age": 20,
    "city": "seoul"
}

print(len(user))
# 3

# 성공: 빈 딕셔너리
data = {}

print(len(data))
# 0

# 주의: 키 개수를 기준으로 셈
data = {
    "scores": [10, 20, 30]
}

print(len(data))
# 1

32. 딕셔너리 비교

딕셔너리 == 딕셔너리

딕셔너리 내용 비교

# 성공: 내용이 같으면 True
a = {"x": 1, "y": 2}
b = {"y": 2, "x": 1}

print(a == b)
# True

# 성공: 값이 다르면 False
c = {"x": 999}

print(a == c)
# False

# 주의: 순서는 상관없음
a = {"a": 1, "b": 2}
b = {"b": 2, "a": 1}

print(a == b)
# True

33. 딕셔너리 안에 리스트 저장

딕셔너리 = {
    키: 리스트
}

값으로 리스트 저장 가능

# 성공: 리스트 저장
user = {
    "scores": [90, 80, 70]
}

print(user["scores"])
# [90, 80, 70]

# 성공: 리스트 값 접근
print(user["scores"][0])
# 90

# 주의: 인덱스를 한 번 더 사용해야 함
user = {
    "scores": [90, 80]
}

print(user["scores"])
# [90, 80]

34. 딕셔너리 안에 딕셔너리 저장

딕셔너리 = {
    키: 딕셔너리
}

중첩 딕셔너리 사용

# 성공: 중첩 딕셔너리
user = {
    "name": "kim",
    "contact": {
        "email": "test@test.com",
        "phone": "010"
    }
}

print(user["contact"]["email"])
# test@test.com

# 주의: 키를 단계별로 접근해야 함
user = {
    "contact": {
        "email": "test@test.com"
    }
}

print(user["contact"])
# {'email': 'test@test.com'}

35. 리스트 안의 딕셔너리

리스트 = [
    {키: 값},
    {키: 값}
]

딕셔너리를 여러 개 저장

# 성공: 여러 사용자 저장
users = [
    {"name": "kim", "age": 20},
    {"name": "lee", "age": 30}
]

print(users[0]["name"])
# kim

print(users[1]["age"])
# 30

# 주의: 인덱스 후 키 접근 필요
users = [
    {"name": "kim"}
]

print(users[0])
# {'name': 'kim'}

36. 딕셔너리 + for 반복문

for key in 딕셔너리:

키를 하나씩 반복

# 성공: 키 출력
user = {
    "name": "kim",
    "age": 20
}

for key in user:
    print(key)

# name
# age

# 성공: 값 출력
for key in user:
    print(user[key])

# kim
# 20

# 주의: 기본 반복은 키 반복
user = {"name": "kim"}

for item in user:
    print(item)

# name

37. items() + enumerate()

enumerate(딕셔너리.items())

번호와 함께 반복

# 성공: 번호와 함께 출력
user = {
    "name": "kim",
    "age": 20
}

for index, (key, value) in enumerate(user.items()):
    print(index, key, value)

# 0 name kim
# 1 age 20

# 주의: 괄호 위치 중요
user = {"name": "kim"}

for index, item in enumerate(user.items()):
    print(index, item)

# 0 ('name', 'kim')

38. 딕셔너리 값 합계

sum(딕셔너리.values())

숫자 값들의 합계 계산

# 성공: 값 합계 계산
scores = {
    "math": 90,
    "english": 80,
    "science": 70
}

result = sum(scores.values())

print(result)
# 240

# 주의: 문자열이 포함되면 에러 발생
data = {
    "a": 1,
    "b": "2"
}

sum(data.values())  # TypeError

39. max(), min()

max(딕셔너리.values())
min(딕셔너리.values())

최댓값과 최솟값 구하기

# 성공: 최댓값
scores = {
    "math": 90,
    "english": 80,
    "science": 70
}

print(max(scores.values()))
# 90

# 성공: 최솟값
print(min(scores.values()))
# 70

# 주의: 타입이 섞이면 비교 불가
data = {
    "a": 1,
    "b": "2"
}

max(data.values())  # TypeError

40. sorted() 값 기준 정렬

sorted(딕셔너리.items(), key=lambda item: item[1])

값 기준으로 정렬

# 성공: 값 기준 오름차순
scores = {
    "kim": 70,
    "lee": 90,
    "park": 80
}

result = sorted(
    scores.items(),
    key=lambda item: item[1]
)

print(result)
# [('kim', 70), ('park', 80), ('lee', 90)]

# 성공: 내림차순
result = sorted(
    scores.items(),
    key=lambda item: item[1],
    reverse=True
)

print(result)
# [('lee', 90), ('park', 80), ('kim', 70)]

# 주의: 결과는 리스트 반환
scores = {"kim": 70}

result = sorted(
    scores.items(),
    key=lambda item: item[1]
)

print(type(result))
# <class 'list'>

41. any()

any(딕셔너리.values())

하나라도 True면 True 반환

# 성공: 하나라도 True면 True
data = {
    "a": 0,
    "b": False,
    "c": 10
}

print(any(data.values()))
# True

# 성공: 모두 False면 False
data = {
    "a": 0,
    "b": False
}

print(any(data.values()))
# False

# 주의: values()를 사용해야 값 기준 검사
data = {
    "a": 0
}

print(any(data))
# True

42. all()

all(딕셔너리.values())

모든 값이 True인지 확인

# 성공: 모두 True면 True
data = {
    "a": 1,
    "b": 2,
    "c": 3
}

print(all(data.values()))
# True

# 성공: 하나라도 False면 False
data = {
    "a": 1,
    "b": 0
}

print(all(data.values()))
# False

# 주의: 0, False, None, 빈 문자열은 False 취급
data = {
    "a": "",
    "b": 1
}

print(all(data.values()))
# False

43. setdefault() 리스트 활용

딕셔너리.setdefault(키, [])

리스트 초기화에 자주 사용

# 성공: 그룹 만들기
data = {}

data.setdefault("python", []).append("kim")
data.setdefault("python", []).append("lee")

print(data)
# {'python': ['kim', 'lee']}

# 주의: 없는 키일 때만 기본값 생성
data = {
    "python": ["kim"]
}

data.setdefault("python", []).append("lee")

print(data)
# {'python': ['kim', 'lee']}

44. 딕셔너리 컴프리헨션 if-else

{
    키: 참값 if 조건 else 거짓값
    for 변수 in 반복
}

조건에 따라 값 변경

# 성공: 짝수/홀수 저장
nums = [1, 2, 3, 4]

result = {
    num: "짝수" if num % 2 == 0 else "홀수"
    for num in nums
}

print(result)
# {1: '홀수', 2: '짝수', 3: '홀수', 4: '짝수'}

# 성공: 음수는 0 처리
nums = [10, -5, 3]

result = {
    num: num if num > 0 else 0
    for num in nums
}

print(result)
# {10: 10, -5: 0, 3: 3}

# 주의: if-else 위치 중요
nums = [1, 2]

result = {
    num: "짝수" if num % 2 == 0 else "홀수"
    for num in nums
}

print(result)
# {1: '홀수', 2: '짝수'}

45. tuple을 키로 사용

딕셔너리 = {
    (값1, 값2): 값
}

튜플은 키로 사용 가능

# 성공: 튜플 키 사용
data = {
    (1, 2): "hello",
    (3, 4): "python"
}

print(data[(1, 2)])
# hello

# 주의: 리스트는 키로 사용할 수 없음
data = {
    [1, 2]: "hello"
}
# TypeError

46. dict()

dict()

딕셔너리 생성 함수

# 성공: 빈 딕셔너리 생성
data = dict()

print(data)
# {}

# 성공: 키워드 방식 생성
user = dict(name="kim", age=20)

print(user)
# {'name': 'kim', 'age': 20}

# 주의: 키워드는 문자열만 가능
data = dict(a=1)

print(data)
# {'a': 1}

47. dict() + 리스트

dict(리스트)

튜플 리스트를 딕셔너리로 변환

# 성공: 튜플 리스트 변환
data = [
    ("name", "kim"),
    ("age", 20)
]

result = dict(data)

print(result)
# {'name': 'kim', 'age': 20}

# 주의: 요소 개수가 2개여야 함
data = [
    ("name", "kim", 123)
]

dict(data)  # ValueError

48. copy() vs =

copy()
=

복사와 참조 차이

# 성공: copy는 별도 객체 생성
a = {"x": 1}

b = a.copy()

b["x"] = 999

print(a)
# {'x': 1}

print(b)
# {'x': 999}

# 주의: = 는 같은 객체 참조
a = {"x": 1}

b = a

b["x"] = 999

print(a)
# {'x': 999}

49. 딕셔너리 삭제 반복

for key in list(딕셔너리.keys()):

반복 중 안전하게 삭제

# 성공: 조건에 맞는 키 삭제
data = {
    "a": 1,
    "b": 0,
    "c": 2
}

for key in list(data.keys()):
    if data[key] == 0:
        del data[key]

print(data)
# {'a': 1, 'c': 2}

# 주의: 반복 중 직접 삭제하면 에러 가능
data = {
    "a": 1,
    "b": 0
}

for key in data:
    del data[key]
# RuntimeError

50. 딕셔너리 정렬 후 다시 변환

dict(sorted(...))

정렬된 딕셔너리 만들기

# 성공: 키 기준 정렬
data = {
    "c": 3,
    "a": 1,
    "b": 2
}

result = dict(sorted(data.items()))

print(result)
# {'a': 1, 'b': 2, 'c': 3}

# 성공: 값 기준 정렬
result = dict(
    sorted(
        data.items(),
        key=lambda item: item[1]
    )
)

print(result)
# {'a': 1, 'b': 2, 'c': 3}

# 주의: Python 3.7+부터 입력 순서 유지
data = {
    "b": 2,
    "a": 1
}

print(data)
# {'b': 2, 'a': 1}

51. defaultdict()

from collections import defaultdict

없는 키를 자동 생성

# 성공: 기본값 자동 생성
from collections import defaultdict

data = defaultdict(int)

data["apple"] += 1
data["apple"] += 1

print(data)
# defaultdict(<class 'int'>, {'apple': 2})

# 성공: 리스트 기본값
groups = defaultdict(list)

groups["python"].append("kim")
groups["python"].append("lee")

print(groups)
# defaultdict(<class 'list'>, {'python': ['kim', 'lee']})

# 주의: 일반 dict는 없는 키 접근 시 에러
data = {}

data["apple"] += 1
# KeyError

52. Counter()

from collections import Counter

데이터 개수 세기

# 성공: 문자 개수 세기
from collections import Counter

data = ["apple", "banana", "apple"]

result = Counter(data)

print(result)
# Counter({'apple': 2, 'banana': 1})

# 성공: 문자열도 가능
text = "hello"

print(Counter(text))
# Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})

# 주의: 결과 타입은 Counter 객체
from collections import Counter

data = Counter(["a", "a"])

print(type(data))
# <class 'collections.Counter'>

53. most_common()

Counter(...).most_common()

가장 많이 나온 데이터 확인

# 성공: 빈도순 정렬
from collections import Counter

data = Counter(["a", "b", "a", "c", "a"])

print(data.most_common())
# [('a', 3), ('b', 1), ('c', 1)]

# 성공: 상위 n개 가져오기
print(data.most_common(2))
# [('a', 3), ('b', 1)]

# 주의: 결과는 리스트
from collections import Counter

data = Counter(["a"])

result = data.most_common()

print(type(result))
# <class 'list'>

54. JSON → dict

json.loads(JSON문자열)

JSON 문자열을 딕셔너리로 변환

# 성공: JSON 문자열 변환
import json

text = '{"name": "kim", "age": 20}'

result = json.loads(text)

print(result)
# {'name': 'kim', 'age': 20}

print(type(result))
# <class 'dict'>

# 주의: JSON 형식이 틀리면 에러
import json

text = "{name: kim}"

json.loads(text)
# JSONDecodeError

55. dict → JSON

json.dumps(딕셔너리)

딕셔너리를 JSON 문자열로 변환

# 성공: JSON 문자열 변환
import json

data = {
    "name": "kim",
    "age": 20
}

result = json.dumps(data)

print(result)
# {"name": "kim", "age": 20}

# 주의: 결과는 문자열
import json

data = {"a": 1}

result = json.dumps(data)

print(type(result))
# <class 'str'>

56. ensure_ascii=False

json.dumps(..., ensure_ascii=False)

한글 깨짐 방지

# 성공: 한글 유지
import json

data = {
    "name": "김철수"
}

result = json.dumps(
    data,
    ensure_ascii=False
)

print(result)
# {"name": "김철수"}

# 주의: 기본값은 유니코드 변환
import json

data = {
    "name": "김철수"
}

print(json.dumps(data))
# {"name": "\\uae40\\ucca0\\uc218"}

57. deepcopy()

copy.deepcopy()

완전한 깊은 복사

# 성공: 중첩 데이터까지 완전 복사
import copy

data = {
    "scores": [1, 2]
}

copied = copy.deepcopy(data)

copied["scores"][0] = 999

print(data)
# {'scores': [1, 2]}

print(copied)
# {'scores': [999, 2]}

# 주의: copy()는 얕은 복사
data = {
    "scores": [1, 2]
}

copied = data.copy()

copied["scores"][0] = 999

print(data)
# {'scores': [999, 2]}

58. lambda + sorted()

sorted(..., key=lambda ...)

정렬 기준 직접 지정

# 성공: 값 기준 정렬
data = {
    "kim": 70,
    "lee": 90,
    "park": 80
}

result = sorted(
    data.items(),
    key=lambda item: item[1]
)

print(result)
# [('kim', 70), ('park', 80), ('lee', 90)]

# 성공: 문자열 길이 기준 정렬
data = {
    "apple": 5,
    "kiwi": 4
}

result = sorted(
    data.keys(),
    key=lambda key: len(key)
)

print(result)
# ['kiwi', 'apple']

# 주의: lambda는 익명 함수
func = lambda x: x * 2

print(func(3))
# 6

59. 빈도수 세기 실전 패턴

dict + 반복문

데이터 등장 횟수 계산

# 성공: 직접 빈도수 계산
words = [
    "python",
    "java",
    "python"
]

count = {}

for word in words:
    count[word] = count.get(word, 0) + 1

print(count)
# {'python': 2, 'java': 1}

# 주의: 초기값 없이 += 사용 시 에러
count = {}

count["python"] += 1
# KeyError

60. 그룹핑 실전 패턴

setdefault()
defaultdict()

데이터 묶기

# 성공: 그룹별 데이터 저장
users = [
    ("python", "kim"),
    ("python", "lee"),
    ("java", "park")
]

groups = {}

for lang, name in users:
    groups.setdefault(lang, []).append(name)

print(groups)
# {
#   'python': ['kim', 'lee'],
#   'java': ['park']
# }

# 주의: append 전에 리스트가 필요
groups = {}

groups["python"].append("kim")
# KeyError

61. map() + dict

map(함수, 반복가능한값)

값을 한 번에 변환

# 성공: 값 변환
data = {
    "a": "1",
    "b": "2",
    "c": "3"
}

result = {
    key: int(value)
    for key, value in data.items()
}

print(result)
# {'a': 1, 'b': 2, 'c': 3}

# 성공: map 사용 가능
nums = ["1", "2", "3"]

result = list(map(int, nums))

print(result)
# [1, 2, 3]

# 주의: map 결과는 map 객체
nums = ["1", "2"]

result = map(int, nums)

print(result)
# <map object at ...>

62. filter() + dict

filter(함수, 반복가능한값)

조건에 맞는 데이터만 추출

# 성공: 값이 2 이상인 데이터만 추출
data = {
    "a": 1,
    "b": 2,
    "c": 3
}

result = dict(
    filter(
        lambda item: item[1] >= 2,
        data.items()
    )
)

print(result)
# {'b': 2, 'c': 3}

# 주의: filter 결과는 filter 객체
data = [1, 2, 3]

result = filter(
    lambda x: x > 1,
    data
)

print(result)
# <filter object at ...>

63. zip() + 딕셔너리 반복

zip(딕셔너리1.items(), 딕셔너리2.items())

두 딕셔너리 동시에 반복

# 성공: 동시에 반복
a = {
    "x": 1,
    "y": 2
}

b = {
    "x": 10,
    "y": 20
}

for item1, item2 in zip(a.items(), b.items()):
    print(item1, item2)

# ('x', 1) ('x', 10)
# ('y', 2) ('y', 20)

# 주의: 길이가 다르면 짧은 쪽 기준
a = {"x": 1}
b = {"x": 10, "y": 20}

for item in zip(a.items(), b.items()):
    print(item)

# ((‘x’, 1), (‘x’, 10))

64. 딕셔너리 unpacking

**

딕셔너리 펼치기

# 성공: 딕셔너리 합치기
a = {"x": 1}
b = {"y": 2}

result = {
    **a,
    **b
}

print(result)
# {'x': 1, 'y': 2}

# 성공: 함수 인자로 사용 가능
def hello(name, age):
    print(name, age)

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

hello(**user)
# kim 20

# 주의: 같은 키는 뒤쪽 값 사용
a = {"x": 1}
b = {"x": 999}

result = {
    **a,
    **b
}

print(result)
# {'x': 999}

65. 딕셔너리 unpacking 함수

함수(**딕셔너리)

키를 함수 매개변수로 전달

# 성공: 함수 인자 전달
def user_info(name, age):
    print(name, age)

data = {
    "name": "kim",
    "age": 20
}

user_info(**data)
# kim 20

# 주의: 키 이름이 매개변수와 같아야 함
def hello(name):
    print(name)

data = {
    "age": 20
}

hello(**data)
# TypeError

66. 함수에서 kwargs

**kwargs

가변 키워드 인자 받기

# 성공: 여러 키워드 받기
def hello(**kwargs):
    print(kwargs)

hello(name="kim", age=20)
# {'name': 'kim', 'age': 20}

# 성공: 값 접근 가능
def hello(**kwargs):
    print(kwargs["name"])

hello(name="kim")
# kim

# 주의: kwargs는 딕셔너리 형태
def hello(**kwargs):
    print(type(kwargs))

hello(a=1)
# <class 'dict'>

67. 딕셔너리 정렬 실전

sorted(..., reverse=True)

내림차순 정렬

# 성공: 값 기준 내림차순
scores = {
    "kim": 70,
    "lee": 90,
    "park": 80
}

result = sorted(
    scores.items(),
    key=lambda item: item[1],
    reverse=True
)

print(result)
# [('lee', 90), ('park', 80), ('kim', 70)]

# 주의: reverse=True는 전체 정렬 뒤집기
nums = [1, 2, 3]

print(sorted(nums, reverse=True))
# [3, 2, 1]

68. 특정 키만 추출

딕셔너리[키]

원하는 데이터만 꺼내기

# 성공: 특정 키만 추출
user = {
    "name": "kim",
    "age": 20,
    "city": "seoul"
}

result = {
    "name": user["name"],
    "age": user["age"]
}

print(result)
# {'name': 'kim', 'age': 20}

# 주의: 없는 키는 에러 발생
user = {
    "name": "kim"
}

print(user["age"])
# KeyError

69. 여러 딕셔너리 합계 계산

반복문 + sum()

데이터 총합 계산

# 성공: 전체 점수 합산
students = [
    {"score": 90},
    {"score": 80},
    {"score": 70}
]

result = sum(
    student["score"]
    for student in students
)

print(result)
# 240

# 주의: 없는 키 접근 시 에러
students = [
    {"score": 90},
    {}
]

result = sum(
    student["score"]
    for student in students
)
# KeyError

70. 실전 JSON 데이터 처리

json.loads()

API 데이터 처리에 자주 사용

# 성공: JSON 데이터 처리
import json

text = """
{
    "users": [
        {"name": "kim", "age": 20},
        {"name": "lee", "age": 30}
    ]
}
"""

data = json.loads(text)

print(data["users"][0]["name"])
# kim

print(data["users"][1]["age"])
# 30

# 주의: JSON은 문자열 형태
import json

text = '{"name": "kim"}'

print(type(text))
# <class 'str'>

71. 키 존재 여부 안전하게 처리

if 키 in 딕셔너리:

없는 키 에러 방지

# 성공: 안전하게 접근
user = {
    "name": "kim"
}

if "age" in user:
    print(user["age"])
else:
    print("없음")

# 없음

# 주의: 바로 접근하면 에러 가능
user = {
    "name": "kim"
}

print(user["age"])
# KeyError

72. get() 실전 패턴

딕셔너리.get(키, 기본값)

기본값 처리

# 성공: 기본값 사용
user = {
    "name": "kim"
}

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

print(age)
# 0

# 성공: 문자열 기본값
email = user.get("email", "없음")

print(email)
# 없음

# 주의: 없는 키는 None 반환
user = {}

print(user.get("age"))
# None

73. 여러 키 한 번에 확인

all()

필수 데이터 검사

# 성공: 모든 키 존재 확인
user = {
    "name": "kim",
    "age": 20
}

required = ["name", "age"]

result = all(
    key in user
    for key in required
)

print(result)
# True

# 주의: 하나라도 없으면 False
user = {
    "name": "kim"
}

required = ["name", "age"]

print(
    all(key in user for key in required)
)
# False

74. dict comprehension + 조건 변경

if 조건 else 값

조건별 데이터 변환

# 성공: 점수 등급 만들기
scores = {
    "kim": 90,
    "lee": 60,
    "park": 30
}

result = {
    name: "합격" if score >= 60 else "불합격"
    for name, score in scores.items()
}

print(result)
# {
#   'kim': '합격',
#   'lee': '합격',
#   'park': '불합격'
# }

# 주의: if 위치 중요
nums = [1, 2]

result = {
    num: "짝수" if num % 2 == 0 else "홀수"
    for num in nums
}

print(result)
# {1: '홀수', 2: '짝수'}

75. setdefault() 실전 그룹핑

setdefault()

카테고리별 묶기

# 성공: 그룹핑
data = [
    ("backend", "kim"),
    ("backend", "lee"),
    ("frontend", "park")
]

groups = {}

for team, name in data:
    groups.setdefault(team, []).append(name)

print(groups)
# {
#   'backend': ['kim', 'lee'],
#   'frontend': ['park']
# }

# 주의: 리스트 초기화 필요
groups = {}

groups["backend"].append("kim")
# KeyError

76. Counter 실전 단어 개수

Counter()

단어 빈도 계산

# 성공: 단어 개수 세기
from collections import Counter

words = """
python java python spring
"""

result = Counter(words.split())

print(result)
# Counter({
#   'python': 2,
#   'java': 1,
#   'spring': 1
# })

# 주의: split 안 하면 문자 단위 계산
from collections import Counter

text = "hello"

print(Counter(text))
# Counter({
#   'l': 2,
#   'h': 1,
#   'e': 1,
#   'o': 1
# })

77. Counter + most_common 실전

most_common()

가장 많이 나온 데이터 찾기

# 성공: 인기 데이터 찾기
from collections import Counter

data = [
    "python",
    "java",
    "python",
    "python",
    "spring"
]

counter = Counter(data)

print(counter.most_common(1))
# [('python', 3)]

print(counter.most_common(2))
# [('python', 3), ('java', 1)]

# 주의: 결과는 리스트
from collections import Counter

data = Counter(["a"])

result = data.most_common()

print(type(result))
# <class 'list'>

78. nested get()

get().get()

중첩 딕셔너리 안전 접근

# 성공: 안전하게 접근
user = {
    "contact": {
        "email": "test@test.com"
    }
}

email = user.get(
    "contact",
    {}
).get("email")

print(email)
# test@test.com

# 주의: 없는 키 직접 접근 시 에러
user = {}

print(user["contact"]["email"])
# KeyError

79. dictionary merge 실전

**
|
update()

딕셔너리 병합 방식

# 성공: unpacking 병합
a = {"x": 1}
b = {"y": 2}

result = {
    **a,
    **b
}

print(result)
# {'x': 1, 'y': 2}

# 성공: | 병합
result = a | b

print(result)
# {'x': 1, 'y': 2}

# 주의: update는 원본 변경
a = {"x": 1}
b = {"y": 2}

a.update(b)

print(a)
# {'x': 1, 'y': 2}

80. API 응답 처리 실전

json.loads()

실무 JSON 처리 패턴

# 성공: API 응답 처리
import json

response = """
{
    "status": "success",
    "data": {
        "users": [
            {
                "name": "kim",
                "age": 20
            }
        ]
    }
}
"""

result = json.loads(response)

users = result["data"]["users"]

print(users[0]["name"])
# kim

print(users[0]["age"])
# 20

# 주의: 문자열 상태에서는 접근 불가
response = '{"name": "kim"}'

print(response["name"])
# TypeError

'🐍Python' 카테고리의 다른 글

Python Basic: set (0)	2026.05.28
Python Basic: tuple (0)	2026.05.28
Python Basic: list (0)	2026.05.28
Python Basic: String (0)	2026.05.28