1. set 생성
집합 = {값1, 값2, 값3}
집합 = set(반복가능한값)
중복을 허용하지 않는 자료형
nums = {1, 2, 3}
print(nums) # {1, 2, 3}
nums = set([1, 2, 2, 3])
print(nums) # {1, 2, 3}
# 주의: 빈 set은 {}가 아니라 set()
empty = set()
print(empty) # set()
empty = {}
print(type(empty)) # <class 'dict'>
2. add()
집합.add(값)
집합에 값 하나 추가
nums = {1, 2, 3}
nums.add(4)
print(nums) # {1, 2, 3, 4}
# 주의: 이미 있는 값은 추가되지 않음
nums = {1, 2, 3}
nums.add(2)
print(nums) # {1, 2, 3}
3. update()
집합.update(반복가능한값)
집합에 여러 값 추가
nums = {1, 2}
nums.update([3, 4])
print(nums) # {1, 2, 3, 4}
# 주의: 문자열은 한 글자씩 추가됨
chars = {"a"}
chars.update("bc")
print(chars) # {'a', 'b', 'c'}
4. remove()
집합.remove(값)
특정 값 제거
nums = {1, 2, 3}
nums.remove(2)
print(nums) # {1, 3}
# 주의: 없는 값을 제거하면 에러 발생
nums = {1, 2, 3}
nums.remove(10) # KeyError
5. discard()
집합.discard(값)
특정 값 제거
nums = {1, 2, 3}
nums.discard(2)
print(nums) # {1, 3}
# 주의: 없는 값을 제거해도 에러가 나지 않음
nums = {1, 2, 3}
nums.discard(10)
print(nums) # {1, 2, 3}
6. pop()
집합.pop()
임의의 값 제거 후 반환
nums = {1, 2, 3}
result = nums.pop()
print(result)
print(nums)
# 주의: set은 순서가 없어서 어떤 값이 제거될지 예측하면 안 됨
nums = {1, 2, 3}
nums.pop()
print(nums)
7. clear()
집합.clear()
집합 전체 비우기
nums = {1, 2, 3}
nums.clear()
print(nums) # set()
# 주의: 원본 집합이 직접 변경됨
nums = {1, 2, 3}
result = nums.clear()
print(nums) # set()
print(result) # None
8. union()
집합1.union(집합2)
집합1 | 집합2
합집합 구하기
a = {1, 2, 3}
b = {3, 4, 5}
result = a.union(b)
print(result) # {1, 2, 3, 4, 5}
print(a | b) # {1, 2, 3, 4, 5}
# 주의: 원본 집합은 변경되지 않음
a = {1, 2}
b = {3, 4}
a.union(b)
print(a) # {1, 2}
9. intersection()
집합1.intersection(집합2)
집합1 & 집합2
교집합 구하기
a = {1, 2, 3}
b = {3, 4, 5}
result = a.intersection(b)
print(result) # {3}
print(a & b) # {3}
# 주의: 공통 값이 없으면 빈 set 반환
a = {1, 2}
b = {3, 4}
print(a & b) # set()
10. difference()
집합1.difference(집합2)
집합1 - 집합2
차집합 구하기
a = {1, 2, 3}
b = {3, 4, 5}
result = a.difference(b)
print(result) # {1, 2}
print(a - b) # {1, 2}
# 주의: 방향에 따라 결과가 다름
a = {1, 2, 3}
b = {3, 4, 5}
print(a - b) # {1, 2}
print(b - a) # {4, 5}
11. symmetric_difference()
집합1.symmetric_difference(집합2)
집합1 ^ 집합2
대칭 차집합 구하기
두 집합 중 한쪽에만 있는 값 반환
a = {1, 2, 3}
b = {3, 4, 5}
result = a.symmetric_difference(b)
print(result) # {1, 2, 4, 5}
print(a ^ b) # {1, 2, 4, 5}
# 주의: 양쪽에 모두 있는 값은 제외됨
a = {1, 2, 3}
b = {3, 4, 5}
print(a ^ b) # {1, 2, 4, 5}
12. issubset()
집합1.issubset(집합2)
집합1 <= 집합2
집합1이 집합2의 부분집합인지 확인
a = {1, 2}
b = {1, 2, 3}
print(a.issubset(b)) # True
print(a <= b) # True
# 주의: 모든 값이 포함되어 있어야 True
a = {1, 4}
b = {1, 2, 3}
print(a <= b) # False
13. issuperset()
집합1.issuperset(집합2)
집합1 >= 집합2
집합1이 집합2를 포함하는지 확인
a = {1, 2, 3}
b = {1, 2}
print(a.issuperset(b)) # True
print(a >= b) # True
# 주의: 하나라도 빠지면 False
a = {1, 2}
b = {1, 2, 3}
print(a >= b) # False
14. isdisjoint()
집합1.isdisjoint(집합2)
두 집합에 공통 값이 없는지 확인
a = {1, 2}
b = {3, 4}
print(a.isdisjoint(b)) # True
# 주의: 공통 값이 하나라도 있으면 False
a = {1, 2}
b = {2, 3}
print(a.isdisjoint(b)) # False
15. len()
len(집합)
집합의 길이 확인
nums = {1, 2, 3}
print(len(nums)) # 3
# 주의: 중복 값은 하나로 처리됨
nums = {1, 1, 2, 2, 3}
print(nums) # {1, 2, 3}
print(len(nums)) # 3
16. copy()
집합.copy()
집합 복사
# 성공: 집합 복사
nums = {1, 2, 3}
copied = nums.copy()
print(copied) # {1, 2, 3}
# 성공: 서로 다른 객체
nums = {1, 2, 3}
copied = nums.copy()
copied.add(4)
print(nums) # {1, 2, 3}
print(copied) # {1, 2, 3, 4}
# 주의: set 안에는 변경 가능한 값은 넣을 수 없음
data = {[1, 2], [3, 4]} # TypeError
17. in
값 in 집합
집합 안에 값이 있는지 확인
# 성공: 값이 있으면 True
nums = {1, 2, 3}
print(2 in nums) # True
# 성공: 값이 없으면 False
nums = {1, 2, 3}
print(10 in nums) # False
# 주의: 리스트보다 set에서 검색이 빠른 편
nums = {1, 2, 3}
print(3 in nums) # True
18. not in
값 not in 집합
집합 안에 값이 없는지 확인
# 성공: 값이 없으면 True
nums = {1, 2, 3}
print(10 not in nums) # True
# 성공: 값이 있으면 False
nums = {1, 2, 3}
print(2 not in nums) # False
19. frozenset()
frozenset(반복가능한값)
수정할 수 없는 집합 생성
# 성공: 변경 불가능한 집합 생성
nums = frozenset([1, 2, 3])
print(nums) # frozenset({1, 2, 3})
# 성공: set 안에 frozenset은 넣을 수 있음
data = {frozenset([1, 2]), frozenset([3, 4])}
print(data) # {frozenset({1, 2}), frozenset({3, 4})}
# 주의: add(), remove() 사용 불가
nums = frozenset([1, 2, 3])
nums.add(4) # AttributeError
20. set 특징 정리
집합 = {값1, 값2, 값3}
set은 중복이 없고 순서가 없는 자료형
# 성공: 중복 자동 제거
nums = {1, 1, 2, 2, 3}
print(nums) # {1, 2, 3}
# 주의: 순서가 보장되지 않음
nums = {3, 1, 2}
print(nums) # 출력 순서를 믿으면 안 됨
# 주의: 인덱싱 불가
nums = {1, 2, 3}
print(nums[0]) # TypeError
21. list → set 변환
set(리스트)
리스트의 중복 제거
# 성공: 리스트 중복 제거
nums = [1, 1, 2, 2, 3]
result = set(nums)
print(result) # {1, 2, 3}
# 주의: 순서는 유지되지 않음
nums = [3, 1, 2, 1]
result = set(nums)
print(result) # 순서 보장 안 됨
22. set → list 변환
list(집합)
집합을 리스트로 변환
# 성공: set을 list로 변환
nums = {1, 2, 3}
result = list(nums)
print(result) # [1, 2, 3]
# 주의: 변환된 리스트의 순서는 보장되지 않음
nums = {3, 1, 2}
result = list(nums)
print(result)
23. set comprehension
{표현식 for 변수 in 반복가능한값}
조건에 맞는 set 생성
# 성공: 제곱값으로 set 생성
nums = {1, 2, 3}
result = {num * num for num in nums}
print(result) # {1, 4, 9}
# 성공: 중복은 자동 제거됨
nums = [1, 1, 2, 2, 3]
result = {num for num in nums}
print(result) # {1, 2, 3}
# 주의: {}는 빈 set이 아니라 빈 dict
result = {}
print(type(result)) # <class 'dict'>
24. union_update 느낌: update()
집합1.update(집합2)
집합1에 집합2의 값을 추가
즉, 원본 집합이 합집합처럼 변경됨
# 성공: 원본 집합에 값 추가
a = {1, 2}
b = {2, 3, 4}
a.update(b)
print(a) # {1, 2, 3, 4}
# 주의: 원본 집합이 직접 변경됨
a = {1, 2}
b = {3, 4}
result = a.update(b)
print(a) # {1, 2, 3, 4}
print(result) # None
25. intersection_update()
집합1.intersection_update(집합2)
교집합 결과로 원본 집합 변경
# 성공: 공통 값만 남김
a = {1, 2, 3}
b = {2, 3, 4}
a.intersection_update(b)
print(a) # {2, 3}
# 주의: 원본 집합이 직접 변경됨
a = {1, 2, 3}
b = {4, 5}
a.intersection_update(b)
print(a) # set()
26. difference_update()
집합1.difference_update(집합2)
차집합 결과로 원본 집합 변경
# 성공: b에 있는 값을 a에서 제거
a = {1, 2, 3}
b = {2, 4}
a.difference_update(b)
print(a) # {1, 3}
# 주의: 원본 집합이 직접 변경됨
a = {1, 2, 3}
b = {1, 2, 3}
a.difference_update(b)
print(a) # set()
27. symmetric_difference_update()
집합1.symmetric_difference_update(집합2)
대칭 차집합 결과로 원본 집합 변경
# 성공: 한쪽에만 있는 값으로 변경
a = {1, 2, 3}
b = {3, 4, 5}
a.symmetric_difference_update(b)
print(a) # {1, 2, 4, 5}
# 주의: 양쪽에 모두 있는 값은 제거됨
a = {1, 2, 3}
b = {2, 3, 4}
a.symmetric_difference_update(b)
print(a) # {1, 4}
28. | 연산자
집합1 | 집합2
합집합
# 성공: 두 집합의 모든 값
a = {1, 2}
b = {2, 3}
print(a | b) # {1, 2, 3}
# 주의: 중복 값은 하나만 남음
a = {1, 1, 2}
b = {2, 3}
print(a | b) # {1, 2, 3}
29. & 연산자
집합1 & 집합2
교집합
# 성공: 공통 값만 반환
a = {1, 2, 3}
b = {2, 3, 4}
print(a & b) # {2, 3}
# 주의: 공통 값이 없으면 빈 set
a = {1, 2}
b = {3, 4}
print(a & b) # set()
30. - 연산자
집합1 - 집합2
차집합
# 성공: a에는 있고 b에는 없는 값
a = {1, 2, 3}
b = {2, 4}
print(a - b) # {1, 3}
# 주의: 순서에 따라 결과가 달라짐
a = {1, 2, 3}
b = {2, 4}
print(a - b) # {1, 3}
print(b - a) # {4}
31. ^ 연산자
집합1 ^ 집합2
대칭 차집합
# 성공: 한쪽에만 있는 값
a = {1, 2, 3}
b = {3, 4, 5}
print(a ^ b) # {1, 2, 4, 5}
# 주의: 양쪽에 모두 있는 값은 제외
a = {1, 2, 3}
b = {2, 3, 4}
print(a ^ b) # {1, 4}
32. |= 연산자
집합1 |= 집합2
합집합 결과로 원본 집합 변경
# 성공: a에 b의 값을 추가
a = {1, 2}
b = {2, 3}
a |= b
print(a) # {1, 2, 3}
# 주의: 원본 집합이 직접 변경됨
a = {1, 2}
b = {3, 4}
result = a |= b # SyntaxError
33. &= 연산자
집합1 &= 집합2
교집합 결과로 원본 집합 변경
# 성공: 공통 값만 남김
a = {1, 2, 3}
b = {2, 3, 4}
a &= b
print(a) # {2, 3}
# 주의: 원본 집합이 직접 변경됨
a = {1, 2}
b = {3, 4}
a &= b
print(a) # set()
34. -= 연산자
집합1 -= 집합2
차집합 결과로 원본 집합 변경
# 성공: b에 있는 값을 a에서 제거
a = {1, 2, 3}
b = {2, 4}
a -= b
print(a) # {1, 3}
# 주의: 원본 집합이 직접 변경됨
a = {1, 2, 3}
b = {1, 2, 3}
a -= b
print(a) # set()
35. ^= 연산자
집합1 ^= 집합2
대칭 차집합 결과로 원본 집합 변경
# 성공: 한쪽에만 있는 값으로 변경
a = {1, 2, 3}
b = {3, 4, 5}
a ^= b
print(a) # {1, 2, 4, 5}
# 주의: 양쪽에 모두 있는 값은 제거됨
a = {1, 2, 3}
b = {2, 3, 4}
a ^= b
print(a) # {1, 4}
36. ==
집합1 == 집합2
두 집합이 같은지 비교
# 성공: 순서가 달라도 값이 같으면 True
a = {1, 2, 3}
b = {3, 2, 1}
print(a == b) # True
# 주의: 값이 하나라도 다르면 False
a = {1, 2, 3}
b = {1, 2, 4}
print(a == b) # False
37. !=
집합1 != 집합2
두 집합이 다른지 비교
# 성공: 값이 다르면 True
a = {1, 2, 3}
b = {1, 2, 4}
print(a != b) # True
# 주의: 순서만 다른 것은 다른 집합이 아님
a = {1, 2, 3}
b = {3, 2, 1}
print(a != b) # False
38. <
집합1 < 집합2
집합1이 집합2의 진부분집합인지 확인
# 성공: a가 b의 진부분집합
a = {1, 2}
b = {1, 2, 3}
print(a < b) # True
# 주의: 두 집합이 같으면 False
a = {1, 2}
b = {1, 2}
print(a < b) # False
39. >
집합1 > 집합2
집합1이 집합2의 진상위집합인지 확인
# 성공: a가 b를 완전히 포함하고 더 큼
a = {1, 2, 3}
b = {1, 2}
print(a > b) # True
# 주의: 두 집합이 같으면 False
a = {1, 2}
b = {1, 2}
print(a > b) # False
40. <=
집합1 <= 집합2
집합1이 집합2의 부분집합인지 확인
# 성공: 모든 값이 포함되면 True
a = {1, 2}
b = {1, 2, 3}
print(a <= b) # True
# 성공: 같은 집합도 True
a = {1, 2}
b = {1, 2}
print(a <= b) # True
# 주의: 하나라도 없으면 False
a = {1, 4}
b = {1, 2, 3}
print(a <= b) # False
41. >=
집합1 >= 집합2
집합1이 집합2를 포함하는지 확인
# 성공: 모든 값을 포함하면 True
a = {1, 2, 3}
b = {1, 2}
print(a >= b) # True
# 성공: 같은 집합도 True
a = {1, 2}
b = {1, 2}
print(a >= b) # True
# 주의: 하나라도 빠지면 False
a = {1, 2}
b = {1, 2, 3}
print(a >= b) # False
42. set + 반복문
for 변수 in 집합:
집합 반복 처리
# 성공: 모든 값 출력
nums = {1, 2, 3}
for num in nums:
print(num)
# 주의: set은 순서가 보장되지 않음
nums = {1, 2, 3}
for num in nums:
print(num)
43. set comprehension + 조건문
{표현식 for 변수 in 반복가능한값 if 조건}
조건에 맞는 값만 set 생성
# 성공: 짝수만 저장
nums = [1, 2, 3, 4, 5, 6]
result = {num for num in nums if num % 2 == 0}
print(result) # {2, 4, 6}
# 성공: 중복 제거도 자동 처리
nums = [1, 1, 2, 2, 3, 4]
result = {num for num in nums if num % 2 == 0}
print(result) # {2, 4}
44. set 길이 비교
len(set(리스트)) != len(리스트)
중복 존재 여부 확인
# 성공: 중복 있음
nums = [1, 2, 2, 3]
print(len(set(nums))) # 3
print(len(nums)) # 4
# 성공: 중복 없음
nums = [1, 2, 3]
print(len(set(nums)) == len(nums)) # True
# 주의: 문자열도 가능
text = "hello"
print(set(text)) # {'h', 'e', 'l', 'o'}
45. set으로 중복 제거
list(set(리스트))
리스트 중복 제거
# 성공: 중복 제거
nums = [1, 1, 2, 2, 3]
result = list(set(nums))
print(result) # [1, 2, 3]
# 주의: 순서가 유지되지 않음
nums = [3, 1, 2, 1]
result = list(set(nums))
print(result)
46. 순서 유지 중복 제거
list(dict.fromkeys(리스트))
순서를 유지하면서 중복 제거
# 성공: 순서 유지
nums = [3, 1, 2, 1, 3]
result = list(dict.fromkeys(nums))
print(result) # [3, 1, 2]
# 주의: set()과 결과가 다를 수 있음
nums = [3, 1, 2, 1]
print(list(set(nums)))
print(list(dict.fromkeys(nums)))
47. immutable 값만 저장 가능
집합 = {immutable 값}
변경 불가능한 값만 저장 가능
# 성공: 숫자 저장 가능
nums = {1, 2, 3}
print(nums)
# 성공: 문자열 저장 가능
fruits = {"apple", "banana"}
print(fruits)
# 주의: 리스트는 저장 불가
data = {[1, 2], [3, 4]} # TypeError
# 성공: tuple은 저장 가능
data = {(1, 2), (3, 4)}
print(data)
48. set 정렬
sorted(집합)
정렬된 리스트 반환
# 성공: 오름차순 정렬
nums = {3, 1, 2}
result = sorted(nums)
print(result) # [1, 2, 3]
# 성공: 내림차순 정렬
nums = {3, 1, 2}
result = sorted(nums, reverse=True)
print(result) # [3, 2, 1]
# 주의: 결과는 list 타입
nums = {3, 1, 2}
result = sorted(nums)
print(type(result)) # <class 'list'>
49. set + enumerate()
enumerate(집합)
집합 반복 시 번호와 함께 사용
# 성공: index와 값 함께 출력
nums = {10, 20, 30}
for idx, value in enumerate(nums):
print(idx, value)
# 주의: set은 순서가 없어서 index 의미를 믿으면 안 됨
nums = {10, 20, 30}
for idx, value in enumerate(nums):
print(idx, value)
50. set + unpacking
a, b, c = 집합
집합 값 언패킹
# 성공: 값 개수가 맞으면 가능
nums = {1, 2, 3}
a, b, c = nums
print(a, b, c)
# 주의: 순서가 보장되지 않음
nums = {"apple", "banana", "orange"}
a, b, c = nums
print(a, b, c)
# 주의: 개수가 다르면 에러 발생
nums = {1, 2}
a, b, c = nums # ValueError
51. set + if문
if 값 in 집합:
특정 값 존재 여부 확인
# 성공: 값이 있으면 실행
nums = {1, 2, 3}
if 2 in nums:
print("존재함")
# 성공: 값이 없으면 실행 안 됨
nums = {1, 2, 3}
if 10 in nums:
print("존재함")
52. 빈 set 확인
if not 집합:
집합이 비어있는지 확인
# 성공: 빈 set이면 True
nums = set()
if not nums:
print("비어있음")
# 성공: 값이 있으면 False
nums = {1, 2, 3}
if not nums:
print("비어있음")
# 주의: {}는 빈 dict
nums = {}
print(type(nums)) # <class 'dict'>
53. set + max()
max(집합)
가장 큰 값 반환
# 성공: 최대값 반환
nums = {1, 5, 3}
print(max(nums)) # 5
# 성공: 문자열도 가능
fruits = {"apple", "banana", "orange"}
print(max(fruits))
# 주의: 빈 set이면 에러 발생
nums = set()
max(nums) # ValueError
54. set + min()
min(집합)
가장 작은 값 반환
# 성공: 최소값 반환
nums = {1, 5, 3}
print(min(nums)) # 1
# 성공: 문자열도 가능
fruits = {"apple", "banana", "orange"}
print(min(fruits))
# 주의: 빈 set이면 에러 발생
nums = set()
min(nums) # ValueError
55. set + sum()
sum(집합)
모든 값 합계
# 성공: 숫자 전체 합
nums = {1, 2, 3}
print(sum(nums)) # 6
# 성공: 중복은 이미 제거된 상태
nums = {1, 1, 2, 2, 3}
print(sum(nums)) # 6
# 주의: 문자열 포함 시 에러 발생
nums = {1, 2, "3"}
sum(nums) # TypeError
56. set + any()
any(집합)
하나라도 True면 True
# 성공: 하나라도 True 값 존재
nums = {0, False, 3}
print(any(nums)) # True
# 성공: 모두 False 계열이면 False
nums = {0, False}
print(any(nums)) # False
57. set + all()
all(집합)
모든 값이 True면 True
# 성공: 모두 True 계열
nums = {1, 2, 3}
print(all(nums)) # True
# 성공: 하나라도 False 계열이면 False
nums = {1, 0, 3}
print(all(nums)) # False
# 주의: 빈 set은 True 반환
nums = set()
print(all(nums)) # True
58. set 중첩 사용 불가
set 안에 set 저장
일반 set은 다른 set 안에 저장 불가
# 주의: set은 mutable이라 저장 불가
data = {{1, 2}, {3, 4}} # TypeError
# 성공: frozenset은 저장 가능
data = {
frozenset([1, 2]),
frozenset([3, 4])
}
print(data)
59. set 안에 tuple 저장
집합 = {(값1, 값2), (값3, 값4)}
tuple은 변경 불가능하므로 set 안에 저장 가능
# 성공: tuple 저장 가능
points = {(1, 2), (3, 4)}
print(points) # {(1, 2), (3, 4)}
# 성공: 좌표처럼 활용 가능
points = {(0, 0), (1, 2), (3, 4)}
print((1, 2) in points) # True
# 주의: tuple 안에 list가 있으면 저장 불가
data = {(1, [2, 3])} # TypeError
60. set 비교 시 타입 주의
집합 == 다른자료형
set과 다른 자료형은 값이 비슷해 보여도 다름
# 성공: set끼리는 순서가 달라도 같음
a = {1, 2, 3}
b = {3, 2, 1}
print(a == b) # True
# 주의: list와 set은 다름
a = {1, 2, 3}
b = [1, 2, 3]
print(a == b) # False
# 주의: tuple과 set도 다름
a = {1, 2, 3}
b = (1, 2, 3)
print(a == b) # False
61. set에서 중복 제거 후 개수 세기
len(set(반복가능한값))
중복을 제거한 값의 개수 확인
# 성공: 고유 숫자 개수
nums = [1, 1, 2, 2, 3, 4]
result = len(set(nums))
print(result) # 4
# 성공: 문자열의 고유 문자 개수
text = "banana"
result = len(set(text))
print(result) # 3
# 주의: 순서가 필요한 경우 set만 쓰면 안 됨
text = "banana"
print(set(text)) # {'b', 'a', 'n'}
62. set으로 공통 값 찾기
set(값1) & set(값2)
두 데이터에서 공통 값 찾기
# 성공: 두 리스트의 공통 값
a = [1, 2, 3, 4]
b = [3, 4, 5, 6]
result = set(a) & set(b)
print(result) # {3, 4}
# 성공: 두 문자열의 공통 문자
a = "apple"
b = "banana"
result = set(a) & set(b)
print(result) # {'a'}
# 주의: 결과 순서는 보장되지 않음
a = ["apple", "banana"]
b = ["banana", "orange"]
print(set(a) & set(b)) # {'banana'}
63. set으로 차이 찾기
set(값1) - set(값2)
첫 번째 데이터에만 있는 값 찾기
# 성공: a에만 있는 값
a = [1, 2, 3, 4]
b = [3, 4, 5, 6]
result = set(a) - set(b)
print(result) # {1, 2}
# 성공: 문자열 차이
a = "hello"
b = "world"
result = set(a) - set(b)
print(result)
# 주의: 방향이 중요함
a = [1, 2, 3]
b = [3, 4, 5]
print(set(a) - set(b)) # {1, 2}
print(set(b) - set(a)) # {4, 5}
64. set으로 전체 고유 값 찾기
set(값1) | set(값2)
두 데이터의 전체 고유 값 찾기
# 성공: 두 리스트의 전체 고유 값
a = [1, 2, 3]
b = [3, 4, 5]
result = set(a) | set(b)
print(result) # {1, 2, 3, 4, 5}
# 성공: 두 문자열의 전체 고유 문자
a = "ab"
b = "bc"
result = set(a) | set(b)
print(result) # {'a', 'b', 'c'}
# 주의: 중복과 순서는 제거됨
a = [3, 3, 1]
b = [2, 2, 1]
print(set(a) | set(b))
65. set으로 한쪽에만 있는 값 찾기
set(값1) ^ set(값2)
두 데이터 중 한쪽에만 있는 값 찾기
# 성공: 한쪽에만 있는 숫자
a = [1, 2, 3]
b = [3, 4, 5]
result = set(a) ^ set(b)
print(result) # {1, 2, 4, 5}
# 성공: 한쪽에만 있는 문자
a = "abc"
b = "bcd"
result = set(a) ^ set(b)
print(result) # {'a', 'd'}
# 주의: 양쪽에 모두 있는 값은 제외됨
a = [1, 2, 3]
b = [2, 3, 4]
print(set(a) ^ set(b)) # {1, 4}
66. set으로 포함 여부 확인
set(작은값) <= set(큰값)
모든 값이 포함되어 있는지 확인
# 성공: 필요한 값이 모두 있음
required = ["id", "name"]
data = ["id", "name", "email"]
print(set(required) <= set(data)) # True
# 성공: 문자열 포함 여부 확인
required = "abc"
data = "abcdef"
print(set(required) <= set(data)) # True
# 주의: 중복 개수는 고려하지 않음
a = [1, 1, 1]
b = [1]
print(set(a) <= set(b)) # True
67. set으로 중복 검사
len(값) != len(set(값))
중복이 있는지 확인
# 성공: 중복 있음
nums = [1, 2, 2, 3]
if len(nums) != len(set(nums)):
print("중복 있음")
# 성공: 중복 없음
nums = [1, 2, 3]
if len(nums) == len(set(nums)):
print("중복 없음")
# 주의: set으로 바꿀 수 없는 값이 있으면 에러
data = [[1, 2], [1, 2]]
set(data) # TypeError
68. set으로 빠진 값 찾기
set(기준값) - set(현재값)
기준에는 있지만 현재 값에는 없는 항목 찾기
# 성공: 빠진 값 찾기
required = {"id", "name", "email"}
current = {"id", "name"}
missing = required - current
print(missing) # {'email'}
# 성공: 여러 개 빠진 값 찾기
required = {"id", "name", "email", "phone"}
current = {"id"}
missing = required - current
print(missing) # {'name', 'email', 'phone'}
# 주의: 결과 순서는 보장되지 않음
required = {"id", "name", "email"}
current = {"id"}
print(required - current)
69. set으로 불필요한 값 찾기
set(현재값) - set(허용값)
현재 값 중 허용되지 않은 항목 찾기
# 성공: 불필요한 값 찾기
allowed = {"id", "name", "email"}
current = {"id", "name", "age"}
extra = current - allowed
print(extra) # {'age'}
# 성공: 여러 개 찾기
allowed = {"id", "name"}
current = {"id", "name", "age", "phone"}
extra = current - allowed
print(extra) # {'age', 'phone'}
# 주의: 기준 방향이 중요함
allowed = {"id", "name", "email"}
current = {"id", "age"}
print(current - allowed) # {'age'}
print(allowed - current) # {'name', 'email'}
70. set으로 필수값 검증
필수값집합 <= 현재값집합
필수값이 모두 포함되어 있는지 확인
# 성공: 필수값 모두 존재
required = {"id", "name"}
current = {"id", "name", "email"}
if required <= current:
print("필수값 모두 있음")
# 성공: 필수값 누락 확인
required = {"id", "name", "email"}
current = {"id", "name"}
if not required <= current:
print("필수값 누락")
# 주의: 값의 개수는 고려하지 않음
required = {"id", "id"}
current = {"id"}
print(required <= current) # True
71. set으로 허용값 검증
현재값집합 <= 허용값집합
현재 값이 모두 허용된 값인지 확인
# 성공: 모두 허용된 값
allowed = {"read", "write", "delete"}
current = {"read", "write"}
if current <= allowed:
print("허용된 권한만 있음")
# 성공: 허용되지 않은 값 확인
allowed = {"read", "write"}
current = {"read", "admin"}
if not current <= allowed:
print("허용되지 않은 값 있음")
# 주의: 빠진 값 검사가 아니라 초과 값 검사
allowed = {"read", "write", "delete"}
current = {"read"}
print(current <= allowed) # True
72. set으로 공통 태그 찾기
set(태그1) & set(태그2)
두 태그 목록에서 공통 태그 찾기
# 성공: 공통 태그 찾기
post1 = {"python", "backend", "api"}
post2 = {"python", "data", "api"}
common = post1 & post2
print(common) # {'python', 'api'}
# 성공: 공통 태그가 없는 경우
post1 = {"python", "backend"}
post2 = {"frontend", "react"}
common = post1 & post2
print(common) # set()
# 주의: 결과 순서는 보장되지 않음
post1 = {"python", "api"}
post2 = {"api", "python"}
print(post1 & post2)
73. set으로 권한 합치기
권한1 | 권한2
여러 권한을 중복 없이 합치기
# 성공: 권한 합치기
user_roles = {"read", "write"}
group_roles = {"read", "delete"}
roles = user_roles | group_roles
print(roles) # {'read', 'write', 'delete'}
# 성공: 여러 set 합치기
a = {"read"}
b = {"write"}
c = {"delete"}
roles = a | b | c
print(roles) # {'read', 'write', 'delete'}
# 주의: 중복 권한은 하나만 남음
user_roles = {"read", "read"}
group_roles = {"read"}
print(user_roles | group_roles) # {'read'}
74. set으로 공통 권한 찾기
권한1 & 권한2
공통으로 가진 권한 찾기
# 성공: 공통 권한 찾기
admin = {"read", "write", "delete"}
user = {"read", "write"}
common = admin & user
print(common) # {'read', 'write'}
# 성공: 공통 권한 없음
admin = {"delete"}
user = {"read"}
common = admin & user
print(common) # set()
# 주의: 결과가 빈 set인지 확인할 수 있음
common = admin & user
if not common:
print("공통 권한 없음")
75. set으로 권한 차이 찾기
기준권한 - 비교권한
기준에는 있고 비교 대상에는 없는 권한 찾기
# 성공: admin에게만 있는 권한
admin = {"read", "write", "delete"}
user = {"read"}
diff = admin - user
print(diff) # {'write', 'delete'}
# 성공: user에게만 있는 권한
admin = {"read"}
user = {"read", "comment"}
diff = user - admin
print(diff) # {'comment'}
# 주의: 방향에 따라 의미가 달라짐
admin = {"read", "write", "delete"}
user = {"read", "comment"}
print(admin - user) # {'write', 'delete'}
print(user - admin) # {'comment'}
76. set으로 권한 변경점 찾기
기존권한 ^ 새로운권한
기존 권한과 새로운 권한에서 달라진 값 찾기
# 성공: 변경된 권한 찾기
old_roles = {"read", "write"}
new_roles = {"read", "delete"}
changed = old_roles ^ new_roles
print(changed) # {'write', 'delete'}
# 성공: 변경점이 없으면 빈 set
old_roles = {"read", "write"}
new_roles = {"read", "write"}
changed = old_roles ^ new_roles
print(changed) # set()
# 주의: 무엇이 추가/삭제됐는지는 따로 봐야 함
old_roles = {"read", "write"}
new_roles = {"read", "delete"}
added = new_roles - old_roles
removed = old_roles - new_roles
print(added) # {'delete'}
print(removed) # {'write'}
77. set으로 중복 사용자 제거
set(사용자리스트)
사용자 목록에서 중복 제거
# 성공: 중복 사용자 제거
users = ["kim", "lee", "kim", "park"]
unique_users = set(users)
print(unique_users) # {'kim', 'lee', 'park'}
# 성공: 다시 list로 변환
users = ["kim", "lee", "kim", "park"]
unique_users = list(set(users))
print(unique_users)
# 주의: 순서는 유지되지 않음
users = ["kim", "lee", "kim", "park"]
print(list(set(users)))
78. set으로 방문자 수 계산
len(set(방문자리스트))
고유 방문자 수 계산
# 성공: 고유 방문자 수
visitors = ["user1", "user2", "user1", "user3"]
count = len(set(visitors))
print(count) # 3
# 성공: IP 기준 고유 방문자 수
ips = ["10.0.0.1", "10.0.0.2", "10.0.0.1"]
count = len(set(ips))
print(count) # 2
# 주의: 대소문자는 다른 값으로 처리됨
users = ["Kim", "kim", "KIM"]
print(len(set(users))) # 3
79. set으로 공통 사용자 찾기
set(그룹1) & set(그룹2)
두 그룹에 모두 있는 사용자 찾기
# 성공: 공통 사용자 찾기
group_a = ["kim", "lee", "park"]
group_b = ["lee", "choi", "kim"]
common = set(group_a) & set(group_b)
print(common) # {'kim', 'lee'}
# 성공: 공통 사용자가 없으면 빈 set
group_a = ["kim", "lee"]
group_b = ["park", "choi"]
common = set(group_a) & set(group_b)
print(common) # set()
# 주의: 결과 순서는 보장되지 않음
group_a = ["kim", "lee", "park"]
group_b = ["lee", "kim"]
print(set(group_a) & set(group_b))
80. set으로 탈퇴 사용자 찾기
set(이전사용자) - set(현재사용자)
이전에는 있었지만 현재는 없는 사용자 찾기
# 성공: 탈퇴 사용자 찾기
old_users = ["kim", "lee", "park"]
current_users = ["kim", "park"]
left_users = set(old_users) - set(current_users)
print(left_users) # {'lee'}
# 성공: 탈퇴 사용자가 없으면 빈 set
old_users = ["kim", "lee"]
current_users = ["kim", "lee"]
left_users = set(old_users) - set(current_users)
print(left_users) # set()
# 주의: 방향이 반대면 신규 사용자가 됨
old_users = ["kim", "lee"]
current_users = ["kim", "lee", "park"]
print(set(old_users) - set(current_users)) # set()
print(set(current_users) - set(old_users)) # {'park'}
81. set으로 신규 사용자 찾기
set(현재사용자) - set(이전사용자)
현재는 있지만 이전에는 없던 사용자 찾기
# 성공: 신규 사용자 찾기
old_users = ["kim", "lee"]
current_users = ["kim", "lee", "park"]
new_users = set(current_users) - set(old_users)
print(new_users) # {'park'}
# 성공: 신규 사용자가 없으면 빈 set
old_users = ["kim", "lee"]
current_users = ["kim", "lee"]
new_users = set(current_users) - set(old_users)
print(new_users) # set()
# 주의: 탈퇴 사용자와 방향이 반대
old_users = ["kim", "lee", "park"]
current_users = ["kim", "lee"]
print(set(current_users) - set(old_users)) # set()
print(set(old_users) - set(current_users)) # {'park'}
82. set으로 사용자 변경점 찾기
set(이전사용자) ^ set(현재사용자)
신규 사용자와 탈퇴 사용자를 함께 찾기
# 성공: 변경된 사용자 찾기
old_users = ["kim", "lee", "park"]
current_users = ["kim", "choi", "park"]
changed = set(old_users) ^ set(current_users)
print(changed) # {'lee', 'choi'}
# 성공: 변경점 없으면 빈 set
old_users = ["kim", "lee"]
current_users = ["kim", "lee"]
changed = set(old_users) ^ set(current_users)
print(changed) # set()
# 주의: 신규/탈퇴를 구분하려면 따로 계산
old_users = ["kim", "lee", "park"]
current_users = ["kim", "choi", "park"]
new_users = set(current_users) - set(old_users)
left_users = set(old_users) - set(current_users)
print(new_users) # {'choi'}
print(left_users) # {'lee'}
83. set으로 공통 상품 찾기
set(상품목록1) & set(상품목록2)
두 상품 목록에 모두 있는 상품 찾기
# 성공: 공통 상품 찾기
store_a = ["keyboard", "mouse", "monitor"]
store_b = ["mouse", "speaker", "monitor"]
common = set(store_a) & set(store_b)
print(common) # {'mouse', 'monitor'}
# 성공: 공통 상품이 없으면 빈 set
store_a = ["keyboard", "mouse"]
store_b = ["speaker", "monitor"]
common = set(store_a) & set(store_b)
print(common) # set()
# 주의: 결과 순서는 보장되지 않음
print(set(store_a) & set(store_b))
84. set으로 품절 상품 찾기
set(이전상품) - set(현재상품)
이전에는 있었지만 현재는 없는 상품 찾기
# 성공: 품절 상품 찾기
old_items = ["keyboard", "mouse", "monitor"]
current_items = ["keyboard", "mouse"]
sold_out = set(old_items) - set(current_items)
print(sold_out) # {'monitor'}
# 성공: 품절 상품이 없으면 빈 set
old_items = ["keyboard", "mouse"]
current_items = ["keyboard", "mouse"]
sold_out = set(old_items) - set(current_items)
print(sold_out) # set()
# 주의: 방향이 반대면 신규 상품이 됨
print(set(current_items) - set(old_items))
85. set으로 신규 상품 찾기
set(현재상품) - set(이전상품)
현재는 있지만 이전에는 없던 상품 찾기
# 성공: 신규 상품 찾기
old_items = ["keyboard", "mouse"]
current_items = ["keyboard", "mouse", "monitor"]
new_items = set(current_items) - set(old_items)
print(new_items) # {'monitor'}
# 성공: 신규 상품이 없으면 빈 set
old_items = ["keyboard", "mouse"]
current_items = ["keyboard", "mouse"]
new_items = set(current_items) - set(old_items)
print(new_items) # set()
# 주의: 품절 상품과 방향이 반대
print(set(old_items) - set(current_items))
86. set으로 상품 변경점 찾기
set(이전상품) ^ set(현재상품)
신규 상품과 품절 상품을 함께 찾기
# 성공: 변경된 상품 찾기
old_items = ["keyboard", "mouse", "monitor"]
current_items = ["keyboard", "speaker", "monitor"]
changed = set(old_items) ^ set(current_items)
print(changed) # {'mouse', 'speaker'}
# 성공: 변경점이 없으면 빈 set
old_items = ["keyboard", "mouse"]
current_items = ["keyboard", "mouse"]
changed = set(old_items) ^ set(current_items)
print(changed) # set()
# 주의: 신규/품절을 구분하려면 따로 계산
new_items = set(current_items) - set(old_items)
sold_out = set(old_items) - set(current_items)
print(new_items) # {'speaker'}
print(sold_out) # {'mouse'}
87. set으로 금지어 검사
set(문장단어) & set(금지어)
문장에 금지어가 포함되어 있는지 확인
# 성공: 금지어 포함 여부 확인
words = ["hello", "bad", "python"]
banned = {"bad", "spam"}
found = set(words) & banned
print(found) # {'bad'}
# 성공: 금지어가 없으면 빈 set
words = ["hello", "python"]
banned = {"bad", "spam"}
found = set(words) & banned
print(found) # set()
# 주의: 대소문자는 다른 값으로 처리됨
words = ["Bad"]
banned = {"bad"}
print(set(words) & banned) # set()
88. set으로 허용 단어 검사
set(문장단어) <= set(허용단어)
문장의 모든 단어가 허용된 단어인지 확인
# 성공: 모두 허용된 단어
words = ["hello", "python"]
allowed = {"hello", "python", "study"}
print(set(words) <= allowed) # True
# 성공: 허용되지 않은 단어 있음
words = ["hello", "bad"]
allowed = {"hello", "python"}
print(set(words) <= allowed) # False
# 주의: 어떤 단어가 문제인지 보려면 차집합 사용
invalid = set(words) - allowed
print(invalid) # {'bad'}
89. set으로 공통 관심사 찾기
set(관심사1) & set(관심사2)
두 사람의 공통 관심사 찾기
# 성공: 공통 관심사 찾기
user_a = ["python", "movie", "music"]
user_b = ["java", "music", "python"]
common = set(user_a) & set(user_b)
print(common) # {'python', 'music'}
# 성공: 공통 관심사가 없으면 빈 set
user_a = ["python", "movie"]
user_b = ["java", "game"]
common = set(user_a) & set(user_b)
print(common) # set()
# 주의: 결과 순서는 보장되지 않음
print(set(user_a) & set(user_b))
90. set으로 추천 후보 찾기
set(상대방목록) - set(내목록)
상대방에게는 있지만 나에게는 없는 항목 찾기
# 성공: 추천 후보 찾기
my_movies = ["A", "B"]
friend_movies = ["A", "B", "C", "D"]
recommend = set(friend_movies) - set(my_movies)
print(recommend) # {'C', 'D'}
# 성공: 추천 후보가 없으면 빈 set
my_movies = ["A", "B"]
friend_movies = ["A", "B"]
recommend = set(friend_movies) - set(my_movies)
print(recommend) # set()
# 주의: 방향이 바뀌면 내가 가진 것 중 상대가 없는 항목
print(set(my_movies) - set(friend_movies))
'🐍Python' 카테고리의 다른 글
| Python Basic: dict (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 |