[Python Basic] 06. 셋 데이터 타입(Set Datatype)

0. 셋 타입의 특징과 정의

셋 타입은 다른 자료형과 다르게 중복된 아이템의 자동 제거와 순서 없음이라는 특징을 가지고 있다. 

셋 타입의 할당은 ({ })로 할 수 있으며, 각각의 아이템은 콤마(,)를 통하여 구분할 수 있다. 

 

1. 셋 타입의 연산

1) 셋타입은 교집합(.intersection or &), 합집합(.union or |), 차집합(.difference or -), 대칭(.symmetic_differece or ^) 연산을 통하여 처리가 가능하다. 특히 주의해야 할 내용은 차집합에서 함수와 연산자의 차이를 정확히 이해하여야 다른 결과의 연산이 나타나지 않는다. 

2) 슈퍼셋(.issuperset or >=), 서버셋(.issubset or <=), 분리(.isdisjoint)의 함수의 사용으로 셋의 관계를 확인할 수 있다. 

3) 하나의 원소와 셋비교(in) 연산자를 이용하여 관계 확인 할 수 있다. 

4) 추가(.add), 제거(.discard), 삭제(.remove)함수를 이용하여 셋에 원소를 더하거나 제거 할 수 있다. 특히 주의해야 할 내용은 .remove 실행시 셋의 원소에 값이 없을 경우 Key error를 발생한다. 

5) 교집합 연산후 값 변환(.intersection_update or &=), 합집합 연산후 값 변환(.update or |=), 차집합 연산 후 값 변환(.difference_update or -=) 연산을 통하여 계산 후 값을 저장하는 기능을 수행 할 수 있다.

 

교집합 연산은 .intersection 또는 & 를 통하여 처리가 가능하다. 

# 06_00_PythonSetDataTypes

FirstSetData =  {1, 2, 3, 4, 5, 6}
SecondSetData = {3, 4, 5, 6, 7, 8}
ThirdSetData =  {5, 6, 7, 8, 9, 10}
FirstSubSet = {3, 4}
FirstSuperSet = {1, 2, 3, 4, 5, 6, 7, 8}
FirstDisjoint = {7, 8, 9, 10}
UnionSetData = {11, 12}
UnionSetData1 = {11, 12}
IntersectionSetData = {9, 10, 11, 12}
IntersectionSetData1 = {9, 10, 11, 12}
DifferenceSetData = {9, 10, 11, 12, 13}
DifferenceSetData1 = {9, 10, 11, 12, 13}

print(type(FirstSetData))           # <class 'set'>
print(type(SecondSetData))          # <class 'set'>
print(type(ThirdSetData))           # <class 'set'>

# 교집합 연산(Intersection)
print(FirstSetData.intersection(SecondSetData))                             # {3, 4, 5, 6}     
print(FirstSetData & SecondSetData)                                         # {3, 4, 5, 6}
print(FirstSetData.intersection(SecondSetData.intersection(ThirdSetData)))  # {5, 6}
print(FirstSetData & SecondSetData&ThirdSetData)                            # {5, 6}

# 합집합 연산(Union)
print(FirstSetData.union(SecondSetData))                                    # {1, 2, 3, 4, 5, 6, 7, 8}
print(FirstSetData | SecondSetData)                                         # {1, 2, 3, 4, 5, 6, 7, 8}
print(FirstSetData.union(SecondSetData.union(ThirdSetData)))                # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
print(FirstSetData | SecondSetData | ThirdSetData)                          # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

# 차집합 연산(Difference)
print(FirstSetData.difference(SecondSetData))                               # {1, 2}
print(FirstSetData - SecondSetData)                                         # {1, 2}
print(FirstSetData.difference(SecondSetData.difference(ThirdSetData)))      # {1, 2, 5, 6}
print(FirstSetData - SecondSetData - ThirdSetData)                          # {1, 2}

# 대칭 연산(Symmetic differece with)
print(FirstSetData.symmetric_difference(SecondSetData))                     # {1, 2, 7, 8}
print(FirstSetData ^ SecondSetData)                                         # {1, 2, 7, 8}
print(FirstSetData.symmetric_difference(SecondSetData.symmetric_difference(ThirdSetData)))  # {1, 2, 5, 6, 9, 10}
print(FirstSetData ^ SecondSetData ^ ThirdSetData)                                          # {1, 2, 5, 6, 9, 10}

# 슈퍼셋 확인(Superset check)
print(FirstSetData.issuperset(FirstSubSet))     # True
print(FirstSetData >= FirstSubSet)              # True
print(FirstSetData.issuperset(FirstSuperSet))   # False
print(FirstSetData >= FirstSuperSet)            # False

# 서브셋 확인(Subset check)
print(FirstSetData.issubset(FirstSubSet))       # False
print(FirstSetData <= FirstSubSet)              # False
print(FirstSetData.issubset(FirstSuperSet))     # True
print(FirstSetData <= FirstSuperSet)            # True

# 분리 확인(Disjoint check)
print(FirstSetData.isdisjoint(SecondSetData))   # False
print(FirstSetData.isdisjoint(FirstDisjoint))   # True

# 하나의 데이터 값과 비교 
print( 2 in FirstSetData )  # True

# 추가 
print(FirstSetData.add(7))  # None
print(FirstSetData)         # {1, 2, 3, 4, 5, 6, 7}

# 삭제
FirstSetData.discard(7)
print(FirstSetData)         # {1, 2, 3, 4, 5, 6}
FirstSetData.discard(7)     
print(FirstSetData)         # {1, 2, 3, 4, 5, 6}

#FirstSetData.remove(1)      # {2, 3, 4, 5, 6}
print(FirstSetData)

# 교집합 연산 후 저장
print(IntersectionSetData)      # {9, 10, 11, 12}
IntersectionSetData.intersection_update(ThirdSetData)   
print(IntersectionSetData)      # {9, 10}

print(IntersectionSetData1)     # {9, 10, 11, 12}
IntersectionSetData1 &= ThirdSetData
print(IntersectionSetData1)     # {9, 10}

# 합집합 연산 후 저장
print(UnionSetData)             # {11, 12}
UnionSetData.update(ThirdSetData)
print(UnionSetData)             # {5, 6, 7, 8, 9, 10, 11, 12}

print(UnionSetData1)            # {11, 12}
UnionSetData1 |= ThirdSetData
print(UnionSetData1)            # {5, 6, 7, 8, 9, 10, 11, 12}

# 차집합 연산 후 저장
print(DifferenceSetData)        # {9, 10, 11, 12, 13}
DifferenceSetData.difference_update(ThirdSetData)
print(DifferenceSetData)        # {11, 12, 13}

print(DifferenceSetData1)       # {9, 10, 11, 12, 13}
DifferenceSetData1 -= ThirdSetData
print(DifferenceSetData1)       # {11, 12, 13}

 

2. 특수한 연산 

셋 내에 셋의 형식을 포함할 수는 있으나 frozenset을 사용해야만 추가 가능하나 엄연히 지원하지 않는 연산이 있으므로 주의 해야 한다. 

그외 len 함수로 원소의 갯수를 sum함수로 원소의 합을 구할 수 있다. 

# 06_01_FrozenSetDataType

FirstSetData =  {1, 2, 2, 3, 3, 3, 5, 6}
print(sum(FirstSetData))    # 17
print(type(FirstSetData))   # <class 'set'>

FrozenSetData = {3, 4}      
FirstSetData.add(frozenset(FrozenSetData))
print(type(FrozenSetData))  # <class 'set'>

print(FirstSetData)         # {frozenset({3, 4}), 1, 2, 3, 5, 6}
print(type(FirstSetData))   # <class 'set'>
# print(sum(FirstSetData))  # Error 발생
print(len(FirstSetData))    # 6