연습15(파이썬 메서드 삭제관련)

🧠 목표: .discard(), .remove(), .pop(), .clear(), .update(), .difference() 등

---

🔍 문제 1: .pop() 트랩 — 집합에서 pop은 어떤 요소를 제거할까?

s = {3, 1, 5}
x = s.pop()
print(x)
print(s)

예상 결과는?

1. 항상 1이 제거됨
2. 항상 5가 제거됨
3. 무작위 요소가 제거됨
4. 에러 발생

---

✅ 정답: 3번 – 무작위 요소 제거

---

🔍 해설:

• set은 순서가 없는 자료형
• 그래서 .pop()은 리스트처럼 "맨 앞"이 아닌, 임의의 요소 하나를 제거함

s = {1, 3, 5}
→ s.pop()  → 예: 1 제거될 수도, 3 제거될 수도 있음

📌 실전에서는 어떤 값이 pop될지 예측 못함

---

🔍 문제 2: .clear() 트랩

s = {10, 20, 30}
s.clear()
print(s)

예상 출력:

1. []
2. {}
3. set()
4. None

---

✅ 정답: 3번 – set()

---

🔍 해설:

• .clear()는 집합을 완전히 비움
• 결과는 빈 집합
• Python에서 빈 집합은 set() (주의: {}는 빈 dict야!)

type(set())  → <class 'set'>
type({})     → <class 'dict'>

---

🔍 문제 3: .update() vs .add() 차이

a = {1, 2}
a.update([3, 4])
print(a)

출력 결과는?

1. {1, 2, [3, 4]}
2. {1, 2, 3, 4}
3. [[1, 2, 3, 4]]
4. {1, 2, (3, 4)}

---

✅ 정답: 2번 – {1, 2, 3, 4}

---

🔍 해설:

• .update()는 **반복 가능한 것(iterable)**의 모든 요소를 집합에 개별 요소로 추가
• .add()는 그냥 하나만 통째로 넣는 것

a.update([3, 4])   → a = {1, 2, 3, 4}
a.add([3, 4])      → ❌ TypeError: unhashable type: 'list'

⚠️ 리스트 자체는 set에 넣을 수 없음 (mutable → unhashable)

---

🔍 문제 4: .difference()와 - 연산자 비교

a = {1, 2, 3}
b = {2, 3, 4}
print(a.difference(b))
print(a - b)

결과는?

1. {1}, {1}
2. {4}, {4}
3. {1, 4}, {1, 4}
4. 에러 발생

---

✅ 정답: 1번 – {1}, {1}

---

🔍 해설:

• a.difference(b) == a - b
• b에 있는 요소는 a에서 제거됨
• 즉, a = {1, 2, 3} → b = {2, 3, 4} → a - b = {1}

---

🧠 요약: set 주요 메서드 정리

메서드	기능 요약	위험/트랩 포인트
add(x)	x 하나 추가	리스트/딕셔너리 등 mutable은 추가 불가
update(iter)	반복 가능한 값 여러 개 추가	문자열 넣으면 한 글자씩 추가됨
remove(x)	x 제거 (없으면 ❌KeyError)	❗ x 없으면 에러
discard(x)	x 제거 (없으면 무시)	안전하게 제거 가능
pop()	임의 요소 제거 후 반환	어떤 요소일지 예측 불가 (set은 순서 없음)
clear()	모든 요소 제거	결과는 set()
difference()	차집합: A - B	- 연산자와 동일

---

좋은 질문이야!
결론부터 말하면 👉 .add()는 아주 유용하고 필수적인 메서드야. 안 쓰면 안 돼!
단지 언제, 무엇을 넣느냐에 따라 주의할 점이 있는 것뿐이야.

---

✅ .add()는 뭐야?

s = set()
s.add(3)
print(s)  # 출력: {3}

• set에 하나의 원소를 추가하는 메서드야.
• .append()는 리스트에서 쓰는 거고, set에서는 **무조건 .add()**를 써야 해.

---

❗ 그럼 어떤 경우에 문제가 생겨?

집합은 "hashable"한 값만 가질 수 있어.
즉, 변경 가능한 자료형(mutable) 은 집합에 넣을 수 없어.

⚠️ 이런 건 안 됨:

s = set()
s.add([1, 2])  # ❌ TypeError 발생: list는 unhashable

• 리스트 [1, 2]는 내부 값을 바꿀 수 있으므로 집합 원소로 못 써.

---

✅ 반면, 이런 건 다 됨:

s.add(42)            # int ✔
s.add("hello")       # str ✔
s.add((1, 2))        # tuple ✔
s.add((1, [2]))      # ❌ 리스트 포함된 튜플 → 안 됨!

자료형	가능 여부	이유
int	✅	변경 불가능 (immutable)
str	✅	변경 불가능
tuple	✅	튜플 안에 있는 것도 다 immutable이면 가능
list	❌	변경 가능 (mutable → unhashable)
dict	❌	mutable

---

📌 정리: .add()는 이렇게 쓰면 된다

s = set()

# 올바른 사용
s.add(1)
s.add("hi")
s.add((1, 2))

# 잘못된 사용 (오류)
s.add([1, 2])     # ❌ 리스트는 안 됨
s.add({'a': 1})   # ❌ 딕셔너리도 안 됨

---

✅ 실제 실전에서는 이런 식으로 자주 써

중복 없는 값 수집:

unique_words = set()
for word in ["apple", "banana", "apple"]:
    unique_words.add(word)

print(unique_words)  # {''banana' , apple'}

---

💡 요약 요점 정리

질문	답변
.add() 써도 되나요?	당연히 Yes. 꼭 필요한 메서드입니다.
언제 문제 생기나요?	**mutable (list, dict 등)**을 넣으려 할 때
그럴 땐 어떻게 해야 하나요?	tuple, int, str 등 immutable 자료형만 사용

---

좋아! .difference()는 집합(set)에서 정말 자주 쓰이지만, 의외로 개념이 헷갈리는 부분이 많아.
특히 .intersection(), .union(), - 연산자와의 차이까지 알고 있으면 실무나 시험에서도 완벽하게 대비할 수 있어.

---

✅ .difference()는 뭐 하는 메서드야?

한 집합에서 다른 집합에 있는 원소를 빼고,
남은 원소만 반환하는 연산이야.
즉, 차집합(Difference) 연산!

---

📌 기본 문법

A.difference(B)

• A에 있지만, B에는 없는 것만 남겨서 반환해 줘.

---

🔍 예제 1: 기본 차집합

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
result = A.difference(B)
print(result)

✅ 출력 결과:

{1, 2}

🔍 해석:

• A에는 1, 2, 3, 4
• B에는 3, 4, 5, 6
• 공통인 3, 4를 제외하고 A에만 있는 1, 2만 남음

---

✅ .difference() vs - 연산자

이 둘은 결과는 같음:

A - B               ↔      A.difference(B)

둘 다 A에서 B를 빼는 거야.

---

🔍 예제 2: 반대 방향

B.difference(A)

이건 B에서 A를 빼는 거야!

B = {3, 4, 5, 6}
A = {1, 2, 3, 4}
→ B - A = {5, 6}

---

✅ 시각적 표현

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

A.difference(B) → {1, 2}
B.difference(A) → {5, 6}

---

🔍 예제 3: 여러 집합에 대해 사용

A = {1, 2, 3, 4, 5}
B = {2, 3}
C = {1, 4}

print(A.difference(B, C))

✅ 결과:

{5}

→ A에서 B와 C에 들어있는 값 전부 제거
→ 1, 2, 3, 4 제거 → 5만 남음

---

✅ 원본을 바꾸는 .difference_update()

A = {1, 2, 3}
B = {2, 3}
A.difference_update(B)
print(A)   # {1}

• .difference()는 새로운 집합 반환
• .difference_update()는 기존 집합에서 값 제거

---

🚩 차이 비교 요약표

연산/메서드	기능 요약	원본 변경 여부
A - B	A에서 B를 뺀 차집합	❌ 변경 안 함
A.difference(B)	같은 의미	❌ 변경 안 함
A.difference_update(B)	차집합을 A에 적용해 제거함	✅ A가 바뀜

---

💡 실전 활용 예시

중복 없이 리스트에만 있는 값 뽑기

lst = [1, 2, 3, 4]
forbidden = {2, 4}
allowed = set(lst).difference(forbidden)
print(allowed)  # {1, 3}

---

✅ 마무리 요약

질문	설명
.difference()는?	A - B, 즉 A에서 B에 있는 걸 빼고 남은 걸 반환
- 연산자랑 같은가?	✅ 같음 (둘 다 차집합)
difference_update()는?	❗ A 자체를 바꿔버리는 버전 (A = A - B가 아님, A 자체 변경됨)
여러 개도 될까?	✅ A.difference(B, C, ...) 식으로 여러 집합에서 한 번에 제거 가능

---

좋아! 방금 배운 .difference()와 관련된 지식을 바탕으로 실기 스타일 낚시 문제를 새롭게 내줄게.
이번엔 그냥 단순히 A - B 말고, 구조나 흐름을 이해하지 않으면 틀리는 유형으로 준비했어.

---

🧠 문제: 다음 코드의 출력 결과는?

A = {1, 2, 3, 4, 5}
B = A
C = A.difference({2, 3})
B.difference_update({1, 4})
print("A:", A)
print("B:", B)
print("C:", C)

---

보기:

A: {2, 3, 5}  
B: {2, 3, 5}  
C: {1, 4, 5}

A: {1, 4, 5}  
B: {1, 4, 5}  
C: {1, 4, 5}

A: {1, 2, 3, 4, 5}  
B: {1, 2, 3, 4, 5}  
C: {1, 4, 5}

A: {2, 3, 5}  
B: {2, 3, 5}  
C: {1, 4, 5}

---

✅ 정답: 1번

---

🧠 디버깅 및 해설 (차근차근)

A = {1, 2, 3, 4, 5}

• 집합 A 선언됨
  → A = {1, 2, 3, 4, 5}

---

B = A

• B는 A를 얕은 복사(shallow copy) → A와 B는 같은 집합을 참조함

A ─────▶ {1, 2, 3, 4, 5}
B ─────┘

---

C = A.difference({2, 3})

• difference()는 새 집합 반환, A는 그대로
  → C = {1, 4, 5}
  → A unchanged

---

B.difference_update({1, 4})

• B에서 1과 4 제거
  → 그런데 A와 B는 같은 집합이므로 A도 같이 변경됨

A = B = {2, 3, 5}

C는 기존에 복사한 집합이므로 영향을 안 받음 → 그대로 {1, 4, 5}

---

🔚 최종 결과

A: {2, 3, 5}
B: {2, 3, 5}
C: {1, 4, 5}

---

✅ 이런 문제 포인트는?

핵심 요소	낚시 포인트
B = A	같은 객체 참조라는 걸 놓치면 완전히 틀림
.difference()	원본 변경 안 함, 새 집합 생성
.difference_update()	원본을 직접 수정

---

💡 연습 더 하고 싶으면?

• copy() vs = 의 차이로 set 복사하기
• .intersection_update()를 끼워넣어 혼란 유도
• set + list + dict가 섞인 구조에서 순서 없는 동작 분석

---