B-2: 딕셔너리와 집합 — 이름표로 찾고, 중복 없이 모으기

안녕하세요! 여러분의 파이썬 가이드, 홍순구 튜터입니다.

지난 시간엔 여러 값을 리스트([])라는 한 그릇에 담고, 번호([0], [1])로 꺼냈죠. 마지막에 제가 이런 질문을 던졌어요. "재훈이의 팔로워 수가 리스트의 몇 번 자리인지, 번호로 기억하는 게 편할까요?" 게시물이 100개라면 87번 자리에 뭐가 있는지 번호로 외우는 건 너무 힘들어요.

오늘은 번호 대신 이름표(key) 로 찾는 그릇, 딕셔너리(dictionary) 를 배웁니다. 프로필["팔로워수"] 처럼, 사전(dictionary)에서 단어로 뜻을 찾듯이 이름으로 값을 꺼내요. 그리고 "중복 없는 모음" 인 집합(set) 으로, 두 사람의 팔로우 관계에서 맞팔(교집합) 을 한 줄에 골라내는 것도 해봅니다.

오늘 우리는 이런 길을 따라갑니다.

 오늘의 여정 — B-2 (총 8 단계)

  1. 딕셔너리 만들기      이름표로 찾기
  2. 더하고 고치고 빼기   값을 수정·추가·삭제
  3. get 과 in            없는 이름표를 불러도 안전하게
  4. 통째로 훑기          keys · values · items
  5. 그릇 조합하기        딕셔너리 여러 개를 리스트에
  6. 집합 만들기          중복 없는 모음
  7. 집합 연산            맞팔은 교집합 (& | -)
  8. 종합: 프로필 관리    딕셔너리 + 맞팔 한데 모아

앞쪽(1~5)은 딕셔너리, 뒤쪽(6~8)은 집합과 종합이에요. 한꺼번에 외우려 하지 말고, 직접 실행해 보면서 하나씩 익혀가요.

💡 오늘 수업의 핵심 — "이름표(key)로 값을 찾는 딕셔너리({})와, 중복 없이 모아 교집합·합집합을 구하는 집합(set)"

🎯 학습 목표

• 딕셔너리로 이름표(key)와 값(value)을 짝지어 담고, 이름표로 값을 꺼낼 수 있다
• get/in 으로 안전하게 접근하고, keys/values/items 로 전체를 훑을 수 있다
• 집합(set)으로 중복을 없애고, 교집합·합집합·차집합으로 두 모임을 비교할 수 있다
• 딕셔너리와 리스트를 조합해 회원 명부 같은 데이터를 다룰 수 있다

Step 1: "이름표로 찾기 — 딕셔너리 만들기"

지난 시간 리스트는 값을 번호 로 찾았어요. profile_list[1] 처럼요. 그런데 [1] 이 팔로워 수인지 게시물 수인지, 번호만 봐선 알 수 없죠. "재훈이의 팔로워 수" 처럼 이름으로 찾을 수 있다면 훨씬 편할 거예요.

이럴 때 쓰는 게 딕셔너리(dictionary) 예요. 우리말로 "사전" 이죠. 사전에서 단어(이름표)로 뜻(값)을 찾듯이, 딕셔너리는 이름표(key) 로 값(value) 을 찾습니다. 중괄호 {} 안에 "이름표": 값 짝을 쉼표로 늘어놓으면 돼요.

코드부터 실행해 봅시다.

# src/b_structures/b2_create.py
# 딕셔너리: 번호 대신 '이름표(key)' 로 값을 찾는 그릇

# 지난 시간 리스트는 번호(0, 1, 2)로 찾았다
profile_list = ["jaehoon", 8500, 42]
print(profile_list[1])          # 8500 — 근데 1번이 뭐였더라?

# 딕셔너리는 '이름표' 로 찾는다 — 사전에서 단어로 뜻 찾듯이
profile = {
    "name": "jaehoon",
    "followers": 8500,
    "posts": 42,
}
print(profile)
print(type(profile))            # <class 'dict'>

# 이름표(key)로 값(value) 꺼내기
print(profile["name"])          # jaehoon
print(profile["followers"])     # 8500

▶ 버튼으로 실행하거나 터미널에서 uv run python src/b_structures/b2_create.py 를 입력하면 이렇게 나와요.

8500
{'name': 'jaehoon', 'followers': 8500, 'posts': 42}
<class 'dict'>
jaehoon
8500

리스트로 담았던 profile_list[1] 은 8500을 주긴 하는데, "1번이 팔로워였나?" 하고 매번 헷갈려요. 딕셔너리 profile 은 profile["followers"] 라고 이름으로 부르니 한눈에 또렷하죠. type(profile) 을 찍으면 <class 'dict'>, "이건 딕셔너리예요" 라고 알려줍니다.

번호로 찾기와 이름표로 찾기를 나란히 보면 차이가 분명해요.

 리스트는 번호로 찾는다
   ["jaehoon", 8500, 42]
       0        1     2
   profile_list[1]  →  8500     (근데 1번이 뭐였지?)

 딕셔너리는 이름표로 찾는다
   {"name": "jaehoon", "followers": 8500, "posts": 42}
   profile["followers"]  →  8500     (이름표라 한눈에!)

이어서 파일의 나머지도 볼게요.

# 빈 딕셔너리로 시작할 수도 있다
empty = {}
print(empty)                    # {}
print(type(empty))              # <class 'dict'>

# 몇 쌍이 들어있나?
print(len(profile))             # 3

리스트처럼 빈 딕셔너리 {} 로 시작해 나중에 채울 수도 있어요. len(profile) 은 "이름표가 몇 쌍 들어있나" 를 알려줘요. 여기선 name, followers, posts 세 쌍이라 3이고요.

💡 한 줄 정리

딕셔너리는 중괄호 {} 안에 "이름표": 값 짝을 담는 그릇이에요. 리스트가 번호([0])로 찾았다면, 딕셔너리는 이름표(["followers"])로 찾아요. 사전에서 단어로 뜻을 찾는 것과 똑같죠.

Step 2: "값을 더하고 고치고 빼기"

지난 시간 리스트는 "가변(바뀌는 그릇)" 이라 자리를 고칠 수 있었죠. 딕셔너리도 마찬가지예요. 팔로워 수는 매일 바뀌고, 소개글은 새로 추가되니까요. 이름표를 이용해 값을 수정하고, 새 이름표를 추가하고, 필요 없는 건 빼봅시다.

# src/b_structures/b2_modify.py
# 딕셔너리는 가변 — 값을 더하고 고치고 뺄 수 있다

profile = {
    "name": "jaehoon",
    "followers": 8500,
    "posts": 42,
}

# 1) 값 수정 — 이름표에 새 값 대입
profile["followers"] = 9000
print(profile["followers"])     # 9000

# 2) 새 이름표 추가 — 없던 key 에 대입하면 새로 생긴다
profile["bio"] = "여행과 사진"
print(profile)                  # bio 가 추가됨

# 3) 삭제 — del
del profile["posts"]
print(profile)                  # posts 가 사라짐

# 4) pop — 빼면서 그 값을 돌려받는다
removed = profile.pop("bio")
print(removed)                  # 여행과 사진
print(profile)                  # bio 가 사라짐

# 몇 쌍 남았나?
print(len(profile))             # 2

실행하면 이렇게 나와요.

9000
{'name': 'jaehoon', 'followers': 9000, 'posts': 42}
{'name': 'jaehoon', 'followers': 9000, 'bio': '여행과 사진'}
여행과 사진
{'name': 'jaehoon', 'followers': 9000}
2

여기서 재미있는 점이 있어요. 수정과 추가가 똑같이 생겼다 는 거예요. profile["followers"] = 9000 은 이미 있는 이름표라 값을 갈아끼우고, profile["bio"] = "여행과 사진" 은 없던 이름표라 새로 만들어요. 파이썬이 "이름표가 있으면 고치고, 없으면 새로 추가" 를 알아서 판단해주는 거죠.

빼는 방법은 두 가지예요. del profile["posts"] 는 그냥 지우기만 해요. profile.pop("bio") 는 지난 시간 리스트의 pop 처럼 빼면서 그 값을 돌려줘요. removed = profile.pop("bio") 로 꺼낸 값을 받아 쓸 수 있죠.

💡 한 줄 정리

딕셔너리는 가변이에요. profile["키"] = 값 한 줄로, 있는 이름표면 수정하고 없는 이름표면 추가해요. 뺄 땐 del(지우기만) 또는 pop(빼면서 값을 돌려받기)을 써요.

Step 3: "없는 이름표를 부르면? — get 과 in"

딕셔너리를 쓰다 보면 이런 상황이 생겨요. "이 프로필에 소개글(bio)이 있던가? 없으면 어떻게 되지?" 없는 이름표를 [] 로 부르면 어떤 일이 벌어지는지, 일부러 한번 마주쳐 봅시다. 에러는 친구니까요.

# src/b_structures/b2_keyerror.py
# 없는 이름표를 부르면? — 에러가 난다 (에러는 친구!)

profile = {"name": "jaehoon", "followers": 8500}
print(profile["age"])   # 'age' 라는 이름표는 없다 → KeyError

uv run python src/b_structures/b2_keyerror.py 로 실행하면 프로그램이 멈추면서 이런 메시지가 나와요.

Traceback (most recent call last):
  File ".../b2_keyerror.py", line 5, in <module>
    print(profile["age"])   # 'age' 라는 이름표는 없다 → KeyError
          ~~~~~~~^^^^^^^
KeyError: 'age'

맨 아랫줄 KeyError: 'age' 가 핵심이에요. "age 라는 이름표(key)는 없는데요?" 라는 뜻이죠. 파이썬 3.14는 친절하게 ~~~~~~~^^^^^^^ 로 어디가 문제인지 화살표까지 짚어줘요. 없는 이름표를 [] 로 부르면 이렇게 프로그램이 멈춰버려요.

이 멈춤을 피하려면 get 을 쓰면 돼요.

# src/b_structures/b2_get.py
# get() — 없는 이름표를 불러도 에러 대신 안전하게

profile = {"name": "jaehoon", "followers": 8500}

# get 은 없는 key 면 None 을 돌려준다 (에러 안 남)
print(profile.get("name"))      # jaehoon
print(profile.get("age"))       # None

# 기본값을 정해줄 수도 있다 — 없으면 이걸 대신 돌려준다
print(profile.get("age", 0))            # 0
print(profile.get("bio", "소개 없음"))    # 소개 없음

# in — 이름표가 있는지 먼저 확인 (지난 시간 리스트의 in 과 같은 결)
print("name" in profile)        # True
print("age" in profile)         # False

# if 와 함께 — 있을 때만 꺼내기
if "followers" in profile:
    print(f"팔로워: {profile['followers']}명")

실행 결과예요.

jaehoon
None
0
소개 없음
True
False
팔로워: 8500명

get 은 없는 이름표를 불러도 멈추지 않고 None(값이 없음)을 돌려줘요. profile.get("age", 0) 처럼 기본값을 정해주면, 없을 때 대신 그 값을 줘요. "소개글 없으면 '소개 없음' 으로" 같은 처리가 한 줄로 끝나죠.

in 은 지난 시간 리스트에서 "이 값이 목록에 있나?" 확인할 때 썼던 그 in 이에요. 딕셔너리에 쓰면 이름표가 있는지 를 확인해줘요. if "followers" in profile: 로 "있으면 꺼내기" 를 안전하게 할 수 있고요.

💡 한 줄 정리

없는 이름표를 [] 로 부르면 KeyError 로 멈춰요. get("키", 기본값) 은 없어도 멈추지 않고 기본값을 돌려주고, in 은 이름표가 있는지 먼저 확인해줘요.

Step 4: "통째로 훑기 — keys · values · items"

지금까지는 이름표 하나를 콕 집어 값을 꺼냈어요. 그런데 "이 프로필의 모든 정보를 한 줄씩 출력해줘" 같은 일도 자주 필요하죠. 딕셔너리에는 전체를 훑게 해주는 세 가지 메서드가 있어요. keys, values, items 예요.

# src/b_structures/b2_iterate.py
# 딕셔너리 통째로 훑기 — keys / values / items

profile = {
    "name": "jaehoon",
    "followers": 8500,
    "posts": 42,
}

# keys() — 이름표만 모아서
print(profile.keys())       # dict_keys(['name', 'followers', 'posts'])

# values() — 값만 모아서
print(profile.values())     # dict_values(['jaehoon', 8500, 42])

# items() — (이름표, 값) 짝으로
print(profile.items())

실행하면 이렇게 나와요.

dict_keys(['name', 'followers', 'posts'])
dict_values(['jaehoon', 8500, 42])
dict_items([('name', 'jaehoon'), ('followers', 8500), ('posts', 42)])

세 메서드가 무엇을 주는지 그림으로 보면 또렷해요.

 profile = {"name": "jaehoon", "followers": 8500, "posts": 42}

   .keys()    →  name, followers, posts            (이름표만)
   .values()  →  jaehoon, 8500, 42                 (값만)
   .items()   →  ("name", "jaehoon"), ...          (이름표·값 짝으로)

keys() 는 이름표만, values() 는 값만, items() 는 (이름표, 값) 짝으로 모아줘요. items() 가 주는 짝, 어디서 본 모양 같지 않나요? 지난 시간 배운 튜플 이에요. ("name", "jaehoon") 처럼요.

이제 이걸 for 로 돌려봅시다.

# 그냥 for 는 이름표(key)를 돈다
for key in profile:
    print(key)              # name / followers / posts

# items() + 튜플 언패킹 — 이름표와 값을 한 번에
# (지난 시간 lat, lng = ... 처럼 짝을 한 번에 푼다)
for key, value in profile.items():
    print(f"{key}: {value}")

실행 결과예요.

name
followers
posts
name: jaehoon
followers: 8500
posts: 42

딕셔너리를 그냥 for 로 돌면 이름표(key) 를 하나씩 줘요. 값까지 같이 쓰고 싶으면 for key, value in profile.items(): 가 제격이에요. items() 가 주는 튜플 짝을, 지난 시간 배운 언패킹(lat, lng = location)으로 key 와 value 에 한 번에 풀어 담는 거죠. 지난 시간 도구가 여기서 다시 빛나네요.

💡 한 줄 정리

keys()(이름표만)·values()(값만)·items()(짝으로)로 딕셔너리 전체를 훑어요. for key, value in profile.items(): 는 items() 의 튜플 짝을 언패킹으로 풀어, 이름표와 값을 한 번에 다뤄요.

Step 5: "그릇을 조합하기 — 딕셔너리 여러 개"

지금까지는 프로필 한 명 을 딕셔너리로 다뤘어요. 그런데 인스타그램엔 회원이 한둘이 아니죠. 여러 명을 어떻게 담을까요? 정답은 지난 시간 배운 그릇과의 조합 이에요. 딕셔너리(한 명)를 리스트에 여러 개 담는 거죠.

지난 시간 리스트 안에 리스트를 담는 "중첩 리스트"(feed[i][j])를 배웠죠? 그 확장판이에요.

# src/b_structures/b2_combine.py
# 그릇을 조합 — 딕셔너리(프로필) 여러 개를 리스트에 담는다

# 프로필 한 명 = 딕셔너리, 여러 명 = 딕셔너리들의 리스트
members = [
    {"name": "jaehoon", "followers": 8500},
    {"name": "minji", "followers": 12000},
    {"name": "seungwoo", "followers": 320},
]

# 리스트 번호로 한 명 고르고, 그 안에서 이름표로 꺼내기
print(members[0]["name"])       # jaehoon
print(members[1]["followers"])  # 12000

실행하면 이렇게 나와요.

jaehoon
12000

members 는 리스트인데, 칸마다 딕셔너리(프로필 한 명)가 들어있어요. 그래서 값을 꺼낼 때 두 단계 를 거쳐요. members[0] 으로 첫 번째 사람을 고르고, 거기에 ["name"] 을 붙여 이름을 꺼내는 거죠. "리스트 번호로 한 명 고르고 → 딕셔너리 이름표로 정보 꺼내기" — 두 그릇이 만나는 자리예요.

이제 전체를 for 로 훑어봅시다.

# 전체 훑기 — for 로 한 명씩, 안에서 이름표로 꺼내기
for member in members:
    name = member["name"]
    followers = member["followers"]
    print(f"{name}: 팔로워 {followers}명")

# 팔로워 1000명 넘는 사람만 세기
popular = 0
for member in members:
    if member["followers"] >= 1000:
        popular = popular + 1
print(f"인기 회원: {popular}명")

실행 결과예요.

jaehoon: 팔로워 8500명
minji: 팔로워 12000명
seungwoo: 팔로워 320명
인기 회원: 2명

for member in members: 는 회원을 한 명씩(딕셔너리 하나씩) 꺼내줘요. 그 안에서 member["name"], member["followers"] 로 정보를 꺼내 쓰는 거죠. 지난 시간 배운 for + if 로 "팔로워 1000명 넘는 사람" 을 세는 것도, 데이터가 딕셔너리로 바뀌었을 뿐 흐름은 똑같아요.

💡 한 줄 정리

딕셔너리(한 명)를 리스트에 여러 개 담으면 회원 명부가 돼요. members[0]["name"] 처럼 "리스트 번호 → 딕셔너리 이름표" 두 단계로 꺼내고, for 로 한 명씩 훑어요.

Step 6: "중복 없는 모음 — 집합(set)"

이제 딕셔너리를 잠시 내려놓고, 또 다른 그릇을 만나봅시다. 이런 상황을 떠올려 보세요. 한 게시물에 좋아요를 누른 사람 목록이 있는데, 같은 사람이 실수로 두 번 눌렀어요. "진짜로 좋아요 누른 사람은 몇 명?" 을 세려면 중복을 빼야겠죠.

이럴 때 쓰는 게 집합(set) 이에요. 집합은 중복을 자동으로 없애는 그릇이에요.

# src/b_structures/b2_set_create.py
# 집합(set): 중복 없는 모음 — 순서도 없다

# 좋아요 누른 사람 목록에 중복이 있다면?
likers = ["minji", "jaehoon", "minji", "seungwoo", "jaehoon"]
print(len(likers))              # 5 — 중복 포함

# set 으로 만들면 중복이 사라진다
unique_likers = set(likers)
print(unique_likers)            # 중복 없는 모음 (순서는 보장 안 됨)
print(len(unique_likers))       # 3 — minji, jaehoon, seungwoo

# 다시 리스트로 — 중복 제거된 리스트
unique_list = list(set(likers))
print(len(unique_list))         # 3

실행하면 이렇게 나와요.

5
{'minji', 'jaehoon', 'seungwoo'}
3
3

likers 리스트엔 minji와 jaehoon이 두 번씩 들어 5개였죠. set(likers) 로 집합으로 만드는 순간, 중복이 사라져 3명만 남아요. "진짜 좋아요 누른 사람 수" 는 len(set(likers)) 한 줄로 끝나는 거죠.

⚠️ 한 가지 주의할 점이 있어요. 집합은 순서가 없어요. 위 출력에서 {'minji', 'jaehoon', 'seungwoo'} 순으로 나왔지만, 실행할 때마다 순서가 달라질 수 있어요. 집합은 "누가 들어있나" 와 "중복 제거" 가 목적이지, "몇 번째" 를 따지는 그릇이 아니거든요. 순서가 중요하면 지난 시간의 리스트를 쓰면 돼요.

집합을 직접 만들 수도 있어요. 여기서 한 가지 함정을 짚고 갈게요.

# 집합 직접 만들기 — 중괄호 {}
tags = {"여행", "맛집", "여행", "일상"}
print(len(tags))                # 3 — '여행' 은 한 번만 (중복 자동 제거)

# 주의! 빈 중괄호 {} 는 딕셔너리다. 빈 집합은 set()
empty_set = set()
print(type(empty_set))          # <class 'set'>
print(type({}))                 # <class 'dict'>

실행 결과예요.

3
<class 'set'>
<class 'dict'>

{"여행", "맛집", "여행", "일상"} 처럼 중괄호로 직접 만들면, "여행" 이 두 번 적혀 있어도 알아서 한 번만 남겨요. 그런데 여기서 헷갈리기 쉬운 함정! 빈 중괄호 {} 는 집합이 아니라 딕셔너리예요. 빈 집합을 만들려면 꼭 set() 이라고 써야 해요. type({}) 이 <class 'dict'> 로 나오는 걸 보면 알 수 있죠.

💡 한 줄 정리

집합(set)은 중복을 자동으로 없애는 그릇이에요. set(리스트) 로 중복을 제거하고, {} 로 직접 만들 수도 있어요. 단 순서가 없고, 빈 집합은 {} 가 아니라 set() 으로 만들어야 해요.

Step 7: "맞팔은 교집합 — 집합 연산"

집합이 진짜 빛나는 순간이 왔어요. 바로 두 모임을 비교 할 때예요. 중학교 수학 시간에 배운 교집합·합집합·차집합, 기억나세요? 파이썬 집합으로 그걸 그대로 해요. 인스타그램으로 비유하면 이래요. "내가 팔로우하는 사람" 과 "나를 팔로우하는 사람", 두 모임을 비교하면 맞팔 을 찾을 수 있죠.

# src/b_structures/b2_set_ops.py
# 집합 연산 — 맞팔은 교집합!

# 내가 팔로우하는 사람들
i_follow = {"minji", "seungwoo", "yuna", "dohyun"}
# 나를 팔로우하는 사람들
follows_me = {"minji", "yuna", "jisoo"}

# 교집합 & — 내가 팔로우 + 그쪽도 나를 팔로우 = 맞팔!
mutual = i_follow & follows_me
print(mutual)                   # minji, yuna (순서는 보장 안 됨)

# 합집합 | — 둘 중 하나라도 (나와 연결된 모든 사람, 중복 없이)
connected = i_follow | follows_me
print(len(connected))           # 5

# 차집합 - — 나는 팔로우하는데 그쪽은 날 안 함 (외사랑)
one_way = i_follow - follows_me
print(one_way)                  # seungwoo, dohyun (순서는 보장 안 됨)

# 부분집합 <= — 이 모임이 저 모임에 통째로 들어가나?
besties = {"minji", "yuna"}
print(besties <= i_follow)      # True (둘 다 i_follow 안에 있음)

실행하면 이렇게 나와요. (집합이라 순서는 그때그때 다를 수 있어요.)

{'yuna', 'minji'}
5
{'seungwoo', 'dohyun'}
True

세 연산을 그림으로 정리하면 이래요.

  i_follow   = { minji, seungwoo, yuna, dohyun }   내가 팔로우
  follows_me = { minji, yuna, jisoo }              나를 팔로우

  &  (교집합) → { minji, yuna }        양쪽 모두 = 맞팔!
  |  (합집합) → 다섯 명 (중복 없이)      둘 중 하나라도 = 연결된 사람
  -  (차집합) → { seungwoo, dohyun }    왼쪽에만 = 나만 팔로우(외사랑)

i_follow & follows_me 는 교집합, 양쪽에 다 있는 사람이에요. 내가 팔로우하고 그쪽도 나를 팔로우하니, 이게 바로 맞팔 이죠! 지난 시간 마지막에 예고했던 그 맞팔을, 단 한 줄(&)로 골라낸 거예요. i_follow | follows_me 는 합집합, 둘 중 하나라도 속한 모든 사람을 중복 없이 모아요. i_follow - follows_me 는 차집합, 나는 팔로우하는데 그쪽은 날 안 하는 사람(살짝 서운한 외사랑)이고요. besties <= i_follow 는 "besties가 i_follow 안에 통째로 들어가나?" 를 묻는 부분집합 검사예요.

💡 한 줄 정리

집합 연산으로 두 모임을 한 줄에 비교해요. 교집합 &(양쪽 모두 = 맞팔), 합집합 |(둘 중 하나라도), 차집합 -(왼쪽에만). 인스타그램 맞팔이 i_follow & follows_me 한 줄로 끝나죠.

Step 8: "종합 — 프로필 관리 + 맞팔 찾기"

오늘 배운 걸 한데 모아봅시다. 딕셔너리로 회원 정보를 관리하고, 집합으로 맞팔을 찾는, 작은 회원 관리 프로그램이에요. 여기엔 오늘 배운 거의 모든 게 들어있어요. 천천히 한 줄씩 읽어봐요.

# src/b_structures/b2_manager.py
# 종합 실습 — 프로필 관리 + 맞팔 찾기

# 회원 프로필 — 이름표(key)로 정보를 담는다 (값이 또 딕셔너리!)
profiles = {
    "jaehoon": {"followers": 8500, "posts": 42},
    "minji": {"followers": 12000, "posts": 88},
}

# 1) 새 회원 추가
profiles["seungwoo"] = {"followers": 320, "posts": 5}
print(f"회원 수: {len(profiles)}명")

# 2) 한 명씩 정보 출력 (items + 튜플 언패킹)
for name, info in profiles.items():
    print(f"{name}: 팔로워 {info['followers']}명, 게시물 {info['posts']}개")

# 3) 팔로워 5000명 넘는 인플루언서 세기
influencers = 0
for name, info in profiles.items():
    if info["followers"] >= 5000:
        influencers = influencers + 1
print(f"인플루언서: {influencers}명")

# 4) 맞팔 찾기 — 내가 팔로우 ∩ 나를 팔로우 (교집합)
i_follow = {"minji", "seungwoo", "yuna"}
follows_me = {"minji", "yuna", "jisoo"}
mutual = i_follow & follows_me
print(f"맞팔: {len(mutual)}명")

실행하면 이렇게 나와요.

회원 수: 3명
jaehoon: 팔로워 8500명, 게시물 42개
minji: 팔로워 12000명, 게시물 88개
seungwoo: 팔로워 320명, 게시물 5개
인플루언서: 2명
맞팔: 2명

이 프로그램엔 오늘 배운 게 골고루 담겼어요. profiles 는 딕셔너리 안에 딕셔너리 예요. 이름표 "jaehoon" 의 값이 또 {"followers": ..., "posts": ...} 딕셔너리죠. profiles["seungwoo"] = {...} 으로 새 회원을 추가하고, for name, info in profiles.items(): 로 한 명씩 훑어요. info["followers"] 로 안쪽 딕셔너리의 값을 꺼내 인플루언서를 세고, 마지막엔 집합 & 로 맞팔을 한 줄에 찾았어요. 딕셔너리(이름표로 찾기)와 집합(중복 없이 비교하기)이 한 프로그램에서 손발을 맞추는 모습이에요.

💡 한 줄 정리

딕셔너리로 회원 정보를 담고(값이 또 딕셔너리일 수도 있고), items() 로 훑고, 집합 & 로 맞팔을 찾았어요. 오늘 배운 두 그릇이 한 프로그램에서 어우러지는 걸 봤죠.

마무리

오늘은 번호 대신 이름표 로 찾는 딕셔너리와, 중복 없이 모으는 집합을 배웠어요. 리스트와 함께 이 둘은 파이썬에서 데이터를 다루는 가장 기본이 되는 그릇이에요. 정말 고생 많으셨어요.

오늘 배운 핵심 세 가지

💡 하나: 딕셔너리({})는 이름표(key)로 값을 찾는 그릇이에요. 프로필["followers"] 로 꺼내고, get/in 으로 안전하게 접근하고, keys/values/items 로 전체를 훑었어요. 리스트가 번호로 찾았다면, 딕셔너리는 이름으로 찾죠.

💡 둘: 집합(set)은 중복을 자동으로 없애는 그릇이에요. 순서는 없지만, 중복 제거(set(리스트))와 빠른 포함 확인을 잘해요. 교집합 &·합집합 |·차집합 - 로 두 모임을 한 줄에 비교했고요.

💡 셋: 맞팔은 교집합 한 줄(i_follow & follows_me)이에요. 그리고 딕셔너리와 리스트를 조합하면(리스트 안에 딕셔너리, 딕셔너리 안에 딕셔너리) 회원 명부 같은 진짜 데이터를 다룰 수 있어요.

다음 시간 예고

다음 시간엔 "컴프리헨션(comprehension)" 을 배웁니다. 오늘 우리는 for 로 또박또박 리스트와 딕셔너리를 만들고 걸렀죠. 그걸 한 줄로 빚어내는 도구가 컴프리헨션이에요. [글자 for 글자 in 단어] 같은 모양으로요. "좋아요 1000 넘는 게시물만 골라내기", "해시태그만 뽑아내기" 같은 걸 단 한 줄로 끝내게 됩니다. 또 두 리스트를 번호와 함께 도는 enumerate, 짝지어 도는 zip 도 만나요. 오늘의 for 가 한층 날렵해지는 시간이 될 거예요. 기대해 주세요!

과제

오늘 배운 딕셔너리와 집합을 직접 손으로 익혀봅시다. 눈으로 본 것과 직접 짜보는 것은 완전히 다르답니다.

[기초] 내 프로필 딕셔너리 만들기

나만의 프로필을 딕셔너리로 만들어 다뤄 보세요.

• name, followers, posts 세 가지 이름표로 프로필 딕셔너리를 만듭니다
• 프로필["name"] 으로 이름을 꺼내 출력하고, len() 으로 이름표가 몇 쌍인지 셉니다
• 프로필["followers"] = ... 로 팔로워 수를 수정하고, 프로필["bio"] = ... 로 소개글을 새로 추가합니다
• get("bio", "소개 없음") 으로 소개글을, get("age", 0) 으로 (없는) 나이를 안전하게 꺼내 출력해 보세요

[응용] 회원 명부 훑기

여러 회원을 리스트에 담아 한 번에 다뤄 보세요.

• 회원 세 명 정도를, 각자 {"name": ..., "followers": ...} 딕셔너리로 만들어 리스트에 담습니다
• for 로 한 명씩 돌며 "이름: 팔로워 N명" 형태로 출력합니다
• 팔로워가 가장 많은 사람을 찾아 출력해 봅니다 (지난 시간 배운 "가장 큰 값 찾기" 흐름을 떠올려 보세요)
• for 와 if 로 팔로워 1000명 넘는 인기 회원이 몇 명인지 세어 함께 출력해 보세요

[심화] 맞팔과 추천 친구 찾기

집합 연산으로 인스타그램의 관계를 분석해 보세요. (오늘 Step 7을 직접 응용하는 과제예요.)

• "내가 팔로우하는 사람" 과 "나를 팔로우하는 사람" 을 각각 집합으로 만듭니다
• 교집합 & 으로 맞팔 인 사람을, 차집합 - 으로 나만 팔로우하는 사람을 찾아 출력합니다
• (도전) 친구가 팔로우하는 사람 중 내가 아직 팔로우 안 하는 사람을 차집합으로 골라 "추천 친구" 로 출력해 보세요
• 좋아요 누른 사람 목록에 중복이 있을 때, set 으로 "진짜 좋아요 누른 사람 수" 를 세어 보세요

생각해볼 주제

정답이 하나로 정해진 질문이 아니에요. 혼자 곰곰이 생각해 보거나, 함께 공부하는 동료와 이야기 나눠 보면 좋습니다.

1. 리스트로도 되는데, 왜 딕셔너리를 따로 둘까?

회원 정보를 ["jaehoon", 8500, 42] 리스트로 담을 수도 있고, {"name": "jaehoon", "followers": 8500, "posts": 42} 딕셔너리로 담을 수도 있어요. 리스트는 [1] 처럼 번호로, 딕셔너리는 ["followers"] 처럼 이름표로 찾죠. 정보가 많아지고 코드가 길어질수록, 둘 중 어느 쪽이 "나중에 읽기" 좋을지 생각해 보세요. 반대로, 번호로 찾는 리스트가 더 어울리는 경우는 어떤 때일까요?

2. 순서를 포기한 대신 집합이 얻은 것

집합은 순서가 없어요. 처음엔 "순서도 못 지키는 그릇을 왜 써?" 싶을 수 있어요. 그런데 집합은 그 순서를 포기한 대가로 "중복 제거" 와 "빠른 포함 확인" 을 얻었어요. 어떤 데이터가 "순서는 중요하지 않지만 중복은 없어야 하는" 경우일까요? (좋아요 누른 사람, 방문한 페이지 목록 같은 걸 떠올려 보세요.) 무언가를 포기하고 다른 걸 얻는 이런 맞바꿈이, 도구를 고르는 안목의 시작이에요.

3. for 로 짠 걸 한 줄로 줄이면, 항상 좋을까?

다음 시간엔 오늘 for 로 또박또박 짠 걸 한 줄로 줄이는 컴프리헨션을 배워요. 코드가 짧아지면 보통 좋다고들 하죠. 그런데 한 줄로 너무 많은 걸 욱여넣으면, 오히려 읽기 어려워지는 순간도 있어요. "짧은 코드" 와 "읽기 쉬운 코드" 가 항상 같은 말일까요? 어떤 때 한 줄이 좋고, 어떤 때 여러 줄이 나을지 미리 상상해 보세요.